diff --git a/.gitignore b/.gitignore
index b99d0325dc4025dc0980b3a4613e1327d3684316..cd299e2268dcf7fae5489505bbc3a1c15cbbac12 100644
--- a/.gitignore
+++ b/.gitignore
@@ -60,18 +60,7 @@ test/connector_c/update
test/connector_c/xlog
test/lib/*.pyc
test/lib/*/*.pyc
-test/unit/base64
-test/unit/bit_test
-test/unit/bitset_basic_test
-test/unit/bitset_iterator_test
-test/unit/bitset_index_test
-test/unit/mhash
-test/unit/rlist
-test/unit/rope
-test/unit/rope_avl
-test/unit/rope_basic
-test/unit/rope_stress
-test/unit/queue
+test/unit/*.test
test/var
third_party/luajit/src/luajit
third_party/luajit/lib/vmdef.lua
diff --git a/.travis.yml b/.travis.yml
index 01a081a5ffb3a905baf0d54a187e6a2022c7ebad..b19d7775abf189261057cb0a329c58542523c86c 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -24,3 +24,6 @@ notifications:
on_success: change
on_failure: always
email: false
+
+git:
+ depth: 500
diff --git a/client/tarantool/CMakeLists.txt b/client/tarantool/CMakeLists.txt
index c8f1a369ac60e870e3beb312771fadf09b82c69c..d03e72375cf7c3bd7f1b30a3afabb4646499cf6b 100644
--- a/client/tarantool/CMakeLists.txt
+++ b/client/tarantool/CMakeLists.txt
@@ -8,7 +8,8 @@ if (NOT READLINE_FOUND)
endif()
set (cli "tarantool")
-set (cli_sources tc.c tc_opt.c tc_admin.c tc_query.c tc_print.c tc_cli.c tc_store.c)
+set (cli_sources tc.c tc_opt.c tc_admin.c tc_query.c tc_print.c tc_buf.c
+ tc_cli.c tc_store.c tc_print_xlog.c tc_print_snap.c)
set (cli_libs tntrpl tntnet tntsql tnt gopt ${READLINE_LIBRARIES})
include_directories(${READLINE_INCLUDE_DIR})
diff --git a/client/tarantool/tc.c b/client/tarantool/tc.c
index ffb96d5c3c7a94e15f3c12dee1c4cc78cf950226..2b190f07b291361f9812fc28099222e376a68173 100644
--- a/client/tarantool/tc.c
+++ b/client/tarantool/tc.c
@@ -45,6 +45,8 @@
#include "client/tarantool/tc.h"
#include "client/tarantool/tc_cli.h"
#include "client/tarantool/tc_print.h"
+#include "client/tarantool/tc_print_snap.h"
+#include "client/tarantool/tc_print_xlog.h"
#include "client/tarantool/tc_store.h"
struct tc tc;
@@ -103,10 +105,15 @@ static void tc_connect_admin(void)
static void tc_validate(void)
{
- tc.opt.printer = tc_print_getcb(tc.opt.format);
- if (tc.opt.printer == NULL)
- return tc_error("unsupported output format '%s'",
+ tc.opt.xlog_printer = tc_print_getxlogcb(tc.opt.format);
+ tc.opt.snap_printer = tc_print_getsnapcb(tc.opt.format);
+ if (tc.opt.xlog_printer == NULL)
+ return tc_error("unsupported output xlog format '%s'",
tc.opt.format);
+ if (tc.opt.snap_printer == NULL)
+ return tc_error("unsupported output snap format '%s'",
+ tc.opt.format);
+
if (tc.opt.format && strcmp(tc.opt.format, "raw") == 0)
tc.opt.raw = 1;
}
diff --git a/client/tarantool/tc_admin.c b/client/tarantool/tc_admin.c
index bdd4a806837c5dd05fbe2f6e2d92e738ac1084a9..7c941ee49c8083d19cce300cecae2d3740b0e031 100644
--- a/client/tarantool/tc_admin.c
+++ b/client/tarantool/tc_admin.c
@@ -115,9 +115,11 @@ int tc_admin_reply(struct tc_admin *a, char **r, size_t *size)
ssize_t rxi = recv(a->fd, rx, sizeof(rx), 0);
if (rxi <= 0)
break;
- char *bufn = realloc(buf, off + rxi + 1);
- if (bufn == NULL)
+ char *bufn = (char *)realloc(buf, off + rxi + 1);
+ if (bufn == NULL) {
+ free(buf);
break;
+ }
buf = bufn;
memcpy(buf + off, rx, rxi);
off += rxi;
diff --git a/client/tarantool/tc_buf.c b/client/tarantool/tc_buf.c
new file mode 100644
index 0000000000000000000000000000000000000000..b4556bb796078d1b86f5b54a84b2146268e22c87
--- /dev/null
+++ b/client/tarantool/tc_buf.c
@@ -0,0 +1,126 @@
+/*
+ * 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 <COPYRIGHT HOLDER> ``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 <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stddef.h>
+#include <ctype.h>
+
+#include "client/tarantool/tc_buf.h"
+
+/* Strip trailing ws from (char*) */
+size_t strip_end_ws(char *str) {
+ size_t last = 0;
+ for (size_t i = 0; str[i] != 0; ++i)
+ if (!isspace(str[i]))
+ last = i + 1;
+ str[last] = '\0';
+ return last;
+}
+
+/* Init membuf */
+int tc_buf(struct tc_buf *buf) {
+ buf->size = TC_BUF_INIT_SIZE;
+ buf->used = 0;
+ buf->data = (char *)malloc(buf->size);
+ if (buf->data == NULL)
+ return -1;
+ return 0;
+}
+
+/* Append len bytes of memory from str pointed memory */
+int tc_buf_append(struct tc_buf *buf, void *str, size_t len) {
+ if (buf->size - buf->used < len) {
+ if (buf->size < len)
+ buf->size = len;
+ buf->size *= TC_BUF_MULTIPLIER;
+ char *nd = (char *)realloc(buf->data, buf->size);
+ if (nd == NULL)
+ return -1;
+ buf->data = nd;
+ }
+ memcpy(buf->data + buf->used, str, len);
+ buf->used += len;
+ return 0;
+}
+
+/* Remove last "num" symbols */
+size_t tc_buf_delete(struct tc_buf *buf, size_t num) {
+ if (buf->used > num) {
+ buf->used -= num;
+ } else {
+ num = buf->used;
+ buf->used = 0;
+ }
+ return num;
+}
+
+inline int tc_buf_isempty(struct tc_buf *buf) {
+ return (buf->used == 0);
+}
+
+inline void tc_buf_clear(struct tc_buf *buf) {
+ buf->used = 0;
+}
+
+/* Free membuffer */
+void tc_buf_free(struct tc_buf *buf) {
+ if (buf->data)
+ free(buf->data);
+}
+
+/* Init buffer as STR */
+int tc_buf_str(struct tc_buf *buf) {
+ if (tc_buf(buf))
+ return -1;
+ return tc_buf_append(buf, (void *)"\0", 1);
+}
+
+/* Append str to STR */
+int tc_buf_str_append(struct tc_buf *buf, char *str, size_t len) {
+ tc_buf_delete(buf, 1);
+ if (tc_buf_append(buf, (void *)str, len))
+ return -1;
+ if (tc_buf_append(buf, (void *)"\0", 1))
+ return -1;
+ return 0;
+}
+
+/* Remove trailing ws from STR */
+int tc_buf_str_stripws(struct tc_buf *buf) {
+ if (buf->data) {
+ buf->used = 1 + strip_end_ws(buf->data);
+ return 0;
+ }
+ return -1;
+}
+
+inline int tc_buf_str_isempty(struct tc_buf *buf) {
+ return (buf->used == 1 ? 1 : 0) || (tc_buf_isempty(buf));
+}
diff --git a/client/tarantool/tc_buf.h b/client/tarantool/tc_buf.h
new file mode 100644
index 0000000000000000000000000000000000000000..52383666e7a7adf1cd869c1e96ff3a4e197d781d
--- /dev/null
+++ b/client/tarantool/tc_buf.h
@@ -0,0 +1,51 @@
+/*
+ * 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 <COPYRIGHT HOLDER> ``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.
+ */
+#define TC_BUF_INIT_SIZE 4096
+#define TC_BUF_MULTIPLIER 2
+
+size_t strip_end_ws(char *str);
+
+struct tc_buf {
+ size_t size;
+ size_t used;
+ char *data;
+};
+
+int tc_buf(struct tc_buf *buf);
+void *tc_buf_realloc(void *data, size_t size);
+int tc_buf_append(struct tc_buf *buf, void *str, size_t len);
+size_t tc_buf_delete(struct tc_buf *buf, size_t len);
+int tc_buf_isempty(struct tc_buf *buf);
+void tc_buf_clear(struct tc_buf *buf);
+void tc_buf_free(struct tc_buf *buf);
+
+int tc_buf_str(struct tc_buf *buf);
+int tc_buf_str_append(struct tc_buf *buf, char *str, size_t len);
+int tc_buf_str_stripws(struct tc_buf *buf);
+int tc_buf_str_isempty(struct tc_buf *buf);
diff --git a/client/tarantool/tc_cli.c b/client/tarantool/tc_cli.c
index efe47330fb0f64b764fd38665ddb6edd2cf9d8dc..b7255ef4c6c195c69f8f8cbb917da4ab96a1ebff 100644
--- a/client/tarantool/tc_cli.c
+++ b/client/tarantool/tc_cli.c
@@ -32,6 +32,7 @@
#include <stdarg.h>
#include <string.h>
#include <stdint.h>
+#include <ctype.h>
#include <sys/types.h>
#include <sys/stat.h>
@@ -39,6 +40,7 @@
#include <fcntl.h>
#include <signal.h>
#include <errno.h>
+#include <wchar.h>
#include <readline/readline.h>
#include <readline/history.h>
@@ -58,9 +60,13 @@
#include "client/tarantool/tc_query.h"
#include "client/tarantool/tc_cli.h"
#include "client/tarantool/tc_print.h"
+#include "client/tarantool/tc_buf.h"
#define TC_DEFAULT_HISTORY_FILE ".tarantool_history"
+#define TC_ALLOCATION_ERROR "error: memory allocation failed for %zu bytes\n"
+#define TC_REALLOCATION_ERROR "error: memory reallocation failed for %zu bytes\n"
+
extern struct tc tc;
static inline int tc_cli_error(char *e) {
@@ -89,7 +95,9 @@ enum tc_keywords {
TC_TEE,
TC_NOTEE,
TC_LOADFILE,
- TC_HELP
+ TC_HELP,
+ TC_SETOPT,
+ TC_SETOPT_DELIM
};
static struct tnt_lex_keyword tc_lex_keywords[] =
@@ -106,6 +114,10 @@ static struct tnt_lex_keyword tc_lex_keywords[] =
{ "tee", 3, TC_TEE },
{ "notee", 5, TC_NOTEE },
{ "loadfile", 8, TC_LOADFILE },
+ { "s", 1, TC_SETOPT},
+ { "setopt", 6, TC_SETOPT},
+ { "delim", 5, TC_SETOPT_DELIM},
+ { "delimiter", 9, TC_SETOPT_DELIM},
{ NULL, 0, TNT_TK_NONE }
};
@@ -125,6 +137,8 @@ tc_cmd_usage(void)
" - tee 'path'\n"
" - notee\n"
" - loadfile 'path'\n"
+ " - setopt key=val\n"
+ " - (possible pairs: delim=\'str\')\n"
"...\n";
tc_printf("%s", usage);
}
@@ -194,9 +208,9 @@ tc_cmd_loadfile(char *path, int *reconnect)
int fd = open(path, O_RDONLY);
if (fd == -1)
return -1;
- char *buf = malloc(st.st_size);
+ char *buf = (char *)malloc(st.st_size);
if (buf == NULL) {
- tc_printf("error: memory allocation failed for %zu bytes\n",
+ tc_printf(TC_ALLOCATION_ERROR,
st.st_size);
return -1;
}
@@ -252,6 +266,37 @@ tc_cmd_try(char *cmd, size_t size, int *reconnect)
if (tc_cmd_loadfile((char*)TNT_TK_S(tk)->data, reconnect) == -1)
rc = TC_CLI_ERROR;
goto done;
+ case TC_SETOPT:
+ switch (tnt_lex(&lex, &tk)) {
+ case TC_SETOPT_DELIM:
+ if (tnt_lex(&lex, &tk) == '=' &&
+ tnt_lex(&lex, &tk) == TNT_TK_STRING) {
+ if (!TNT_TK_S(tk)->size) {
+ tc.opt.delim = "";
+ tc.opt.delim_len = 0;
+ goto done;
+ }
+ char * temp = (char *)malloc(TNT_TK_S(tk)->size);
+ if (temp == NULL)
+ tc_error(TC_ALLOCATION_ERROR,
+ TNT_TK_S(tk)->size);
+ strncpy(temp,
+ (const char *)TNT_TK_S(tk)->data,
+ TNT_TK_S(tk)->size + 1);
+ tc.opt.delim = temp;
+ tc.opt.delim_len = strlen(tc.opt.delim);
+ } else {
+ tc_printf("---\n");
+ tc_printf(" - Expected delim='string'\n");
+ tc_printf("---\n");
+ }
+ break;
+ default:
+ tc_printf("---\n");
+ tc_printf(" - Unknown option to set\n");
+ tc_printf("---\n");
+ }
+ goto done;
}
*reconnect = tc_cli_admin(cmd, rc == TC_CLI_EXIT);
if (*reconnect)
@@ -321,6 +366,56 @@ static void tc_cli_init(void) {
tc_error("signal initialization failed\n");
}
+static char* tc_cli_readline_pipe() {
+ int size = 8192, pos = 0;
+ const size_t wcsize = sizeof(wchar_t);
+ char *str = (char *)malloc(size);
+ if (str == NULL)
+ tc_error(TC_ALLOCATION_ERROR, size);
+ wchar_t c;
+ while ((c = getwchar())) {
+ if (size < (pos + wcsize)) {
+ size *= 2;
+ char *nd = (char *)realloc(str, size);
+ if (nd == NULL)
+ tc_error(TC_REALLOCATION_ERROR, size);
+ str = nd;
+ }
+ if (c == '\r' || c == '\n' || c == WEOF) {
+ char c_t = (c != WEOF ? getchar() : '\n');
+ if (c_t != '\r' && c_t != '\n')
+ ungetc(c_t, stdin);
+ wctomb(str + pos++, 0);
+ break;
+ }
+ else
+ pos += wctomb(str + pos, c);
+ }
+ if (pos == 1 && c == WEOF) {
+ free(str);
+ return NULL;
+ }
+ return str;
+}
+
+
+
+static int check_delim(char* str, size_t len, size_t sep_len) {
+ const char *sep = tc.opt.delim;
+ len = strip_end_ws(str);
+ if (sep_len == 0)
+ return 1;
+ if (len < sep_len)
+ return 0;
+ size_t i;
+ for (i = len; sep_len > 0; --sep_len, --i)
+ if (str[i - 1] != sep[sep_len - 1])
+ return 0;
+ str[i] = '\0';
+ len = strip_end_ws(str);
+ return 1;
+}
+
int tc_cli(void)
{
/* initializing cli */
@@ -335,25 +430,62 @@ int tc_cli(void)
/* setting prompt */
char prompt[128];
- snprintf(prompt, sizeof(prompt), "%s> ", tc.opt.host);
-
+ int prompt_len = snprintf(prompt, sizeof(prompt), "%s> ", tc.opt.host) - 2;
+ char prompt_delim[128];
/* interactive mode */
- char *cmd;
- while ((cmd = readline(prompt))) {
- if (!cmd[0])
- goto next;
- int cmd_len = strlen(cmd);
- tc_print_cmd2tee(prompt, cmd, cmd_len);
- enum tc_cli_cmd_ret ret = tc_cli_cmd(cmd, cmd_len);
- if (ret == TC_CLI_EXIT)
+ char *part_cmd;
+ struct tc_buf cmd;
+ if (tc_buf_str(&cmd))
+ tc_error(TC_REALLOCATION_ERROR,
+ cmd.size);
+ while (1) {
+ if (isatty(STDIN_FILENO)) {
+ snprintf(prompt_delim, sizeof(prompt_delim),
+ "%*s> ", prompt_len, "-");
+ part_cmd = readline(!tc_buf_str_isempty(&cmd) ? prompt_delim
+ : prompt);
+ } else {
+ clearerr(stdin);
+ part_cmd = tc_cli_readline_pipe();
+ }
+ if (!part_cmd)
break;
- add_history(cmd);
+ size_t part_cmd_len = strlen(part_cmd);
+ int delim_exists = check_delim(part_cmd,
+ part_cmd_len,
+ tc.opt.delim_len);
+ if (tc_buf_str_append(&cmd, part_cmd, strlen(part_cmd)))
+ tc_error(TC_REALLOCATION_ERROR,
+ cmd.size);
+ free(part_cmd);
+ if (!delim_exists && !feof(stdin)) {
+ if (tc_buf_str_append(&cmd, " ", 1))
+ tc_error(TC_REALLOCATION_ERROR,
+ cmd.size);
+ continue;
+ }
+ tc_buf_str_stripws(&cmd);
+ if (delim_exists && tc_buf_str_isempty(&cmd))
+ goto next;
+ tc_print_cmd2tee(cmd.used != 1 ? prompt_delim : prompt,
+ cmd.data, cmd.used - 1);
+ enum tc_cli_cmd_ret ret = tc_cli_cmd(cmd.data,
+ cmd.used - 1);
+ if (isatty(STDIN_FILENO))
+ add_history(cmd.data);
next:
- free(cmd);
- }
+ tc_buf_clear(&cmd);
+ if (ret == TC_CLI_EXIT || feof(stdin)) {
+ tc_buf_free(&cmd);
+ break;
+ }
+}
/* updating history file */
write_history(history);
clear_history();
return 0;
}
+
+#undef TC_ALLOCATION_ERROR
+#undef TC_REALLOCATION_ERROR
diff --git a/client/tarantool/tc_opt.c b/client/tarantool/tc_opt.c
index c666b292110c7216f1539657afc8e71f9d8d10d0..331ad3e59a836853b98be0064a95b3f2ab7a94bf 100644
--- a/client/tarantool/tc_opt.c
+++ b/client/tarantool/tc_opt.c
@@ -35,6 +35,7 @@
#include "client/tarantool/tc_opt.h"
+
#define TC_DEFAULT_HOST "localhost"
#define TC_DEFAULT_PORT 33013
#define TC_DEFAULT_PORT_ADMIN 33015
@@ -63,6 +64,14 @@ static const void *tc_options_def = gopt_start(
gopt_longs("header"), NULL, "add file headers for the raw output"),
gopt_option('R', GOPT_ARG, gopt_shorts('R'),
gopt_longs("rpl"), " <lsn>", "act as replica for the specified server"),
+ gopt_option('B', 0, gopt_shorts('B'),
+ gopt_longs("bin"), NULL, "print STR in lua printer instead"
+ " of NUM32 and NUM64, except arithmetic update arguments"),
+ gopt_option('D', GOPT_ARG, gopt_shorts('D'),
+ gopt_longs("delim"), " <delim>",
+ "if you use --cat, then it will add delim to an end of every line of your"
+ "lua file, when used at CLI start of client, then it's replacement of "
+ "setopt delim='<delim>' command"),
gopt_option('?', 0, gopt_shorts(0), gopt_longs("help"),
NULL, "display this help and exit"),
gopt_option('v', 0, gopt_shorts('v'), gopt_longs("version"),
@@ -148,6 +157,17 @@ enum tc_opt_mode tc_opt_init(struct tc_opt *opt, int argc, char **argv)
if (gopt(tc_options, 'H'))
opt->raw_with_headers = 1;
+ /* string instead of num and num64 */
+ opt->str_instead_int = 0;
+ if (gopt(tc_options, 'B'))
+ opt->str_instead_int = 1;
+
+ /* set delimiter on start */
+ opt->delim = "";
+ opt->delim_len = 0;
+ if (gopt_arg(tc_options, 'D', &opt->delim))
+ opt->delim_len = strlen(opt->delim);
+
/* replica mode */
if (gopt_arg(tc_options, 'R', &arg)) {
opt->mode = TC_OPT_RPL;
diff --git a/client/tarantool/tc_opt.h b/client/tarantool/tc_opt.h
index 931e95150fcca5db80b95f7be830216aa784a41c..cef473890b3b1009f4ae54e671bd917537448699 100644
--- a/client/tarantool/tc_opt.h
+++ b/client/tarantool/tc_opt.h
@@ -57,10 +57,14 @@ struct tc_opt {
const char *format;
int raw;
int raw_with_headers;
- void *printer;
+ int str_instead_int;
+ void *xlog_printer;
+ void *snap_printer;
const char *file;
char **cmdv;
int cmdc;
+ const char *delim;
+ size_t delim_len;
};
void tc_opt_usage(void);
diff --git a/client/tarantool/tc_print.c b/client/tarantool/tc_print.c
index 78f64dce43d529773c431ff0c9dbfcffc6546a95..bacdef37eb3d390221cb1e31668df138447d8b0d 100644
--- a/client/tarantool/tc_print.c
+++ b/client/tarantool/tc_print.c
@@ -37,6 +37,7 @@
#include <unistd.h>
#include <errno.h>
+
#include <connector/c/include/tarantool/tnt.h>
#include <connector/c/include/tarantool/tnt_xlog.h>
#include <connector/c/include/tarantool/tnt_rpl.h>
@@ -49,6 +50,8 @@
extern struct tc tc;
+/*##################### Base printing functions #####################*/
+
void tc_print_tee(char *buf, size_t size) {
if (tc.tee_fd == -1)
return;
@@ -95,6 +98,8 @@ void tc_printf(char *fmt, ...) {
}
}
+/*##################### string functions #####################*/
+
static int tc_str_valid(char *data, uint32_t size) {
int length;
wchar_t dest;
@@ -111,19 +116,34 @@ static int tc_str_valid(char *data, uint32_t size) {
return 1;
}
-static void tc_print_str(char *data, uint32_t size) {
+void tc_print_string(char *data, uint32_t size, char lua)
+{
if (tc_str_valid(data, size)) {
wchar_t dest;
int length;
mbtowc (NULL, NULL, 0);
while ((length = mbtowc(&dest, data, size)) > -1 && size > 0) {
if (dest >= 0x20) {
- tc_printf ("%lc", dest);
+ if (lua)
+ switch (dest) {
+ case '\'':
+ tc_printf("\\\'");
+ break;
+ case '\\':
+ tc_printf("\\\\");
+ break;
+ default:
+ tc_printf ("%lc", dest);
+ }
+ else
+ tc_printf ("%lc", dest);
}
else {
switch (dest) {
case 0x00:
tc_printf("\\0");
+ length++;
+ /* Cause of mbtowc returns 0 when \0 */
break;
case 0x07:
tc_printf("\\a");
@@ -147,12 +167,10 @@ static void tc_print_str(char *data, uint32_t size) {
tc_printf("\\r");
break;
default:
- tc_printf("\\x%02lX",
+ tc_printf("\\x%02lX",
(unsigned long int)dest);
break;
}
- if (length == 0)
- ++length;
}
size -= length;
data += length;
@@ -166,7 +184,11 @@ static void tc_print_str(char *data, uint32_t size) {
}
}
-static void tc_print_fields(struct tnt_tuple *tu) {
+/*##################### Tuple and Fields #####################*/
+/* tarantool */
+
+void tc_print_fields(struct tnt_tuple *tu)
+{
struct tnt_iter ifl;
tnt_iter(&ifl, tu);
while (tnt_next(&ifl)) {
@@ -183,7 +205,7 @@ static void tc_print_fields(struct tnt_tuple *tu) {
tc_printf("%"PRIu64, *((uint64_t*)data));
break;
default:
- tc_print_str(data, size);
+ tc_print_string(data, size, 0);
}
tc_printf("'");
}
@@ -210,46 +232,46 @@ void tc_print_list(struct tnt_list *l)
tnt_iter_free(&it);
}
-static void
-tc_printer_tarantool(struct tnt_log_header_v11 *hdr,
- struct tnt_request *r)
+/* lua */
+
+void tc_print_lua_field(char *data, uint32_t size, char string)
{
- tc_printf("%s lsn: %"PRIu64", time: %f, len: %"PRIu32"\n",
- tc_query_type(r->h.type),
- hdr->lsn,
- hdr->tm,
- hdr->len);
- switch (r->h.type) {
- case TNT_OP_INSERT:
- tc_print_tuple(&r->r.insert.t);
+ if (string)
+ goto _string;
+ switch (size){
+ case 4:
+ tc_printf("%"PRIu32, *((uint32_t*)data));
break;
- case TNT_OP_DELETE:
- tc_print_tuple(&r->r.del.t);
- break;
- case TNT_OP_UPDATE:
- tc_print_tuple(&r->r.update.t);
+ case 8:
+ tc_printf("%"PRIu64, *((uint64_t*)data));
break;
+ default:
+_string:
+ tc_printf("\'");
+ tc_print_string(data, size, 1);
+ tc_printf("\'");
}
}
-static void
-tc_printer_raw(struct tnt_log_header_v11 *hdr, struct tnt_request *r)
+void tc_print_lua_fields(struct tnt_tuple *tu)
{
- if (tc.opt.raw_with_headers) {
- fwrite(&tnt_log_marker_v11,
- sizeof(tnt_log_marker_v11), 1, stdout);
+ struct tnt_iter ifl;
+ tnt_iter(&ifl, tu);
+ while (tnt_next(&ifl)) {
+ if ((TNT_IFIELD_IDX(&ifl)) != 0)
+ tc_printf(", ");
+ char *data = TNT_IFIELD_DATA(&ifl);
+ uint32_t size = TNT_IFIELD_SIZE(&ifl);
+ tc_print_lua_field(data, size, tc.opt.str_instead_int);
}
- fwrite(hdr, sizeof(*hdr), 1, stdout);
- fwrite(r->origin, r->origin_size, 1, stdout);
+ if (ifl.status == TNT_ITER_FAIL)
+ tc_printf("<parsing error>");
+ tnt_iter_free(&ifl);
}
-tc_printerf_t tc_print_getcb(const char *name)
+void tc_print_lua_tuple(struct tnt_tuple *tu)
{
- if (name == NULL)
- return tc_printer_tarantool;
- if (!strcasecmp(name, "tarantool"))
- return tc_printer_tarantool;
- if (!strcasecmp(name, "raw"))
- return tc_printer_raw;
- return NULL;
+ tc_printf("{");
+ tc_print_lua_fields(tu);
+ tc_printf("}");
}
diff --git a/client/tarantool/tc_print.h b/client/tarantool/tc_print.h
index 4af4b1b87d3104fc0d56cce61f48bde9c269096a..fe2612e74b113fdae5b1ccdceb2fca883c91d63f 100644
--- a/client/tarantool/tc_print.h
+++ b/client/tarantool/tc_print.h
@@ -29,17 +29,19 @@
* SUCH DAMAGE.
*/
-typedef void (*tc_printerf_t)(struct tnt_log_header_v11 *hdr,
- struct tnt_request *r);
-
void tc_print_tee(char *buf, size_t size);
void tc_print_cmd2tee(char *prompt, char *cmd, int size);
void tc_printf(char *fmt, ...);
void tc_print_buf(char *buf, size_t size);
+void tc_print_string(char *data, uint32_t size, char lua);
+
+void tc_print_fields(struct tnt_tuple *tu);
void tc_print_tuple(struct tnt_tuple *tu);
void tc_print_list(struct tnt_list *l);
-tc_printerf_t tc_print_getcb(const char *name);
+void tc_print_lua_field(char *data, uint32_t size, char string);
+void tc_print_lua_fields(struct tnt_tuple *tu);
+void tc_print_lua_tuple(struct tnt_tuple *tu);
#endif /* TC_PRINT_H_INCLUDED */
diff --git a/client/tarantool/tc_print_snap.c b/client/tarantool/tc_print_snap.c
new file mode 100644
index 0000000000000000000000000000000000000000..e08d183994722288657c9d7687efafa98f7cbadb
--- /dev/null
+++ b/client/tarantool/tc_print_snap.c
@@ -0,0 +1,68 @@
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <inttypes.h>
+#include <limits.h>
+#include <stdint.h>
+
+#include <connector/c/include/tarantool/tnt.h>
+#include <connector/c/include/tarantool/tnt_xlog.h>
+#include <connector/c/include/tarantool/tnt_snapshot.h>
+
+#include "client/tarantool/tc_opt.h"
+#include "client/tarantool/tc_admin.h"
+#include "client/tarantool/tc.h"
+#include "client/tarantool/tc_print.h"
+#include "client/tarantool/tc_print_snap.h"
+#include "client/tarantool/tc_query.h"
+#include "client/tarantool/tc_store.h"
+
+extern struct tc tc;
+
+static void
+tc_printer_snap_raw( struct tnt_log_row_snap_v11 *row,
+ struct tnt_tuple *tu)
+{
+ if (tc.opt.raw_with_headers) {
+ fwrite(&tnt_log_marker_v11,
+ sizeof(tnt_log_marker_v11), 1, stdout);
+ }
+ fwrite(row, sizeof(row), 1, stdout);
+ fwrite(tu->data, tu->size, 1, stdout);
+}
+static void
+tc_printer_snap_tarantool( struct tnt_log_row_snap_v11 *row,
+ struct tnt_tuple *tu)
+{
+ tc_printf("tag: %"PRIu16", cookie: %"PRIu64", space: %"PRIu32"\n",
+ row->tag,
+ row->cookie,
+ row->space);
+ tc_print_tuple(tu);
+
+}
+static void
+tc_printer_snap_lua( struct tnt_log_row_snap_v11 *row,
+ struct tnt_tuple *tu)
+{
+ tc_printf("lua box.insert(%"PRIu32", ", row->space);
+ tc_print_lua_fields(tu);
+ tc_printf(")");
+ if (tc.opt.delim_len > 0)
+ tc_printf("%s\n", tc.opt.delim);
+ else
+ tc_printf("\n");
+}
+
+tc_printerf_snap_t tc_print_getsnapcb(const char *name)
+{
+ if (name == NULL)
+ return tc_printer_snap_tarantool;
+ if (!strcasecmp(name, "tarantool"))
+ return tc_printer_snap_tarantool;
+ if (!strcasecmp(name, "raw"))
+ return tc_printer_snap_raw;
+ if (!strcasecmp(name, "lua"))
+ return tc_printer_snap_lua;
+ return NULL;
+}
diff --git a/client/tarantool/tc_print_snap.h b/client/tarantool/tc_print_snap.h
new file mode 100644
index 0000000000000000000000000000000000000000..9bf467a2bc062be0b8e9c8cfe55dec5bc5d99250
--- /dev/null
+++ b/client/tarantool/tc_print_snap.h
@@ -0,0 +1,37 @@
+#ifndef TC_PRINT_SNAP_H_INCLUDED
+#define TC_PRINT_SNAP_H_INCLUDED
+/*
+ * 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 <COPYRIGHT HOLDER> ``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.
+ */
+
+typedef void (*tc_printerf_snap_t)(struct tnt_log_row_snap_v11 *row,
+ struct tnt_tuple *tu);
+
+tc_printerf_snap_t tc_print_getsnapcb(const char *name);
+
+#endif /* TC_PRINT_SNAP_H_INCLUDED */
diff --git a/client/tarantool/tc_print_xlog.c b/client/tarantool/tc_print_xlog.c
new file mode 100644
index 0000000000000000000000000000000000000000..57f48513cd957f02eea149a2e3b01d3865c573b3
--- /dev/null
+++ b/client/tarantool/tc_print_xlog.c
@@ -0,0 +1,197 @@
+/*
+ * 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 <COPYRIGHT HOLDER> ``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 <stdlib.h>
+#include <stdio.h>
+#include <inttypes.h>
+#include <strings.h>
+
+#include <connector/c/include/tarantool/tnt.h>
+#include <connector/c/include/tarantool/tnt_xlog.h>
+#include <connector/c/include/tarantool/tnt_rpl.h>
+
+#include "client/tarantool/tc_opt.h"
+#include "client/tarantool/tc_admin.h"
+#include "client/tarantool/tc_print.h"
+#include "client/tarantool/tc_print_xlog.h"
+#include "client/tarantool/tc_query.h"
+#include "client/tarantool/tc_print.h"
+#include "client/tarantool/tc.h"
+
+extern struct tc tc;
+
+static void
+tc_printer_xlog_raw(struct tnt_log_header_v11 *hdr,
+ struct tnt_request *r)
+{
+ if (tc.opt.raw_with_headers) {
+ fwrite(&tnt_log_marker_v11,
+ sizeof(tnt_log_marker_v11), 1, stdout);
+ }
+ fwrite(hdr, sizeof(*hdr), 1, stdout);
+ fwrite(r->origin, r->origin_size, 1, stdout);
+}
+
+static void
+tc_printer_xlog_tarantool(struct tnt_log_header_v11 *hdr,
+ struct tnt_request *r)
+{
+ tc_printf("%s lsn: %"PRIu64", time: %f, len: %"PRIu32"\n",
+ tc_query_type(r->h.type),
+ hdr->lsn,
+ hdr->tm,
+ hdr->len);
+ switch (r->h.type) {
+ case TNT_OP_INSERT:
+ tc_print_tuple(&r->r.insert.t);
+ break;
+ case TNT_OP_DELETE:
+ tc_print_tuple(&r->r.del.t);
+ break;
+ case TNT_OP_UPDATE:
+ tc_print_tuple(&r->r.update.t);
+ break;
+ }
+}
+
+static void
+tc_printer_xlog_lua(struct tnt_log_header_v11 *hdr,
+ struct tnt_request *r)
+{
+ tc_printf("lua box.");
+ switch (r->h.type) {
+ case TNT_OP_INSERT:
+ if (r->r.insert.h.flags && TNT_FLAG_REPLACE == TNT_FLAG_REPLACE)
+ tc_printf("replace(");
+ else
+ tc_printf("insert(");
+ tc_printf("%"PRIu32", ", r->r.insert.h.ns);
+ tc_print_lua_fields(&r->r.insert.t);
+ break;
+ case TNT_OP_DELETE:
+ tc_printf("delete(");
+ tc_printf("%"PRIu32", ", r->r.del.h.ns);
+ tc_print_lua_tuple(&r->r.del.t);
+ break;
+ case TNT_OP_UPDATE:
+ tc_printf("update(");
+ tc_printf("%"PRIu32", ", r->r.update.h.ns);
+ tc_print_lua_tuple(&r->r.update.t);
+ tc_printf(", '");
+ for (uint32_t i = 0; i < r->r.update.opc; i++) {
+ switch (r->r.update.opv[i].op) {
+ case TNT_UPDATE_ASSIGN:
+ tc_printf("=p");
+ break;
+ case TNT_UPDATE_ADD:
+ tc_printf("+p");
+ break;
+ case TNT_UPDATE_AND:
+ tc_printf("&p");
+ break;
+ case TNT_UPDATE_XOR:
+ tc_printf("^p");
+ break;
+ case TNT_UPDATE_OR:
+ tc_printf("|p");
+ break;
+ case TNT_UPDATE_SPLICE:
+ tc_printf(":p");
+ break;
+ case TNT_UPDATE_DELETE:
+ tc_printf("#p");
+ break;
+ case TNT_UPDATE_INSERT:
+ tc_printf("!p");
+ break;
+ }
+ }
+ tc_printf("'");
+ for (uint32_t i = 0; i < r->r.update.opc; i++) {
+ tc_printf(", %"PRIu32,
+ r->r.update.opv[i].field);
+ switch (r->r.update.opv[i].op){
+ case TNT_UPDATE_ADD:
+ case TNT_UPDATE_AND:
+ case TNT_UPDATE_XOR:
+ case TNT_UPDATE_OR:
+ tc_printf(", ");
+ tc_print_lua_field(r->r.update.opv[i].data,
+ r->r.update.opv[i].size, 0);
+ break;
+ case TNT_UPDATE_SPLICE:
+ tc_printf(", box.pack('ppp'");
+ char *data = r->r.update.opv[i].data;
+ size_t pos = 1;
+ tc_printf(", %"PRId32,
+ *(int32_t *)(data + pos));
+ pos += 5;
+ tc_printf(", %"PRId32", ",
+ *(int32_t *)(data + pos));
+ pos += 4 + r->r.update.opv[i].size_enc_len;
+ tc_printf("\'");
+ tc_print_string(data,
+ r->r.update.opv[i].size - pos, 1);
+ tc_printf("\'");
+ tc_printf(")");
+ break;
+ case TNT_UPDATE_DELETE:
+ tc_printf(", \'\'");
+ break;
+ case TNT_UPDATE_INSERT:
+ case TNT_UPDATE_ASSIGN:
+ tc_printf(", ");
+ tc_print_lua_field(r->r.update.opv[i].data,
+ r->r.update.opv[i].size,
+ tc.opt.str_instead_int);
+ break;
+ }
+ }
+ break;
+ }
+ tc_printf(") -- %"PRIu64, hdr->lsn);
+ if (tc.opt.delim_len > 0)
+ tc_printf("%s\n", tc.opt.delim);
+ else
+ tc_printf("\n");
+}
+
+tc_printerf_xlog_t tc_print_getxlogcb(const char *name)
+{
+ if (name == NULL)
+ return tc_printer_xlog_tarantool;
+ if (!strcasecmp(name, "tarantool"))
+ return tc_printer_xlog_tarantool;
+ if (!strcasecmp(name, "raw"))
+ return tc_printer_xlog_raw;
+ if (!strcasecmp(name, "lua"))
+ return tc_printer_xlog_lua;
+ return NULL;
+}
diff --git a/client/tarantool/tc_print_xlog.h b/client/tarantool/tc_print_xlog.h
new file mode 100644
index 0000000000000000000000000000000000000000..e9918606ee7d3278b3d3206f0aa23b404410c7d2
--- /dev/null
+++ b/client/tarantool/tc_print_xlog.h
@@ -0,0 +1,37 @@
+#ifndef TC_PRINT_XLOG_H_INCLUDED
+#define TC_PRINT_XLOG_H_INCLUDED
+/*
+ * 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 <COPYRIGHT HOLDER> ``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.
+ */
+
+typedef void (*tc_printerf_xlog_t)(struct tnt_log_header_v11 *hdr,
+ struct tnt_request *r);
+
+tc_printerf_xlog_t tc_print_getxlogcb(const char *name);
+
+#endif /* TC_PRINT_XLOG_H_INCLUDED */
diff --git a/client/tarantool/tc_store.c b/client/tarantool/tc_store.c
index c04d8c481b2fdd4c1149d51e65e486d3597bc8b4..ec2bc020e7b259ceebf9f49e53f5ab7b53b65f0f 100644
--- a/client/tarantool/tc_store.c
+++ b/client/tarantool/tc_store.c
@@ -44,6 +44,8 @@
#include "client/tarantool/tc_admin.h"
#include "client/tarantool/tc.h"
#include "client/tarantool/tc_print.h"
+#include "client/tarantool/tc_print_xlog.h"
+#include "client/tarantool/tc_print_snap.h"
#include "client/tarantool/tc_query.h"
#include "client/tarantool/tc_store.h"
@@ -125,7 +127,7 @@ static int tc_store_printer(struct tnt_iter *i) {
return 0;
struct tnt_stream_xlog *s =
TNT_SXLOG_CAST(TNT_IREQUEST_STREAM(i));
- ((tc_printerf_t)tc.opt.printer)(&s->log.current.hdr, r);
+ ((tc_printerf_xlog_t)tc.opt.xlog_printer)(&s->log.current.hdr, r);
return 0;
}
@@ -133,21 +135,7 @@ static int tc_snapshot_printer(struct tnt_iter *i) {
struct tnt_tuple *tu = TNT_ISTORAGE_TUPLE(i);
struct tnt_stream_snapshot *ss =
TNT_SSNAPSHOT_CAST(TNT_ISTORAGE_STREAM(i));
- if (tc.opt.raw) {
- if (tc.opt.raw_with_headers) {
- fwrite(&tnt_log_marker_v11,
- sizeof(tnt_log_marker_v11), 1, stdout);
- }
- fwrite(&ss->log.current.row_snap,
- sizeof(ss->log.current.row_snap), 1, stdout);
- fwrite(tu->data, tu->size, 1, stdout);
- } else {
- tc_printf("tag: %"PRIu16", cookie: %"PRIu64", space: %"PRIu32"\n",
- ss->log.current.row_snap.tag,
- ss->log.current.row_snap.cookie,
- ss->log.current.row_snap.space);
- tc_print_tuple(tu);
- }
+ ((tc_printerf_snap_t)tc.opt.snap_printer)(&ss->log.current.row_snap, tu);
return 0;
}
@@ -200,6 +188,7 @@ int tc_store_cat(void)
fputs("\n", stdout);
}
int rc;
+
switch (type) {
case TNT_LOG_SNAPSHOT:
rc = tc_store_foreach_snapshot(tc_snapshot_printer);
diff --git a/cmake/CheckBuiltInFunctionExists.cmake b/cmake/CheckBuiltInFunctionExists.cmake
deleted file mode 100644
index 6b4128f129f2f3effa521edcd17508964b3a03bd..0000000000000000000000000000000000000000
--- a/cmake/CheckBuiltInFunctionExists.cmake
+++ /dev/null
@@ -1,7 +0,0 @@
-include(CheckCSourceCompiles)
-
-macro(check_builtin_function_exists function variable)
- set(CMAKE_REQUIRED_FLAGS "-Wno-unused-value -Wno-error")
- check_c_source_compiles("int main(void) { ${function}; return 0; }"
- ${variable})
-endmacro(check_builtin_function_exists)
diff --git a/connector/c/include/tp.h b/connector/c/include/tp.h
index 4d886719bb2fe7515e8528bf57daefc05ff0e770..d76e827be6d569bcb59fca7b3abe92a5f0d5e670 100644
--- a/connector/c/include/tp.h
+++ b/connector/c/include/tp.h
@@ -329,6 +329,12 @@ tp_unused(struct tp *p) {
* data must be manually freed when the buffer is no longer
* needed.
* (eg. free(p->s));
+ * if realloc will return NULL, then you must destroy previous memory.
+ * (eg.
+ * if (tp_realloc(p, ..) == NULL) {
+ * free(p->s)
+ * return NULL;
+ * }
*/
tp_function_unused static char*
tp_realloc(struct tp *p, size_t required, size_t *size) {
diff --git a/connector/c/tnt/tnt_buf.c b/connector/c/tnt/tnt_buf.c
index c5209dd1b2effcaf52220e88dc7828d7cf831941..a67016197d2de33feb4637f56886f0bfa8f98b25 100644
--- a/connector/c/tnt/tnt_buf.c
+++ b/connector/c/tnt/tnt_buf.c
@@ -68,8 +68,10 @@ static char* tnt_buf_resize(struct tnt_stream *s, size_t size) {
size_t off = sb->size;
size_t nsize = off + size;
char *nd = realloc(sb->data, nsize);
- if (nd == NULL)
+ if (nd == NULL) {
+ free(sb->data);
return NULL;
+ }
sb->data = nd;
sb->size = nsize;
return sb->data + off;
diff --git a/connector/c/tnt/tnt_tuple.c b/connector/c/tnt/tnt_tuple.c
index 0a9c36baf7451ed8da96ff71d2708e8d44e7e950..9b8cec4a6ae2aeaee781fcef811e80193b55551f 100644
--- a/connector/c/tnt/tnt_tuple.c
+++ b/connector/c/tnt/tnt_tuple.c
@@ -394,6 +394,7 @@ struct tnt_tuple *tnt_list_at(struct tnt_list *l, struct tnt_tuple *t) {
/* reallocating tuple data */
char *ndata = realloc(l->list, sizeof(struct tnt_list_ptr) * (l->count + 1));
if (ndata == NULL) {
+ free(l->list);
if (allocated)
tnt_tuple_free(t);
return NULL;
diff --git a/doc/user/iterator-types.xml b/doc/user/iterator-types.xml
index 836442e21826f5a4d7e017f5e559ccb8fa6148e8..efb50c86a364555ede0a602469d59968ac9e09e6 100644
--- a/doc/user/iterator-types.xml
+++ b/doc/user/iterator-types.xml
@@ -55,7 +55,7 @@
</simpara>
<simpara>
Semantics of the match depends on the index.
- A HASH and TREE index only supports exact match: all parts
+ A HASH index only supports exact match: all parts
of a key participating in the index must be provided.
In case of TREE index, only few parts of a key or a
key prefix are accepted for search.
@@ -64,12 +64,10 @@
criteria.
</simpara>
<simpara>
- A non-unique HASH index returns tuples in unspecified
- order.
When a TREE index is not unique, or only part of a key
is given as a search criteria, matching tuples are
returned in ascending order.
- BITSET indexes are always unique.
+ BITSET and HASH indexes are always unique.
</simpara>
</entry>
</row>
diff --git a/doc/user/space.xml b/doc/user/space.xml
index 348d21151f205f5f453f0cb73c267ceae4845c78..655af9e063fd7b85ca69943f1940a9e63425c3b0 100644
--- a/doc/user/space.xml
+++ b/doc/user/space.xml
@@ -94,8 +94,7 @@ please be aware of these restrictions:
dynamically, currently you need to restart the server even to
disable or enable a space,
</simpara></listitem>
- <listitem><simpara>HASH indexes may cover only one field and can
- not be non-unique.
+ <listitem><simpara>HASH indexes can not be non-unique.
</simpara></listitem>
</itemizedlist>
</para>
diff --git a/include/assoc.h b/include/assoc.h
index 937101ecfa2c9a2836ff0e5ddb270ed566f0275b..fd67835f77004d6fc80fb17a561ce503fcdd91d0 100644
--- a/include/assoc.h
+++ b/include/assoc.h
@@ -39,7 +39,7 @@
*/
#define mh_name _i32ptr
struct mh_i32ptr_node_t {
- u32 key;
+ uint32_t key;
void *val;
};
@@ -55,14 +55,14 @@ struct mh_i32ptr_node_t {
*/
#define mh_name _i64ptr
struct mh_i64ptr_node_t {
- u64 key;
+ uint64_t key;
void *val;
};
#define mh_node_t struct mh_i64ptr_node_t
-#define mh_int_t u32
+#define mh_int_t uint32_t
#define mh_arg_t void *
-#define mh_hash(a, arg) ((u32)((a->key)>>33^(a->key)^(a->key)<<11))
+#define mh_hash(a, arg) ((uint32_t)((a->key)>>33^(a->key)^(a->key)<<11))
#define mh_eq(a, b, arg) ((a->key) == (b->key))
#include <mhash.h>
@@ -88,13 +88,13 @@ struct mh_lstrptr_node_t {
};
#define mh_node_t struct mh_lstrptr_node_t
-#define mh_int_t u32
+#define mh_int_t uint32_t
#define mh_arg_t void *
-static inline u32
+static inline uint32_t
mh_strptr_hash(const mh_node_t *a, mh_arg_t arg) {
(void) arg;
const char *_k = a->key;
- const u32 l = load_varint32(&_k);
+ const uint32_t l = load_varint32(&_k);
return PMurHash32(13, _k, l);
}
#define mh_hash(a, arg) mh_strptr_hash(a, arg)
diff --git a/include/box/box.h b/include/box/box.h
index 43808bc50fdaf47fee816d340103aec59dd4ee93..08cd9cb2c3e22065c032a5c47542fc134cf2b444 100644
--- a/include/box/box.h
+++ b/include/box/box.h
@@ -60,7 +60,7 @@ void box_free(void);
* change when entering/leaving read-only mode
* (master->slave propagation).
*/
-typedef void (*box_process_func)(struct port *, u32, const char *, u32);
+typedef void (*box_process_func)(struct port *, uint32_t, const char *, uint32_t);
/** For read-write operations. */
extern box_process_func box_process;
/** For read-only port. */
@@ -70,12 +70,14 @@ extern box_process_func box_process_ro;
* Check storage-layer related options in the
* configuration file.
*/
-i32 box_check_config(struct tarantool_cfg *conf);
+int
+box_check_config(struct tarantool_cfg *conf);
/*
* Take into effect storage-layer related
* changes in the server configuration.
*/
-i32 box_reload_config(struct tarantool_cfg *old_conf, struct tarantool_cfg *new_conf);
+int
+box_reload_config(struct tarantool_cfg *old_conf, struct tarantool_cfg *new_conf);
void box_lua_load_cfg(struct lua_State *L);
/**
* Iterate over all spaces and save them to the
diff --git a/include/fiber.h b/include/fiber.h
index 0416c4d0ab2664f147a7f1acc083cb3fb1e15bc3..a02948e1d0046427967b875b11f135cac37339ef 100644
--- a/include/fiber.h
+++ b/include/fiber.h
@@ -104,7 +104,7 @@ struct fiber {
*/
void (*f) (va_list);
va_list f_data;
- u32 flags;
+ uint32_t flags;
struct fiber *waiter;
};
diff --git a/include/lib/small/mempool.h b/include/lib/small/mempool.h
new file mode 100644
index 0000000000000000000000000000000000000000..f26ec1a7b0c413306752d9458dc4079e0e580add
--- /dev/null
+++ b/include/lib/small/mempool.h
@@ -0,0 +1,270 @@
+#ifndef INCLUDES_TARANTOOL_SMALL_MEMPOOL_H
+#define INCLUDES_TARANTOOL_SMALL_MEMPOOL_H
+/*
+ * 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 <COPYRIGHT HOLDER> ``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 <stdbool.h>
+#include <inttypes.h>
+#include "lib/small/slab_cache.h"
+#define RB_COMPACT 1
+#include "third_party/rb.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * Pool allocator.
+ *
+ * Good for allocating tons of small objects of the same size.
+ * Stores all objects in order-of-virtual-page-size memory blocks,
+ * called slabs. Each object can be freed if necessary. There is
+ * (practically) no allocation overhead. Internal fragmentation
+ * may occur if lots of objects are allocated, and then many of
+ * them are freed in reverse-to-allocation order.
+ *
+ * Under the hood, uses a slab cache of mmap()-allocated slabs.
+ * Slabs of the slab cache are never released back to the
+ * operating system.
+ *
+ * Thread-safety
+ * -------------
+ * Calls to alloc() and free() on the same mempool instance must
+ * be externally synchronized. Use of different instances in
+ * different threads is thread-safe (but they must also be based
+ * on distinct slab caches).
+ *
+ * Exception-safety
+ * ----------------
+ * The only type of failure which can occur is a failure to
+ * allocate memory. In case of such error, an exception
+ * (ClientError, ER_OUT_OF_RESOURCES) is raised. _nothrow()
+ * version of mempool_alloc() returns NULL rather than raises an
+ * error in case of failure.
+ */
+
+typedef unsigned long mbitmap_t;
+
+enum {
+ /**
+ * At least this many bytes must be reserved
+ * for free/occupied object bit map.
+ */
+ MEMPOOL_MAP_SIZEOF = sizeof(mbitmap_t),
+ /**
+ * How many bits per bitmap, i.e. how many objects
+ * a single bitmap can map.
+ */
+ MEMPOOL_MAP_BIT = MEMPOOL_MAP_SIZEOF * CHAR_BIT,
+ /** Mempool slab has to contain at least this many
+ * objects, to ensure that overhead on bitmaps
+ * for free/used objects is small.
+ */
+ MEMPOOL_OBJ_MIN = 2 * MEMPOOL_MAP_BIT
+};
+
+/** mslab - a standard slab formatted to store objects of equal size. */
+struct mslab {
+ struct slab slab;
+ /** Index of the first bitmap element which has a free slot. */
+ uint32_t ffi;
+ /** Number of available slots in the slab. */
+ uint32_t nfree;
+ /** Used if this slab is a member of free_slabs tree. */
+ rb_node(struct mslab) node;
+ /* Reference to the owning pool. */
+ struct mempool *pool;
+ /**
+ * A bitmap for free used/objects in the slab.
+ * A bitmap rather than a free list is used since:
+ * - this tends to keep allocations close to the
+ * beginning of the slab, which is better for
+ * cache locality
+ * - it makes it possible to iterate over all
+ * objects in a slab.
+ */
+ mbitmap_t map[];
+};
+
+static inline size_t
+mslab_sizeof()
+{
+ return slab_size_align(sizeof(struct mslab), sizeof(intptr_t));
+}
+
+typedef rb_tree(struct mslab) mslab_tree_t;
+
+/** A memory pool. */
+struct mempool
+{
+ /** The source of empty slabs. */
+ struct slab_cache *cache;
+ /** All slabs. */
+ struct slab_list slabs;
+ /**
+ * Slabs with some amount of free space available are put
+ * into this red-black tree, which is sorted by slab
+ * address. A (partially) free slab with the smallest
+ * address is chosen for allocation. This reduces internal
+ * memory fragmentation across many slabs.
+ */
+ mslab_tree_t free_slabs;
+ /**
+ * A completely empty slab which is not freed only to
+ * avoid the overhead of slab_cache oscillation around
+ * a single element allocation.
+ */
+ struct mslab *spare;
+ /**
+ * The size of an individual object. All objects
+ * allocated on the pool have the same size.
+ */
+ uint32_t objsize;
+ /**
+ * Mempool slabs are ordered (@sa slab_cache.h for
+ * definition of "ordered"). The order is calculated
+ * when the pool is initialized.
+ */
+ uint8_t slab_order;
+ /** How many objects can fit in a slab. */
+ uint32_t objcount;
+ /**
+ * How many bytes of the slab are reserved for
+ * slab map.
+ */
+ uint32_t mapsize;
+};
+
+/** Allocation statistics. */
+struct mempool_stats
+{
+ /** Object size. */
+ uint32_t objsize;
+ /** Total objects allocated. */
+ uint32_t objcount;
+ /** Size of the slab. */
+ uint32_t slabsize;
+ /** Number of slabs. All slabs are of the same size. */
+ uint32_t slabcount;
+ /** Memory used and booked but passive (to see fragmentation). */
+ struct small_stats totals;
+};
+
+void
+mempool_stats(struct mempool *mempool, struct mempool_stats *stats);
+
+/** @todo: struct mempool_iterator */
+
+void
+mempool_create_with_order(struct mempool *pool, struct slab_cache *cache,
+ uint32_t objsize, uint8_t order);
+
+/**
+ * Initialize a mempool. Tell the pool the size of objects
+ * it will contain.
+ *
+ * objsize must be >= sizeof(mbitmap_t)
+ * If allocated objects must be aligned, then objsize must
+ * be aligned. The start of free area in a slab is always
+ * uint64_t aligned.
+ *
+ * @sa mempool_destroy()
+ */
+static inline void
+mempool_create(struct mempool *pool, struct slab_cache *cache,
+ uint32_t objsize)
+{
+ /* Keep size-induced internal fragmentation within limits. */
+ size_t slab_size_min = objsize * MEMPOOL_OBJ_MIN;
+ /*
+ * Calculate the amount of usable space in a slab.
+ * @note: this asserts that slab_size_min is less than
+ * SLAB_ORDER_MAX.
+ */
+ uint8_t order = slab_order(slab_size_min);
+ return mempool_create_with_order(pool, cache, objsize, order);
+}
+
+/**
+ * Free the memory pool and release all cached memory blocks.
+ * @sa mempool_create()
+ */
+void
+mempool_destroy(struct mempool *pool);
+
+/** Allocate an object. */
+void *
+mempool_alloc_nothrow(struct mempool *pool);
+
+/**
+ * Free a single object.
+ * @pre the object is allocated in this pool.
+ */
+void
+mempool_free(struct mempool *pool, void *ptr);
+
+/** How much memory is used by this pool. */
+static inline size_t
+mempool_used(struct mempool *pool)
+{
+ return pool->slabs.stats.used;
+}
+
+
+/** How much memory is held by this pool. */
+static inline size_t
+mempool_total(struct mempool *pool)
+{
+ return pool->slabs.stats.total;
+}
+
+#if defined(__cplusplus)
+#include "exception.h"
+
+static inline void *
+mempool_alloc(struct mempool *pool)
+{
+
+ void *ptr = mempool_alloc_nothrow(pool);
+ if (ptr == NULL)
+ tnt_raise(LoggedError, ER_MEMORY_ISSUE,
+ pool->objsize, "mempool", "new slab");
+ return ptr;
+}
+
+static inline void *
+mempool_calloc(struct mempool *pool)
+{
+ return memset(mempool_alloc(pool), 0, pool->objsize);
+}
+
+} /* extern "C" */
+#endif /* __cplusplus */
+
+#endif /* INCLUDES_TARANTOOL_SMALL_MEMPOOL_H */
diff --git a/include/lib/small/region.h b/include/lib/small/region.h
new file mode 100644
index 0000000000000000000000000000000000000000..bfe2a87ecf60b78408406a3697b1a4b2acb89f1a
--- /dev/null
+++ b/include/lib/small/region.h
@@ -0,0 +1,241 @@
+#ifndef INCLUDES_TARANTOOL_SMALL_REGION_H
+#define INCLUDES_TARANTOOL_SMALL_REGION_H
+/*
+ * 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 <COPYRIGHT HOLDER> ``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 <inttypes.h>
+#include <assert.h>
+#include <stdio.h>
+#include "rlist.h"
+#include "slab_cache.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * Region allocator.
+ *
+ * Good for allocating objects of any size, as long as
+ * all of them can be freed at once. Keeps a list of
+ * order-of-page-size memory blocks, thus has no external
+ * fragmentation. Does have a fair bit of internal fragmentation,
+ * but only if average allocation size is close to the block size.
+ * Therefore is ideal for a ton of small allocations of different
+ * sizes.
+ *
+ * Under the hood, the allocator uses a page cache of
+ * mmap()-allocated pages. Pages of the page cache are never
+ * released back to the operating system.
+ *
+ * Thread-safety
+ * -------------
+ * @todo, not thread safe ATM
+ *
+ * Errors
+ * ----------------
+ * The only type of failure which can occur is a failure to
+ * allocate memory. alloc() calls return NULL in this case.
+ */
+
+/** A memory region.
+ *
+ * A memory region is a list of memory blocks.
+ *
+ * It's possible to allocate a chunk of any size
+ * from a region.
+ * It's not possible, however, to free a single allocated
+ * piece, all memory must be freed at once with region_reset() or
+ * region_free().
+ */
+
+enum { REGION_NAME_MAX = 30 };
+
+struct region
+{
+ struct slab_cache *cache;
+ struct slab_list slabs;
+ char name[REGION_NAME_MAX];
+};
+
+/**
+ * Initialize a memory region.
+ * @sa region_free().
+ */
+static inline void
+region_create(struct region *region, struct slab_cache *cache)
+{
+ region->cache = cache;
+ slab_list_create(®ion->slabs);
+ region->name[0] = '\0';
+}
+
+/**
+ * Free all allocated objects and release the allocated
+ * blocks.
+ */
+void
+region_free(struct region *region);
+
+/** Internal: a single block in a region. */
+struct rslab
+{
+ /*
+ * slab is a wrapper around struct slab - with a few
+ * extra members.
+ */
+ struct slab slab;
+ uint32_t used;
+};
+
+static inline size_t
+rslab_sizeof()
+{
+ return slab_size_align(sizeof(struct rslab), sizeof(intptr_t));
+}
+
+static inline void *
+rslab_data(struct rslab *slab)
+{
+ return (char *) slab + rslab_sizeof();
+}
+
+/** How much memory is available in a given block? */
+static inline size_t
+rslab_unused(struct rslab *slab)
+{
+ return slab->slab.size - rslab_sizeof() - slab->used;
+}
+
+/**
+ * Allocate 'size' bytes from a block.
+ * @pre block must have enough unused space
+ */
+static inline void *
+slab_alloc(struct rslab *slab, size_t size)
+{
+ assert(size <= rslab_unused(slab));
+ void *ptr = rslab_data(slab) + slab->used;
+ slab->used += size;
+ return ptr;
+}
+
+void *
+region_alloc_slow(struct region *region, size_t size);
+
+/** Allocate size bytes from a region. */
+static inline void *
+region_alloc_nothrow(struct region *region, size_t size)
+{
+ if (! rlist_empty(®ion->slabs.slabs)) {
+ struct rslab *slab = rlist_first_entry(®ion->slabs.slabs,
+ struct rslab,
+ slab.next_in_list);
+ if (size <= rslab_unused(slab)) {
+ region->slabs.stats.used += size;
+ return slab_alloc(slab, size);
+ }
+ }
+ return region_alloc_slow(region, size);
+}
+
+/**
+ * Mark region as empty, but keep the blocks.
+ */
+static inline void
+region_reset(struct region *region)
+{
+ if (! rlist_empty(®ion->slabs.slabs)) {
+ struct rslab *slab = rlist_first_entry(®ion->slabs.slabs,
+ struct rslab,
+ slab.next_in_list);
+ region->slabs.stats.used -= slab->used;
+ slab->used = 0;
+ }
+}
+
+/** How much memory is used by this region. */
+static inline size_t
+region_used(struct region *region)
+{
+ return region->slabs.stats.used;
+}
+
+
+/** How much memory is held by this region. */
+static inline size_t
+region_total(struct region *region)
+{
+ return region->slabs.stats.total;
+}
+
+static inline void
+region_free_after(struct region *region, size_t after)
+{
+ if (region_used(region) > after)
+ region_free(region);
+}
+
+void
+region_truncate(struct region *pool, size_t sz);
+
+static inline void
+region_set_name(struct region *region, const char *name)
+{
+ snprintf(region->name, sizeof(region->name), "%s", name);
+}
+
+static inline const char *
+region_name(struct region *region)
+{
+ return region->name;
+}
+
+#if defined(__cplusplus)
+#include "exception.h"
+
+static inline void *
+region_alloc(struct region *region, size_t size)
+{
+ void *ptr = region_alloc_nothrow(region, size);
+ if (ptr == NULL)
+ tnt_raise(LoggedError, ER_MEMORY_ISSUE,
+ size, "region", "new slab");
+ return ptr;
+}
+
+static inline void *
+region_calloc(struct region *region, size_t size)
+{
+ return memset(region_alloc(region, size), 0, size);
+}
+} /* extern "C" */
+#endif
+
+#endif /* INCLUDES_TARANTOOL_SMALL_REGION_H */
diff --git a/include/lib/small/slab_cache.h b/include/lib/small/slab_cache.h
new file mode 100644
index 0000000000000000000000000000000000000000..a0877b6fdb1c73b2047d7ae06f6e99d93353a029
--- /dev/null
+++ b/include/lib/small/slab_cache.h
@@ -0,0 +1,231 @@
+#ifndef INCLUDES_TARANTOOL_SMALL_SLAB_CACHE_H
+#define INCLUDES_TARANTOOL_SMALL_SLAB_CACHE_H
+/*
+ * 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 <COPYRIGHT HOLDER> ``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 <inttypes.h>
+#include <limits.h>
+#include <stddef.h>
+#include <assert.h>
+#include "rlist.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+enum {
+ /*
+ * Slabs of "order" from 0 to 8 have size which is a power
+ * of 2. They are obtained either using mmap(), or by
+ * splitting an mmapped() slab of higher order (buddy
+ * system). Memory address of such slab is aligned to
+ * slab size.
+ */
+ SLAB_ORDER_LAST = 10,
+ /*
+ * The last "order" contains huge slabs, allocated with
+ * malloc(). This order is provided to make life of
+ * slab_cache user easier, so that one doesn't have to
+ * worry about allocation sizes larger than SLAB_MAX_SIZE.
+ */
+ SLAB_HUGE = SLAB_ORDER_LAST + 1,
+ /** Binary logarithm of SLAB_MIN_SIZE. */
+ SLAB_MIN_SIZE_LB = 12,
+ /** Minimal size of an ordered slab, 4096 */
+ SLAB_MIN_SIZE = 1 << SLAB_MIN_SIZE_LB,
+ /** Maximal size of an ordered slab, 1M */
+ SLAB_MAX_SIZE = SLAB_MIN_SIZE << SLAB_ORDER_LAST
+};
+
+struct slab {
+ /*
+ * Next slab in the list of allocated slabs. Unused if
+ * this slab has a buddy. Sic: if a slab is not allocated
+ * but is made by a split of a larger (allocated) slab,
+ * this member got to be left intact, to not corrupt
+ * cache->allocated list.
+ */
+ struct rlist next_in_cache;
+ /** Next slab in slab_list->slabs list. */
+ struct rlist next_in_list;
+ /**
+ * Allocated size.
+ * Is different from (SLAB_MIN_SIZE << slab->order)
+ * when requested size is bigger than SLAB_MAX_SIZE
+ * (i.e. slab->order is SLAB_CLASS_LAST).
+ */
+ size_t size;
+ /** Slab magic (for sanity checks). */
+ uint32_t magic;
+ /** Base of lb(size) for ordered slabs. */
+ uint8_t order;
+ /**
+ * Only used for buddy slabs. If the buddy of the current
+ * free slab is also free, both slabs are merged and
+ * a free slab of the higher order emerges.
+ */
+ uint8_t in_use;
+};
+
+/** Allocation statistics. */
+struct small_stats {
+ size_t used;
+ size_t total;
+};
+
+static inline void
+small_stats_reset(struct small_stats *stats)
+{
+ stats->used = stats->total = 0;
+}
+
+/**
+ * A general purpose list of slabs. Is used
+ * to store unused slabs of a certain order in the
+ * slab cache, as well as to contain allocated
+ * slabs of a specialized allocator.
+ */
+struct slab_list {
+ struct rlist slabs;
+ /** Total/used bytes in this list. */
+ struct small_stats stats;
+};
+
+#define slab_list_add(list, slab, member) \
+do { \
+ rlist_add_entry(&(list)->slabs, (slab), member);\
+ (list)->stats.total += (slab)->size; \
+} while (0)
+
+#define slab_list_del(list, slab, member) \
+do { \
+ rlist_del_entry((slab), member); \
+ (list)->stats.total -= (slab)->size; \
+} while (0)
+
+static inline void
+slab_list_create(struct slab_list *list)
+{
+ rlist_create(&list->slabs);
+ small_stats_reset(&list->stats);
+}
+
+struct slab_cache {
+ /**
+ * Slabs are ordered by size, which is a multiple of two.
+ * orders[0] contains slabs of size SLAB_MIN_SIZE
+ * (order 0). orders[1] contains slabs of
+ * 2 * SLAB_MIN_SIZE, and so on. The list only contains
+ * unused slabs - a used slab is removed from the
+ * slab_cache list and its next_in_list link may
+ * be reused for some other purpose.
+ * Note, that SLAB_HUGE slabs are not accounted
+ * here, since they are never reused.
+ */
+ struct slab_list orders[SLAB_ORDER_LAST + 1];
+ /** All allocated slabs used in the cache.
+ * The stats reflect the total used/allocated
+ * memory in the cache.
+ */
+ struct slab_list allocated;
+};
+
+void
+slab_cache_create(struct slab_cache *cache);
+
+void
+slab_cache_destroy(struct slab_cache *cache);
+
+struct slab *
+slab_get(struct slab_cache *cache, size_t size);
+
+struct slab *
+slab_get_with_order(struct slab_cache *cache, uint8_t order);
+
+void
+slab_put(struct slab_cache *cache, struct slab *slab);
+
+struct slab *
+slab_from_ptr(void *ptr, uint8_t order);
+
+/** Align a size. Alignment must be a power of 2 */
+static inline size_t
+slab_size_align(size_t size, size_t alignment)
+{
+ return (size + alignment - 1) & ~(alignment - 1);
+}
+
+/* Aligned size of slab meta. */
+static inline size_t
+slab_sizeof()
+{
+ return slab_size_align(sizeof(struct slab), sizeof(intptr_t));
+}
+
+static inline size_t
+slab_size(struct slab *slab)
+{
+ return slab->size - slab_sizeof();
+}
+
+void
+slab_cache_check(struct slab_cache *cache);
+
+/**
+ * Find the nearest power of 2 size capable of containing
+ * a chunk of the given size. Adjust for SLAB_MIN_SIZE and
+ * SLAB_MAX_SIZE.
+ */
+static inline uint8_t
+slab_order(size_t size)
+{
+ assert(size <= UINT32_MAX);
+ if (size <= SLAB_MIN_SIZE)
+ return 0;
+ if (size > SLAB_MAX_SIZE)
+ return SLAB_HUGE;
+
+ return (uint8_t) (CHAR_BIT * sizeof(uint32_t) -
+ __builtin_clz((uint32_t) size - 1) -
+ SLAB_MIN_SIZE_LB);
+}
+
+/** Convert slab order to the mmap()ed size. */
+static inline intptr_t
+slab_order_size(uint8_t order)
+{
+ assert(order <= SLAB_ORDER_LAST);
+ return 1 << (order + SLAB_MIN_SIZE_LB);
+}
+
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif /* INCLUDES_TARANTOOL_SMALL_SLAB_CACHE_H */
diff --git a/include/lib/small/small.h b/include/lib/small/small.h
new file mode 100644
index 0000000000000000000000000000000000000000..8ab4d2ee72fd0afa79d122b88c28411e15c5fecb
--- /dev/null
+++ b/include/lib/small/small.h
@@ -0,0 +1,229 @@
+#ifndef INCLUDES_TARANTOOL_SMALL_SMALL_H
+#define INCLUDES_TARANTOOL_SMALL_SMALL_H
+/*
+ * 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 <COPYRIGHT HOLDER> ``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 <stdint.h>
+#include "lib/small/mempool.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * Small object allocator.
+ *
+ * The allocator consists of a collection of mempools.
+ *
+ * There are two containers of pools:
+ *
+ * pools for objects of size 8-500 bytes are stored in an array,
+ * where pool->objsize of each array member is a multiple of 8-16
+ * (value defined in STEP_SIZE constant). These are
+ * "stepped" pools, since pool->objsize of each next pool in the
+ * array differs from the previous size by a fixed step size.
+ *
+ * For example, there is a pool for size range 16-32,
+ * another one for 32-48, 48-64, etc. This makes the look up
+ * procedure for small allocations just a matter of getting an
+ * array index via a bit shift. All stepped pools are initialized
+ * when an instance of small_alloc is created.
+ *
+ * Objects of size beyond the stepped pools range (the upper limit
+ * is usually around 300 bytes), are stored in pools with a size
+ * which is a multiple of alloc_factor. alloc_factor is itself
+ * a configuration constant in the range (1.0, 2.0]. I.e. imagine
+ * alloc_factor is 1.1, then there are pools for objects of size
+ * 300-330, 330-363, and so on. These pools are created upon first
+ * allocation within given range, and stored in a red-black tree.
+ *
+ * Initially this red-black tree contains only a pool for
+ * alloc->object_max.
+ * When a request for a new allocation of sz bytes arrives
+ * and it can not be satisfied from a stepped pool,
+ * a search for a nearest factored pool is made in the tree.
+ *
+ * If, for the nearest found factored pool:
+ *
+ * pool->objsize > sz * alloc_factor,
+ *
+ * (i.e. pool object size is too big) a new factored pool is
+ * created and inserted into the tree.
+ *
+ * This way the tree only contains factored pools for sizes
+ * which are actually used by the server, and can be kept
+ * small.
+ */
+
+/** Basic constants of small object allocator. */
+enum {
+ /** How many stepped pools there is. */
+ STEP_POOL_MAX = 32,
+ /** How many factored pools there can be. */
+ FACTOR_POOL_MAX = 256,
+};
+
+/**
+ * A mempool to store objects sized within one multiple of
+ * alloc_factor. Is a member of the red-black tree which
+ * contains all such pools.
+ *
+ * Example: let's assume alloc_factor is 1.1. There will be an
+ * instance of factor_pool for objects of size from 300 to 330,
+ * from 330 to 363, and so on.
+ */
+struct factor_pool
+{
+ /** rb_tree entry */
+ rb_node(struct factor_pool) node;
+ /** the pool itself. */
+ struct mempool pool;
+ /**
+ * Objects starting from this size and up to
+ * pool->objsize are stored in this factored
+ * pool.
+ */
+ size_t objsize_min;
+ /** next free factor pool in the cache. */
+ struct factor_pool *next;
+};
+
+typedef rb_tree(struct factor_pool) factor_tree_t;
+
+/** A slab allocator for a wide range of object sizes. */
+struct small_alloc {
+ uint32_t step_pool_objsize_max;
+ /**
+ * All slabs in all pools must be of the same order,
+ * otherwise small_free() has no way to derive from
+ * pointer its slab and then the pool.
+ */
+ /**
+ * An array of "stepped" pools, pool->objsize of adjacent
+ * pools differ by a fixed size (step).
+ */
+ struct mempool step_pools[STEP_POOL_MAX];
+ /** A cache for nodes in the factor_pools tree. */
+ struct factor_pool factor_pool_cache[FACTOR_POOL_MAX];
+ /** First free element in factor_pool_cache. */
+ struct factor_pool *factor_pool_next;
+ /**
+ * A red-black tree with "factored" pools, i.e.
+ * each pool differs from its neighbor by a factor.
+ */
+ factor_tree_t factor_pools;
+ struct slab_cache *cache;
+ /**
+ * The factor used for factored pools. Must be > 1.
+ * Is provided during initialization.
+ */
+ float factor;
+ /** All slabs in all mempools have the same order. */
+ uint8_t slab_order;
+};
+
+/** Initialize a small memory allocator. */
+void
+small_alloc_create(struct small_alloc *alloc, struct slab_cache *cache,
+ uint32_t objsize_min, uint32_t objsize_max,
+ float alloc_factor);
+
+/** Destroy the allocator and all allocated memory. */
+void
+small_alloc_destroy(struct small_alloc *alloc);
+
+/** Allocate a piece of memory in the small allocator.
+ *
+ * @retval NULL the requested size is beyond objsize_max
+ * or out of memory
+ */
+void *
+smalloc_nothrow(struct small_alloc *alloc, size_t size);
+
+/** Free memory chunk allocated by the small allocator. */
+void
+smfree(struct small_alloc *alloc, void *ptr);
+
+/**
+ * @brief Return an unique index associated with a chunk allocated
+ * by the allocator.
+ *
+ * This index space is more dense than the pointers space,
+ * especially in the least significant bits. This number is
+ * needed because some types of box's indexes (e.g. BITSET) have
+ * better performance then they operate on sequential offsets
+ * (i.e. dense space) instead of memory pointers (sparse space).
+ *
+ * The calculation is based on SLAB number and the position of an
+ * item within it. Current implementation only guarantees that
+ * adjacent chunks from one SLAB will have consecutive indexes.
+ * That is, if two chunks were sequentially allocated from one
+ * chunk they will have sequential ids. If a second chunk was
+ * allocated from another SLAB thеn the difference between indexes
+ * may be more than one.
+ *
+ * @param ptr pointer to memory allocated in small_alloc
+ * @return unique index
+ */
+size_t
+small_ptr_compress(struct small_alloc *alloc, void *ptr);
+
+void *
+small_ptr_decompress(struct small_alloc *alloc, size_t val);
+
+typedef void (*mempool_stats_cb)(void *cb_ctx,
+ struct mempool_stats *stats);
+
+void
+small_stats(struct small_alloc *alloc,
+ struct small_stats *totals,
+ mempool_stats_cb cb, void *cb_ctx);
+
+#ifdef __cplusplus
+#include "exception.h"
+
+static inline void *
+smalloc(struct small_alloc *alloc, size_t size)
+{
+ void *ptr = smalloc_nothrow(alloc, size);
+ if (ptr == NULL)
+ tnt_raise(LoggedError, ER_MEMORY_ISSUE,
+ size, "small object allocator", "new slab");
+ return ptr;
+}
+
+static inline void *
+smalloc0(struct small_alloc *alloc, size_t size)
+{
+ return memset(smalloc(alloc, size), 0, size);
+}
+
+} /* extern "C" */
+#endif
+
+#endif /* INCLUDES_TARANTOOL_SMALL_SMALL_H */
diff --git a/include/log_io.h b/include/log_io.h
index 2493f914148bb6b22276298cb84878352fd79c83..e4e1dd9e235012eeacb00e0cf7c9e2e1026fb335 100644
--- a/include/log_io.h
+++ b/include/log_io.h
@@ -32,10 +32,9 @@
#include <limits.h>
#include <stdbool.h>
#include "tarantool/util.h"
-#include "tbuf.h"
#include "tarantool_ev.h"
-extern const u32 default_version;
+extern const uint32_t default_version;
enum log_format { XLOG = 65534, SNAP = 65535 };
@@ -64,12 +63,12 @@ struct log_dir {
extern struct log_dir snap_dir;
extern struct log_dir wal_dir;
-i64
+int64_t
greatest_lsn(struct log_dir *dir);
char *
-format_filename(struct log_dir *dir, i64 lsn, enum log_suffix suffix);
-i64
-find_including_file(struct log_dir *dir, i64 target_lsn);
+format_filename(struct log_dir *dir, int64_t lsn, enum log_suffix suffix);
+int64_t
+find_including_file(struct log_dir *dir, int64_t target_lsn);
struct log_io {
struct log_dir *dir;
@@ -84,9 +83,9 @@ struct log_io {
};
struct log_io *
-log_io_open_for_read(struct log_dir *dir, i64 lsn, enum log_suffix suffix);
+log_io_open_for_read(struct log_dir *dir, int64_t lsn, enum log_suffix suffix);
struct log_io *
-log_io_open_for_write(struct log_dir *dir, i64 lsn, enum log_suffix suffix);
+log_io_open_for_write(struct log_dir *dir, int64_t lsn, enum log_suffix suffix);
struct log_io *
log_io_open(struct log_dir *dir, enum log_mode mode,
const char *filename, enum log_suffix suffix, FILE *file);
@@ -109,26 +108,27 @@ void
log_io_cursor_open(struct log_io_cursor *i, struct log_io *l);
void
log_io_cursor_close(struct log_io_cursor *i);
-struct tbuf *
-log_io_cursor_next(struct log_io_cursor *i);
-typedef u32 log_magic_t;
+const char *
+log_io_cursor_next(struct log_io_cursor *i, uint32_t *rowlen);
+
+typedef uint32_t log_magic_t;
struct header_v11 {
- u32 header_crc32c;
- i64 lsn;
+ uint32_t header_crc32c;
+ int64_t lsn;
double tm;
- u32 len;
- u32 data_crc32c;
+ uint32_t len;
+ uint32_t data_crc32c;
} __attribute__((packed));
-static inline struct header_v11 *header_v11(const struct tbuf *t)
+static inline struct header_v11 *header_v11(const char *t)
{
- return (struct header_v11 *)t->data;
+ return (struct header_v11 *)t;
}
static inline void
-header_v11_fill(struct header_v11 *header, u64 lsn, size_t data_len)
+header_v11_fill(struct header_v11 *header, int64_t lsn, size_t data_len)
{
header->lsn = lsn;
header->tm = ev_now();
@@ -141,15 +141,15 @@ header_v11_sign(struct header_v11 *header);
struct row_v11 {
log_magic_t marker;
struct header_v11 header;
- u16 tag;
- u64 cookie;
- u8 data[];
+ uint16_t tag;
+ uint64_t cookie;
+ uint8_t data[];
} __attribute__((packed));
void
-row_v11_fill(struct row_v11 *row, u64 lsn, u16 tag, u64 cookie,
- const char *metadata, size_t metadata_len, const char
- *data, size_t data_len);
+row_v11_fill(struct row_v11 *row, int64_t lsn, uint16_t tag,
+ uint64_t cookie, const char *metadata, size_t metadata_len,
+ const char *data, size_t data_len);
static inline size_t
row_v11_size(struct row_v11 *row)
diff --git a/include/mhash.h b/include/mhash.h
index 722a9dffc9e973c038a056336a9524595200e07d..e6bfc1943896cc35fffa1589125b72cda194803f 100644
--- a/include/mhash.h
+++ b/include/mhash.h
@@ -170,6 +170,32 @@ _mh(next_slot)(mh_int_t slot, mh_int_t inc, mh_int_t size)
return slot >= size ? slot - size : slot;
}
+#if defined(mh_hash_key) && defined(mh_eq_key)
+/**
+ * If it is necessary to search by something different
+ * than a hash node, define mh_hash_key and mh_eq_key
+ * and use mh_find().
+ */
+static inline mh_int_t
+_mh(find)(struct _mh(t) *h, mh_key_t key, mh_arg_t arg)
+{
+ (void) arg;
+
+ mh_int_t k = mh_hash_key(key, arg);
+ mh_int_t i = k % h->n_buckets;
+ mh_int_t inc = 1 + k % (h->n_buckets - 1);
+ for (;;) {
+ if ((mh_exist(h, i) && mh_eq_key(key, mh_node(h, i), arg)))
+ return i;
+
+ if (!mh_dirty(h, i))
+ return h->n_buckets;
+
+ i = _mh(next_slot)(i, inc, h->n_buckets);
+ }
+}
+#endif
+
static inline mh_int_t
_mh(get)(struct _mh(t) *h, const mh_node_t *node,
mh_arg_t arg)
@@ -504,9 +530,12 @@ _mh(dump)(struct _mh(t) *h)
#undef mh_int_t
#undef mh_node_t
#undef mh_arg_t
+#undef mh_key_t
#undef mh_name
#undef mh_hash
+#undef mh_hash_key
#undef mh_eq
+#undef mh_eq_key
#undef mh_node
#undef mh_dirty
#undef mh_place
diff --git a/include/recovery.h b/include/recovery.h
index 97f7673fd0d4607a82f715cb2a6d6d47c79f3cb8..1757593728a0cfa08efbab7b583b2a5c0414ea47 100644
--- a/include/recovery.h
+++ b/include/recovery.h
@@ -43,7 +43,7 @@ struct tbuf;
#define RECOVER_READONLY 1
-typedef int (row_handler)(void *, struct tbuf *);
+typedef int (row_handler)(void *, const char *, uint32_t);
/** A "condition variable" that allows fibers to wait when a given
* LSN makes it to disk.
@@ -51,11 +51,11 @@ typedef int (row_handler)(void *, struct tbuf *);
struct wait_lsn {
struct fiber *waiter;
- i64 lsn;
+ int64_t lsn;
};
void
-wait_lsn_set(struct wait_lsn *wait_lsn, i64 lsn);
+wait_lsn_set(struct wait_lsn *wait_lsn, int64_t lsn);
inline static void
wait_lsn_clear(struct wait_lsn *wait_lsn)
@@ -71,7 +71,7 @@ struct wal_watcher;
struct remote {
struct sockaddr_in addr;
struct fiber *reader;
- u64 cookie;
+ uint64_t cookie;
ev_tstamp recovery_lag, recovery_last_update_tstamp;
};
@@ -81,7 +81,7 @@ enum wal_mode { WAL_NONE = 0, WAL_WRITE, WAL_FSYNC, WAL_FSYNC_DELAY, WAL_MODE_MA
extern const char *wal_mode_STRS[];
struct recovery_state {
- i64 lsn, confirmed_lsn;
+ int64_t lsn, confirmed_lsn;
/* The WAL we're currently reading/writing from/to. */
struct log_io *current_wal;
struct log_dir *snap_dir;
@@ -122,8 +122,8 @@ void recover_snap(struct recovery_state *);
void recover_existing_wals(struct recovery_state *);
void recovery_follow_local(struct recovery_state *r, ev_tstamp wal_dir_rescan_delay);
void recovery_finalize(struct recovery_state *r);
-int wal_write(struct recovery_state *r, i64 lsn, u64 cookie,
- u16 op, const char *data, u32 len);
+int wal_write(struct recovery_state *r, int64_t lsn, uint64_t cookie,
+ uint16_t op, const char *data, uint32_t len);
void recovery_setup_panic(struct recovery_state *r, bool on_snap_error, bool on_wal_error);
diff --git a/include/rlist.h b/include/rlist.h
index 1756efb5c07bf9404d35b63371352c9dd9acd00c..399de75470f998c1f6f8f4e47f4c853f7fa545ff 100644
--- a/include/rlist.h
+++ b/include/rlist.h
@@ -97,8 +97,6 @@ rlist_del(struct rlist *item)
inline static struct rlist *
rlist_shift(struct rlist *head)
{
- if (head->next == head->prev)
- return 0;
struct rlist *shift = head->next;
head->next = shift->next;
shift->next->prev = head;
@@ -194,12 +192,16 @@ rlist_move_tail(struct rlist *to, struct rlist *item)
#define rlist_first_entry(head, type, member) \
rlist_entry(rlist_first(head), type, member)
-#define rlist_shift_entry(head, type, member) ({ \
- struct rlist *_shift = rlist_shift(head); \
- _shift ? rlist_entry(_shift, type, member) : 0; })
+/**
+ * Remove one element from the list and return it
+ * @pre the list is not empty
+ */
+#define rlist_shift_entry(head, type, member) \
+ rlist_entry(rlist_shift(head), type, member) \
/**
* return last entry
+ * @pre the list is not empty
*/
#define rlist_last_entry(head, type, member) \
rlist_entry(rlist_last(head), type, member)
@@ -250,30 +252,35 @@ delete from one list and add_tail as another's head
* foreach through list
*/
#define rlist_foreach(item, head) \
- for(item = rlist_first(head); item != (head); item = rlist_next(item))
+ for (item = rlist_first(head); item != (head); item = rlist_next(item))
/**
* foreach backward through list
*/
#define rlist_foreach_reverse(item, head) \
- for(item = rlist_last(head); item != (head); item = rlist_prev(item))
+ for (item = rlist_last(head); item != (head); item = rlist_prev(item))
/**
* foreach through all list entries
*/
#define rlist_foreach_entry(item, head, member) \
- for(item = rlist_first_entry((head), typeof(*item), member); \
- &item->member != (head); \
- item = rlist_next_entry((item), member))
+ for (item = rlist_first_entry((head), typeof(*item), member); \
+ &item->member != (head); \
+ item = rlist_next_entry((item), member))
/**
* foreach backward through all list entries
*/
#define rlist_foreach_entry_reverse(item, head, member) \
- for(item = rlist_last_entry((head), typeof(*item), member); \
- &item->member != (head); \
- item = rlist_prev_entry((item), member))
-
+ for (item = rlist_last_entry((head), typeof(*item), member); \
+ &item->member != (head); \
+ item = rlist_prev_entry((item), member))
+
+#define rlist_foreach_entry_safe(item, head, member, tmp) \
+ for ((item) = rlist_first_entry((head), typeof(*item), member); \
+ &item->member != (head) && \
+ ((tmp) = rlist_next_entry((item), member)); \
+ (item) = (tmp))
#if defined(__cplusplus)
} /* extern "C" */
diff --git a/include/salloc.h b/include/salloc.h
index 0b9cd53ec0d17594ad293b47bb1ce2b3494c6435..4b7e5e97e427490dcb1a07a1517c59399dd4cef2 100644
--- a/include/salloc.h
+++ b/include/salloc.h
@@ -30,7 +30,7 @@
*/
#include <stddef.h>
#include <stdbool.h>
-#include "tarantool/util.h" /* for u64 */
+#include "tarantool/util.h" /* for uint64_t */
struct tbuf;
@@ -42,11 +42,11 @@ void slab_validate();
/** Statistics on utilization of a single slab class. */
struct slab_cache_stats {
- i64 item_size;
- i64 slabs;
- i64 items;
- i64 bytes_used;
- i64 bytes_free;
+ int64_t item_size;
+ int64_t slabs;
+ int64_t items;
+ int64_t bytes_used;
+ int64_t bytes_free;
};
/** Statistics on utilization of the slab allocator. */
diff --git a/include/stat.h b/include/stat.h
index 478eeb4f4c9f2f4dc3312d1e2b40b2533ccaf347..26b9fdb4e1e82b5422b9eac235754d07dabe0fbc 100644
--- a/include/stat.h
+++ b/include/stat.h
@@ -36,9 +36,9 @@ void stat_cleanup(int base, size_t max_idx);
int stat_register(const char **name, size_t count);
extern int stat_max_name_len;
-void stat_collect(int base, int name, i64 value);
+void stat_collect(int base, int name, int64_t value);
-typedef int (*stat_cb)(const char *name, int rps, i64 total, void *cb_ctx);
+typedef int (*stat_cb)(const char *name, int rps, int64_t total, void *cb_ctx);
int stat_foreach(stat_cb cb, void *cb_ctx);
diff --git a/include/tarantool.h b/include/tarantool.h
index f9589f2ffeb4bf9204d74e95f5f210aba6acbc08..017ae428814d05b6e5f71b3a52ad5fcb092b0b7c 100644
--- a/include/tarantool.h
+++ b/include/tarantool.h
@@ -45,7 +45,7 @@ extern char *cfg_filename_fullpath;
extern bool init_storage, booting;
extern char *binary_filename;
extern char *custom_proc_title;
-i32 reload_cfg(struct tbuf *out);
+int reload_cfg(struct tbuf *out);
void show_cfg(struct tbuf *out);
int snapshot(void);
const char *tarantool_version(void);
diff --git a/include/tarantool/util.h b/include/tarantool/util.h
index 7712da55bd26807e3f18a225cb9b09f83eb763d7..af2a0549abfe35113195c77a60ebf3dc2990284c 100644
--- a/include/tarantool/util.h
+++ b/include/tarantool/util.h
@@ -121,15 +121,6 @@ strindex(const char **haystack, const char *needle, uint32_t hmax);
#define CACHEALIGN(LEN) TYPEALIGN(32, (LEN))
#endif
-typedef uint8_t u8;
-typedef uint16_t u16;
-typedef uint32_t u32;
-typedef uint64_t u64;
-typedef int8_t i8;
-typedef int16_t i16;
-typedef int32_t i32;
-typedef int64_t i64;
-
#define CRLF "\n"
#ifdef GCC
diff --git a/include/tbuf.h b/include/tbuf.h
index 551ef726fada37f2b5c48bc83c45a3637b2dbf0c..b08cab42ace1e2a0646d67fd42481290391180c6 100644
--- a/include/tbuf.h
+++ b/include/tbuf.h
@@ -40,9 +40,9 @@ extern "C" {
struct tbuf {
/* Used space in the buffer. */
- u32 size;
+ uint32_t size;
/* Total allocated buffer capacity. */
- u32 capacity;
+ uint32_t capacity;
/* Allocated buffer. */
char *data;
struct palloc_pool *pool;
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index 78145267b547b293e652c62ad188207dd0e40a7f..fe000c8f2b4abfb3e744f0c6301f375784370ae9 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -37,7 +37,7 @@ add_custom_command(OUTPUT ${CMAKE_SOURCE_DIR}/src/memcached-grammar.cc
-o src/memcached-grammar.cc
DEPENDS ${CMAKE_SOURCE_DIR}/src/memcached-grammar.rl)
-add_custom_target(generate_admin_m DEPENDS ${CMAKE_SOURCE_DIR}/src/admin.cc)
+add_custom_target(generate_admin_cc DEPENDS ${CMAKE_SOURCE_DIR}/src/admin.cc)
add_custom_target(generate_memcached_grammar_cc DEPENDS
${CMAKE_SOURCE_DIR}/src/memcached-grammar.cc)
@@ -103,6 +103,7 @@ set (common_sources
cpu_feature.c
replica.cc
iproto.cc
+ iproto_port.cc
session.cc
object.cc
exception.cc
@@ -205,7 +206,7 @@ function(tarantool_module mod)
add_library(lt${mod} STATIC ${recompiled_sources})
set_target_properties(lt${mod} PROPERTIES COMPILE_FLAGS
"-DTARANTOOL_CONFIG='<cfg/tarantool_${mod}_cfg.h>'")
- add_dependencies(lt${mod} generate_headers generate_admin_m generate_memcached_grammar_m build_bundled_libs)
+ add_dependencies(lt${mod} generate_headers generate_admin_cc generate_memcached_grammar_cc build_bundled_libs)
target_link_libraries(tarantool_${mod} lt${mod} ${common_libraries})
diff --git a/src/admin.cc b/src/admin.cc
index 02f717a0a6510df3bbe274c7545df70e0ab81cba..6512d9d424e0f84ef7ffa4106c7fbff2336863f1 100644
--- a/src/admin.cc
+++ b/src/admin.cc
@@ -91,7 +91,7 @@ static const int admin_en_main = 1;
struct salloc_stat_admin_cb_ctx {
- i64 total_used;
+ int64_t total_used;
struct tbuf *out;
};
@@ -186,7 +186,7 @@ tarantool_info(struct tbuf *out)
}
static int
-show_stat_item(const char *name, int rps, i64 total, void *ctx)
+show_stat_item(const char *name, int rps, int64_t total, void *ctx)
{
struct tbuf *buf = (struct tbuf *) ctx;
int name_len = strlen(name);
diff --git a/src/admin.rl b/src/admin.rl
index 56bd8b30006ad01034d3800e4927cd8c313f01fc..f336ca78eef57288569dbf2b7235a993d799a42e 100644
--- a/src/admin.rl
+++ b/src/admin.rl
@@ -82,7 +82,7 @@ static const char *unknown_command = "unknown command. try typing help." CRLF;
}%%
struct salloc_stat_admin_cb_ctx {
- i64 total_used;
+ int64_t total_used;
struct tbuf *out;
};
@@ -177,7 +177,7 @@ tarantool_info(struct tbuf *out)
}
static int
-show_stat_item(const char *name, int rps, i64 total, void *ctx)
+show_stat_item(const char *name, int rps, int64_t total, void *ctx)
{
struct tbuf *buf = (struct tbuf *) ctx;
int name_len = strlen(name);
diff --git a/src/box/CMakeLists.txt b/src/box/CMakeLists.txt
index 4e251781ae7f04eb9075aa2feb8b154b7d607746..9929d5be5da4db8974cc4bbc9ab34fc7c6ea7641 100644
--- a/src/box/CMakeLists.txt
+++ b/src/box/CMakeLists.txt
@@ -15,8 +15,21 @@ add_custom_target(box_generate_lua_sources
DEPENDS ${lua_sources})
set_property(DIRECTORY PROPERTY ADDITIONAL_MAKE_CLEAN_FILES ${lua_sources})
-tarantool_module("box" tuple.cc index.cc hash_index.cc tree_index.cc space.cc
- port.cc request.cc tuple_update.cc txn.cc box.cc ${lua_sources} box_lua.cc box_lua_space.cc
- bitset_index.cc)
+tarantool_module("box"
+ tuple.cc
+ tuple_convert.cc
+ tuple_update.cc
+ index.cc
+ hash_index.cc
+ tree_index.cc
+ bitset_index.cc
+ space.cc
+ port.cc
+ request.cc
+ txn.cc
+ box.cc
+ ${lua_sources}
+ box_lua.cc
+ box_lua_space.cc)
target_link_libraries(tarantool_box bitset)
diff --git a/src/box/bitset_index.cc b/src/box/bitset_index.cc
index 7dc944ddfb7a0b6b4bb6a1ace7fa180ccce0a589..bb548e6252c4f9cccf583a0df2330811af36ef56 100644
--- a/src/box/bitset_index.cc
+++ b/src/box/bitset_index.cc
@@ -153,7 +153,7 @@ BitsetIndex::max() const
}
struct tuple *
-BitsetIndex::random(u32 rnd) const
+BitsetIndex::random(uint32_t rnd) const
{
(void) rnd;
tnt_raise(ClientError, ER_UNSUPPORTED, "BitsetIndex", "random()");
@@ -178,7 +178,7 @@ BitsetIndex::allocIterator() const
}
struct tuple *
-BitsetIndex::findByKey(const char *key, u32 part_count) const
+BitsetIndex::findByKey(const char *key, uint32_t part_count) const
{
(void) key;
(void) part_count;
@@ -232,7 +232,7 @@ BitsetIndex::replace(struct tuple *old_tuple, struct tuple *new_tuple,
void
BitsetIndex::initIterator(struct iterator *iterator, enum iterator_type type,
- const char *key, u32 part_count) const
+ const char *key, uint32_t part_count) const
{
assert(iterator->free == bitset_index_iterator_free);
assert (part_count != 0 || key == NULL);
diff --git a/src/box/bitset_index.h b/src/box/bitset_index.h
index 4b3c4c4fca71d47d2f49b7fc6727633da6b11caa..f78236f5ff50642935f77b862784173541d9ae06 100644
--- a/src/box/bitset_index.h
+++ b/src/box/bitset_index.h
@@ -53,8 +53,8 @@ class BitsetIndex: public Index {
virtual size_t size() const;
virtual struct tuple *min() const;
virtual struct tuple *max() const;
- virtual struct tuple *random(u32 rnd) const;
- virtual struct tuple *findByKey(const char *key, u32 part_count) const;
+ virtual struct tuple *random(uint32_t rnd) const;
+ virtual struct tuple *findByKey(const char *key, uint32_t part_count) const;
virtual struct tuple *findByTuple(struct tuple *tuple) const;
virtual struct tuple *replace(struct tuple *old_tuple,
struct tuple *new_tuple,
@@ -63,7 +63,7 @@ class BitsetIndex: public Index {
virtual struct iterator *allocIterator() const;
virtual void initIterator(struct iterator *iterator,
enum iterator_type type,
- const char *key, u32 part_count) const;
+ const char *key, uint32_t part_count) const;
private:
struct bitset_index index;
};
diff --git a/src/box/box.cc b/src/box/box.cc
index 7bbc8f16fa19a5c2f5f3a5ea7968ecf1a77e4cd7..019ee1bc99ecd4e487dffe331a8f407ebd38907a 100644
--- a/src/box/box.cc
+++ b/src/box/box.cc
@@ -52,11 +52,11 @@ extern "C" {
#include <third_party/base64.h>
static void process_replica(struct port *port,
- u32 op, const char *reqdata, u32 reqlen);
+ uint32_t op, const char *reqdata, uint32_t reqlen);
static void process_ro(struct port *port,
- u32 op, const char *reqdata, u32 reqlen);
+ uint32_t op, const char *reqdata, uint32_t reqlen);
static void process_rw(struct port *port,
- u32 op, const char *reqdata, u32 reqlen);
+ uint32_t op, const char *reqdata, uint32_t reqlen);
box_process_func box_process = process_ro;
box_process_func box_process_ro = process_ro;
@@ -65,14 +65,14 @@ static char status[64] = "unknown";
static int stat_base;
struct box_snap_row {
- u32 space;
- u32 tuple_size;
- u32 data_size;
+ uint32_t space;
+ uint32_t tuple_size;
+ uint32_t data_size;
char data[];
} __attribute__((packed));
void
-port_send_tuple(struct port *port, struct txn *txn, u32 flags)
+port_send_tuple(struct port *port, struct txn *txn, uint32_t flags)
{
struct tuple *tuple;
if ((tuple = txn->new_tuple) || (tuple = txn->old_tuple))
@@ -80,7 +80,7 @@ port_send_tuple(struct port *port, struct txn *txn, u32 flags)
}
static void
-process_rw(struct port *port, u32 op, const char *reqdata, u32 reqlen)
+process_rw(struct port *port, uint32_t op, const char *reqdata, uint32_t reqlen)
{
struct txn *txn = txn_begin();
@@ -99,7 +99,7 @@ process_rw(struct port *port, u32 op, const char *reqdata, u32 reqlen)
}
static void
-process_replica(struct port *port, u32 op, const char *reqdata, u32 reqlen)
+process_replica(struct port *port, uint32_t op, const char *reqdata, uint32_t reqlen)
{
if (!request_is_select(op)) {
tnt_raise(ClientError, ER_NONMASTER,
@@ -109,7 +109,7 @@ process_replica(struct port *port, u32 op, const char *reqdata, u32 reqlen)
}
static void
-process_ro(struct port *port, u32 op, const char *reqdata, u32 reqlen)
+process_ro(struct port *port, uint32_t op, const char *reqdata, uint32_t reqlen)
{
if (!request_is_select(op))
tnt_raise(LoggedError, ER_SECONDARY);
@@ -158,25 +158,25 @@ recover_snap_row(const void *data)
}
static int
-recover_row(void *param __attribute__((unused)), struct tbuf *t)
+recover_row(void *param __attribute__((unused)), const char *row, uint32_t rowlen)
{
/* drop wal header */
- if (tbuf_peek(t, sizeof(struct header_v11)) == NULL) {
+ if (rowlen < sizeof(struct header_v11)) {
say_error("incorrect row header: expected %zd, got %zd bytes",
- sizeof(struct header_v11), (size_t) t->size);
+ sizeof(struct header_v11), (size_t) rowlen);
return -1;
}
try {
- const char *data = t->data;
- const char *end = t->data + t->size;
- u16 tag = pick_u16(&data, end);
- (void) pick_u64(&data, end); /* drop cookie */
+ const char *end = row + rowlen;
+ row += sizeof(struct header_v11);
+ uint16_t tag = pick_u16(&row, end);
+ (void) pick_u64(&row, end); /* drop cookie */
if (tag == SNAP) {
- recover_snap_row(data);
+ recover_snap_row(row);
} else if (tag == XLOG) {
- u16 op = pick_u16(&data, end);
- process_rw(&port_null, op, data, end - data);
+ uint16_t op = pick_u16(&row, end);
+ process_rw(&null_port, op, row, end - row);
} else {
say_error("unknown row tag: %i", (int)tag);
return -1;
@@ -226,7 +226,7 @@ box_leave_local_standby_mode(void *data __attribute__((unused)))
box_enter_master_or_replica_mode(&cfg);
}
-i32
+int
box_check_config(struct tarantool_cfg *conf)
{
/* replication & hot standby modes can not work together */
@@ -286,7 +286,7 @@ box_check_config(struct tarantool_cfg *conf)
return 0;
}
-i32
+int
box_reload_config(struct tarantool_cfg *old_conf, struct tarantool_cfg *new_conf)
{
bool old_is_replica = old_conf->replication_source != NULL;
@@ -367,7 +367,7 @@ box_init(void)
static void
snapshot_write_tuple(struct log_io *l, struct fio_batch *batch,
- u32 n, struct tuple *tuple)
+ uint32_t n, struct tuple *tuple)
{
struct box_snap_row header;
header.space = n;
diff --git a/src/box/box_lua.cc b/src/box/box_lua.cc
index 48fbec10f06acc8ab1ed867d7a8af5ed6bbb1e73..21503c9928c71d8d945b497609712265f5000660 100644
--- a/src/box/box_lua.cc
+++ b/src/box/box_lua.cc
@@ -81,6 +81,7 @@ static lua_State *root_L;
*/
static const char *tuplelib_name = "box.tuple";
+static const char *tuple_iteratorlib_name = "box.tuple.iterator";
static void
lbox_pushtuple(struct lua_State *L, struct tuple *tuple);
@@ -141,7 +142,8 @@ lbox_tuple_slice(struct lua_State *L)
{
struct tuple *tuple = lua_checktuple(L, 1);
int argc = lua_gettop(L) - 1;
- int start, end;
+ uint32_t start, end;
+ int offset;
/*
* Prepare the range. The second argument is optional.
@@ -150,91 +152,126 @@ lbox_tuple_slice(struct lua_State *L)
*/
if (argc == 0 || argc > 2)
luaL_error(L, "tuple.slice(): bad arguments");
- start = lua_tointeger(L, 2);
- if (start < 0)
- start += tuple->field_count;
+
+ offset = lua_tointeger(L, 2);
+ if (offset >= 0 && offset < tuple->field_count) {
+ start = offset;
+ } else if (offset < 0 && -offset <= tuple->field_count) {
+ start = offset + tuple->field_count;
+ } else {
+ return luaL_error(L, "tuple.slice(): start >= field count");
+ }
+
if (argc == 2) {
- end = lua_tointeger(L, 3);
- if (end < 0)
- end += tuple->field_count;
- else if (end > tuple->field_count)
- end = tuple->field_count;
+ offset = lua_tointeger(L, 3);
+ if (offset > 0 && offset <= tuple->field_count) {
+ end = offset;
+ } else if (offset < 0 && -offset < tuple->field_count) {
+ end = offset + tuple->field_count;
+ } else {
+ return luaL_error(L, "tuple.slice(): end > field count");
+ }
} else {
end = tuple->field_count;
}
if (end <= start)
- luaL_error(L, "tuple.slice(): start must be less than end");
-
- u32 stop = end - 1;
+ return luaL_error(L, "tuple.slice(): start must be less than end");
struct tuple_iterator it;
tuple_rewind(&it, tuple);
const char *field;
uint32_t len;
- uint32_t field_no = 0;
- while ((field = tuple_next(&it, &len))) {
- if (field_no >= start) {
- lua_pushlstring(L, field, len);
- if (field_no == stop)
- break;
- }
+
+ assert(start < tuple->field_count);
+ uint32_t field_no = start;
+ field = tuple_seek(&it, start, &len);
+ while (field && field_no < end) {
+ lua_pushlstring(L, field, len);
++field_no;
+ field = tuple_next(&it, &len);
}
+ assert(field_no == end);
return end - start;
}
+/** A single value on the Lua stack. */
+struct lua_field {
+ const char *data;
+ uint32_t len;
+ union {
+ uint32_t u32;
+ uint64_t u64;
+ };
+ enum field_data_type type;
+};
+
/**
- * Pack our BER integer into luaL_Buffer
+ * Convert a value on the lua stack to a Tarantool data type.
*/
static void
-luaL_addvarint32(luaL_Buffer *b, u32 value)
+lua_tofield(lua_State *L, int i, struct lua_field *field)
{
- char buf[sizeof(u32)+1];
- char *bufend = pack_varint32(buf, value);
- luaL_addlstring(b, buf, bufend - buf);
+ double num;
+ size_t size;
+ switch (lua_type(L, i)) {
+ case LUA_TNUMBER:
+ num = lua_tonumber(L, i);
+ if (num <= UINT32_MAX && num >= INT32_MIN) {
+ field->u32 = (uint32_t) num;
+ field->data = (const char *) &field->u32;
+ field->len = sizeof(uint32_t);
+ field->type = NUM;
+ return;
+ } else {
+ field->u64 = (uint64_t) num;
+ field->data = (const char *) &field->u64;
+ field->len = sizeof(uint64_t);
+ field->type = NUM64;
+ return;
+ }
+ case LUA_TCDATA:
+ field->u64 = tarantool_lua_tointeger64(L, i);
+ field->data = (const char *) &field->u64;
+ field->len = sizeof(uint64_t);
+ field->type = NUM64;
+ return;
+ case LUA_TBOOLEAN:
+ if (lua_toboolean(L, i)) {
+ field->data = "true";
+ field->len = 4;
+ } else {
+ field->data = "false";
+ field->len = 5;
+ }
+ field->type = STRING;
+ return;
+ case LUA_TNIL:
+ field->data = "nil";
+ field->len = 3;
+ field->type = STRING;
+ return;
+ case LUA_TSTRING:
+ field->data = lua_tolstring(L, i, &size);
+ field->len = (uint32_t) size;
+ field->type = STRING;
+ return;
+ default:
+ field->data = NULL;
+ field->len = 0;
+ field->type = UNKNOWN;
+ return;
+ }
}
/**
- * Convert an element on Lua stack to a part of an index
- * key.
- *
- * Lua type system has strings, numbers, booleans, tables,
- * userdata objects. Tarantool indexes only support 32/64-bit
- * integers and strings.
- *
- * Instead of considering each Tarantool <-> Lua type pair,
- * here we follow the approach similar to one in lbox_pack()
- * (see tarantool_lua.m):
- *
- * Lua numbers are converted to 32 or 64 bit integers,
- * if key part is integer. In all other cases,
- * Lua types are converted to Lua strings, and these
- * strings are used as key parts.
+ * Pack our BER integer into luaL_Buffer
*/
-void
-append_key_part(struct lua_State *L, int i, luaL_Buffer *b,
- enum field_data_type type)
+static void
+luaL_addvarint32(luaL_Buffer *b, uint32_t value)
{
- const char *str;
- size_t size;
- u32 v_u32;
- u64 v_u64;
-
- if (lua_type(L, i) == LUA_TNUMBER) {
- if (type == NUM64) {
- v_u64 = (u64) lua_tonumber(L, i);
- str = (char *) &v_u64;
- size = sizeof(u64);
- } else {
- v_u32 = (u32) lua_tointeger(L, i);
- str = (char *) &v_u32;
- size = sizeof(u32);
- }
- } else {
- str = luaL_checklstring(L, i, &size);
- }
- luaL_addvarint32(b, size);
- luaL_addlstring(b, str, size);
+ char buf[sizeof(uint32_t)+1];
+ char *bufend = pack_varint32(buf, value);
+ luaL_addlstring(b, buf, bufend - buf);
}
/**
@@ -255,7 +292,7 @@ lbox_tuple_transform(struct lua_State *L)
if (argc < 3)
luaL_error(L, "tuple.transform(): bad arguments");
lua_Integer offset = lua_tointeger(L, 2); /* Can be negative and can be > INT_MAX */
- lua_Integer len = lua_tointeger(L, 3);
+ lua_Integer field_count = lua_tointeger(L, 3);
/* validate offset and len */
if (offset < 0) {
@@ -265,53 +302,22 @@ lbox_tuple_transform(struct lua_State *L)
} else if (offset > tuple->field_count) {
offset = tuple->field_count;
}
- if (len < 0)
+ if (field_count < 0)
luaL_error(L, "tuple.transform(): len is negative");
- if (len > tuple->field_count - offset)
- len = tuple->field_count - offset;
+ if (field_count > tuple->field_count - offset)
+ field_count = tuple->field_count - offset;
- assert(offset + len <= tuple->field_count);
+ assert(offset + field_count <= tuple->field_count);
/*
* Calculate the number of operations and length of UPDATE expression
*/
- uint32_t op_cnt = 0;
- size_t expr_len = 0;
- expr_len += sizeof(uint32_t); /* op_count */
- if (offset < tuple->field_count) {
- /* Add an UPDATE operation for each removed field. */
- op_cnt += len;
- expr_len += len * sizeof(uint32_t); /* Field */
- expr_len += len * sizeof(uint8_t); /* UPDATE_OP_DELETE */
- expr_len += len * varint32_sizeof(0); /* Unused */
- }
-
- for (int i = 4; i <= argc; i++) {
- uint32_t field_len = 0;
- switch (lua_type(L, i)) {
- case LUA_TNUMBER:
- field_len = sizeof(uint32_t);
- break;
- case LUA_TCDATA:
- field_len = sizeof(uint64_t);
- break;
- case LUA_TSTRING:
- field_len = lua_objlen(L, i);
- break;
- default:
- luaL_error(L, "tuple.transform(): unsupported field type '%s'",
- lua_typename(L, lua_type(L, i)));
- break;
- }
+ uint32_t op_cnt = offset < tuple->field_count ? field_count : 0;
+ if (argc > 3)
+ op_cnt += argc - 3;
- /* Insert one field */
- op_cnt++;
- expr_len += sizeof(uint32_t); /* Field Number */
- expr_len += sizeof(uint8_t); /* UPDATE_OP_SET */
- expr_len += varint32_sizeof(field_len) + field_len; /* Field */
- }
if (op_cnt == 0) {
- /* tuple_upate() does not accept an empty operation list. */
+ /* tuple_update() does not accept an empty operation list. */
lbox_pushtuple(L, tuple);
return 1;
}
@@ -319,47 +325,32 @@ lbox_tuple_transform(struct lua_State *L)
/*
* Prepare UPDATE expression
*/
- char *expr = (char *) palloc(fiber->gc_pool, expr_len);
- char *pos = expr;
- pos = pack_u32(pos, op_cnt);
- for (uint32_t i = 0; i < (uint32_t) len; i++) {
- pos = pack_u32(pos, offset);
- pos = pack_u8(pos, UPDATE_OP_DELETE);
- pos = pack_varint32(pos, 0);
+ luaL_Buffer b;
+ luaL_buffinit(L, &b);
+ luaL_addlstring(&b, (char *) &op_cnt, sizeof(op_cnt));
+ uint32_t offset_u32 = (uint32_t) offset;
+ for (uint32_t i = 0; i < (uint32_t) field_count; i++) {
+ luaL_addlstring(&b, (char *) &offset_u32, sizeof(offset_u32));
+ luaL_addchar(&b, UPDATE_OP_DELETE);
+ luaL_addvarint32(&b, 0); /* Unused. */
}
- for (int i = argc ; i >= 4; i--) {
- uint32_t field_u32;
- uint64_t field_u64;
- const char *field = NULL;
- size_t field_len = 0;
- switch (lua_type(L, i)) {
- case LUA_TNUMBER:
- field_u32 = lua_tonumber(L, i);
- field = (const char *) &field_u32;
- field_len = sizeof(uint32_t);
- break;
- case LUA_TCDATA:
- field_u64 = tarantool_lua_tointeger64(L, i);
- field = (const char *) &field_u64;
- field_len = sizeof(uint64_t);
- break;
- case LUA_TSTRING:
- field = luaL_checklstring(L, i, &field_len);
- break;
- default:
- assert(false);
- break;
+ for (int i = argc ; i > 3; i--) {
+ luaL_addlstring(&b, (char *) &offset_u32, sizeof(offset_u32));
+ luaL_addchar(&b, UPDATE_OP_INSERT);
+ struct lua_field field;
+ lua_tofield(L, i, &field);
+ if (field.type == UNKNOWN) {
+ return luaL_error(L, "tuple.transform(): "
+ "unsupported field type '%s'",
+ lua_typename(L, lua_type(L, i)));
}
-
- assert(field_len <= UINT32_MAX);
- /* Insert the field */
- pos = pack_u32(pos, offset); /* Field Number */
- pos = pack_u8(pos, UPDATE_OP_INSERT); /* Operation */
- pos = pack_lstr(pos, field, field_len); /* Field Value */
+ luaL_addvarint32(&b, field.len);
+ luaL_addlstring(&b, field.data, field.len);
}
-
- assert(pos == expr + expr_len);
+ luaL_pushresult(&b);
+ size_t expr_len;
+ const char *expr = lua_tolstring(L, -1, &expr_len);
/* Execute tuple_update */
struct tuple *new_tuple = tuple_update(tuple, expr, expr + expr_len);
@@ -413,28 +404,15 @@ lbox_tuple_find_do(struct lua_State *L, bool all)
default:
luaL_error(L, "tuple.find(): bad arguments");
}
- size_t key_size = 0;
- const char *key = NULL;
- u32 u32v;
- u64 u64v;
- switch (lua_type(L, argc)) {
- case LUA_TNUMBER:
- u32v = lua_tonumber(L, argc);
- key_size = sizeof(u32);
- key = (const char*)&u32v;
- break;
- case LUA_TCDATA:
- u64v = tarantool_lua_tointeger64(L, argc);
- key_size = sizeof(u64);
- key = (const char*)&u64v;
- break;
- case LUA_TSTRING:
- key = luaL_checklstring(L, argc, &key_size);
- break;
- default:
- luaL_error(L, "tuple.find(): bad field type");
- }
- return tuple_find(L, tuple, offset, key, key_size, all);
+
+ struct lua_field field;
+ lua_tofield(L, argc, &field);
+ if (field.type == UNKNOWN)
+ return luaL_error(L, "tuple.find(): unsupported field "
+ "type: %s",
+ lua_typename(L, lua_type(L, argc)));
+
+ return tuple_find(L, tuple, offset, field.data, field.len, all);
}
static int
@@ -550,22 +528,30 @@ lbox_tuple_next(struct lua_State *L)
struct tuple *tuple = lua_checktuple(L, 1);
int argc = lua_gettop(L) - 1;
- u32 field_no;
- if (argc == 0 || (argc == 1 && lua_type(L, 2) == LUA_TNIL))
- field_no = 0;
- else if (argc == 1 && lua_type(L, 2) == LUA_TNUMBER)
- field_no = lua_tointeger(L, 2);
- else
+ struct tuple_iterator *it = NULL;
+ if (argc == 0 || (argc == 1 && lua_type(L, 2) == LUA_TNIL)) {
+ it = (struct tuple_iterator *) lua_newuserdata(L, sizeof(*it));
+ assert (it != NULL);
+ luaL_getmetatable(L, tuple_iteratorlib_name);
+ lua_setmetatable(L, -2);
+ tuple_rewind(it, tuple);
+ } else if (argc == 1 && lua_type(L, 2) == LUA_TUSERDATA) {
+ it = (struct tuple_iterator *)
+ luaL_checkudata(L, 2, tuple_iteratorlib_name);
+ assert (it != NULL);
+ lua_pushvalue(L, 2);
+ } else {
return luaL_error(L, "tuple.next(): bad arguments");
+ }
- if (field_no >= tuple->field_count) {
+ uint32_t len;
+ const char *field = tuple_next(it, &len);
+ if (field == NULL) {
+ lua_pop(L, 1);
lua_pushnil(L);
return 1;
}
- uint32_t len;
- const char *field = tuple_field(tuple, field_no, &len);
- lua_pushinteger(L, field_no + 1);
lua_pushlstring(L, field, len);
return 2;
}
@@ -616,6 +602,10 @@ static const struct luaL_reg lbox_tuplelib[] = {
{NULL, NULL}
};
+static const struct luaL_reg lbox_tuple_iterator_meta[] = {
+ {NULL, NULL}
+};
+
/* }}} */
/** {{{ box.index Lua library: access to spaces and indexes
@@ -638,20 +628,20 @@ lbox_pushiterator(struct lua_State *L, Index *index,
struct iterator *it, enum iterator_type type,
const char *key, size_t size, int part_count)
{
- struct lbox_iterator_holder {
+ struct lbox_iterator_udata {
struct iterator *it;
char key[];
};
- struct lbox_iterator_holder *holder = (struct lbox_iterator_holder *)
- lua_newuserdata(L, sizeof(*holder) + size);
+ struct lbox_iterator_udata *udata = (struct lbox_iterator_udata *)
+ lua_newuserdata(L, sizeof(*udata) + size);
luaL_getmetatable(L, iteratorlib_name);
lua_setmetatable(L, -2);
- holder->it = it;
+ udata->it = it;
if (key) {
- memcpy(holder->key, key, size);
- key = holder->key;
+ memcpy(udata->key, key, size);
+ key = udata->key;
}
key_validate(index->key_def, type, key, part_count);
index->initIterator(it, type, key, part_count);
@@ -740,7 +730,7 @@ lbox_index_random(struct lua_State *L)
luaL_error(L, "Usage: index:random((uint32) rnd)");
Index *index = lua_checkindex(L, 1);
- u32 rnd = lua_tointeger(L, 2);
+ uint32_t rnd = lua_tointeger(L, 2);
lbox_pushtuple(L, index->random(rnd));
return 1;
}
@@ -780,7 +770,7 @@ lbox_create_iterator(struct lua_State *L)
/* Create a new iterator. */
enum iterator_type type = ITER_ALL;
- u32 key_part_count = 0;
+ uint32_t key_part_count = 0;
const char *key = NULL;
size_t key_size = 0;
if (argc == 1 || (argc == 2 && lua_type(L, 2) == LUA_TNIL)) {
@@ -802,16 +792,15 @@ lbox_create_iterator(struct lua_State *L)
/* Tuple. */
struct tuple *tuple = lua_checktuple(L, 2);
key_part_count = tuple->field_count;
- luaL_addlstring(&b, tuple->data, tuple->bsize);
+ tuple_to_luabuf(tuple, &b);
} else {
/* Single or multi- part key. */
key_part_count = argc - 2;
- for (u32 i = 0; i < key_part_count; i++) {
- enum field_data_type type = UNKNOWN;
- if (i < index->key_def->part_count) {
- type = index->key_def->parts[i].type;
- }
- append_key_part(L, i + 3, &b, type);
+ struct lua_field field;
+ for (uint32_t i = 0; i < key_part_count; i++) {
+ lua_tofield(L, i + 3, &field);
+ luaL_addvarint32(&b, field.len);
+ luaL_addlstring(&b, field.data, field.len);
}
}
/*
@@ -912,26 +901,25 @@ lbox_index_count(struct lua_State *L)
/* preparing single or multi-part key */
luaL_Buffer b;
luaL_buffinit(L, &b);
- u32 key_part_count;
+ uint32_t key_part_count;
if (argc == 1 && lua_type(L, 2) == LUA_TUSERDATA) {
/* Searching by tuple. */
struct tuple *tuple = lua_checktuple(L, 2);
- luaL_addlstring(&b, tuple->data, tuple->bsize);
+ tuple_to_luabuf(tuple, &b);
key_part_count = tuple->field_count;
} else {
/* Single or multi- part key. */
key_part_count = argc;
- for (u32 i = 0; i < argc; ++i) {
- enum field_data_type type = UNKNOWN;
- if (i < index->key_def->part_count) {
- type = index->key_def->parts[i].type;
- }
- append_key_part(L, i + 2, &b, type);
+ struct lua_field field;
+ for (uint32_t i = 0; i < argc; ++i) {
+ lua_tofield(L, i + 2, &field);
+ luaL_addvarint32(&b, field.len);
+ luaL_addlstring(&b, field.data, field.len);
}
}
luaL_pushresult(&b);
const char *key = lua_tostring(L, -1);
- u32 count = 0;
+ uint32_t count = 0;
key_validate(index->key_def, ITER_EQ, key, key_part_count);
/* Prepare index iterator */
@@ -986,7 +974,7 @@ static inline struct port_lua *
port_lua(struct port *port) { return (struct port_lua *) port; }
/*
- * For addU32/dupU32 do nothing -- the only u32 Box can give
+ * For addU32/dupU32 do nothing -- the only uint32_t Box can give
* us is tuple count, and we don't need it, since we intercept
* everything into Lua stack first.
* @sa port_add_lua_multret
@@ -994,7 +982,7 @@ port_lua(struct port *port) { return (struct port_lua *) port; }
static void
port_lua_add_tuple(struct port *port, struct tuple *tuple,
- u32 flags __attribute__((unused)))
+ uint32_t flags __attribute__((unused)))
{
lua_State *L = port_lua(port)->L;
try {
@@ -1006,7 +994,7 @@ port_lua_add_tuple(struct port *port, struct tuple *tuple,
struct port_vtab port_lua_vtab = {
port_lua_add_tuple,
- port_null_eof,
+ null_port_eof,
};
static struct port *
@@ -1026,48 +1014,21 @@ port_lua_create(struct lua_State *L)
static struct tuple *
lua_table_to_tuple(struct lua_State *L, int index)
{
- u32 field_count = 0;
- u32 tuple_len = 0;
-
- size_t field_len;
+ uint32_t field_count = 0;
+ uint32_t tuple_len = 0;
+ struct lua_field field;
/** First go: calculate tuple length. */
lua_pushnil(L); /* first key */
while (lua_next(L, index) != 0) {
++field_count;
- switch (lua_type(L, -1)) {
- case LUA_TNUMBER:
- {
- uint64_t n = lua_tonumber(L, -1);
- field_len = n > UINT32_MAX ? sizeof(uint64_t) : sizeof(uint32_t);
- break;
- }
- case LUA_TBOOLEAN:
- {
- bool value = lua_toboolean(L, -1);
- const char *str = value ? "true" : "false";
- field_len = strlen(str);
- break;
- }
- case LUA_TCDATA:
- {
- /* Check if we can convert. */
- (void) tarantool_lua_tointeger64(L, -1);
- field_len = sizeof(u64);
- break;
- }
- case LUA_TSTRING:
- {
- (void) lua_tolstring(L, -1, &field_len);
- break;
- }
- default:
+ lua_tofield(L, -1, &field);
+ if (field.type == UNKNOWN) {
tnt_raise(ClientError, ER_PROC_RET,
lua_typename(L, lua_type(L, -1)));
- break;
}
- tuple_len += field_len + varint32_sizeof(field_len);
+ tuple_len += field.len + varint32_sizeof(field.len);
lua_pop(L, 1);
}
struct tuple *tuple = tuple_alloc(tuple_len);
@@ -1082,41 +1043,8 @@ lua_table_to_tuple(struct lua_State *L, int index)
lua_pushnil(L); /* first key */
while (lua_next(L, index) != 0) {
- switch (lua_type(L, -1)) {
- case LUA_TNUMBER:
- {
- uint64_t n = lua_tonumber(L, -1);
- if (n > UINT32_MAX) {
- pos = pack_lstr(pos, &n, sizeof(n));
- } else {
- uint32_t n32 = (uint32_t) n;
- pos = pack_lstr(pos, &n32, sizeof(n32));
- }
- break;
- }
- case LUA_TBOOLEAN:
- {
- bool value = lua_toboolean(L, -1);
- const char *str = value ? "true" : "false";
- pos = pack_lstr(pos, str, strlen(str));
- break;
- }
- case LUA_TCDATA:
- {
- uint64_t n = tarantool_lua_tointeger64(L, -1);
- pos = pack_lstr(pos, &n, sizeof(n));
- break;
- }
- case LUA_TSTRING:
- {
- const char *field = lua_tolstring(L, -1, &field_len);
- pos = pack_lstr(pos, field, field_len);
- break;
- }
- default:
- assert(false);
- break;
- }
+ lua_tofield(L, -1, &field);
+ pos = pack_lstr(pos, field.data, field.len);
lua_pop(L, 1);
}
return tuple;
@@ -1127,54 +1055,24 @@ lua_totuple(struct lua_State *L, int index)
{
int type = lua_type(L, index);
struct tuple *tuple;
- switch (type) {
- case LUA_TTABLE:
- {
- tuple = lua_table_to_tuple(L, index);
- break;
- }
- case LUA_TNUMBER:
- {
- size_t len = sizeof(u32);
- u32 num = lua_tointeger(L, index);
- tuple = tuple_alloc(len + varint32_sizeof(len));
- tuple->field_count = 1;
- pack_lstr(tuple->data, &num, len);
- break;
- }
- case LUA_TCDATA:
- {
- u64 num = tarantool_lua_tointeger64(L, index);
- size_t len = sizeof(u64);
- tuple = tuple_alloc(len + varint32_sizeof(len));
+ struct lua_field field;
+ lua_tofield(L, index, &field);
+ if (field.type != UNKNOWN) {
+ tuple = tuple_alloc(field.len + varint32_sizeof(field.len));
tuple->field_count = 1;
- pack_lstr(tuple->data, &num, len);
- break;
+ pack_lstr(tuple->data, field.data, field.len);
+ return tuple;
}
- case LUA_TSTRING:
- {
- size_t len;
- const char *str = lua_tolstring(L, index, &len);
- tuple = tuple_alloc(len + varint32_sizeof(len));
- tuple->field_count = 1;
- pack_lstr(tuple->data, str, len);
- break;
- }
- case LUA_TNIL:
- case LUA_TBOOLEAN:
+ switch (type) {
+ case LUA_TTABLE:
{
- const char *str = tarantool_lua_tostring(L, index);
- size_t len = strlen(str);
- tuple = tuple_alloc(len + varint32_sizeof(len));
- tuple->field_count = 1;
- pack_lstr(tuple->data, str, len);
- break;
+ return lua_table_to_tuple(L, index);
}
case LUA_TUSERDATA:
{
tuple = lua_istuple(L, index);
if (tuple)
- break;
+ return tuple;
}
default:
/*
@@ -1183,24 +1081,17 @@ lua_totuple(struct lua_State *L, int index)
tnt_raise(ClientError, ER_PROC_RET, lua_typename(L, type));
break;
}
- return tuple;
}
static void
port_add_lua_ret(struct port *port, struct lua_State *L, int index)
{
struct tuple *tuple = lua_totuple(L, index);
- try {
- port_add_tuple(port, tuple, BOX_RETURN_TUPLE);
-
- if (tuple->refs == 0)
- tuple_free(tuple);
- } catch (...) {
+ auto scoped_guard = make_scoped_guard([=] {
if (tuple->refs == 0)
tuple_free(tuple);
-
- throw;
- }
+ });
+ port_add_tuple(port, tuple, BOX_RETURN_TUPLE);
}
/**
@@ -1269,7 +1160,7 @@ port_add_lua_multret(struct port *port, struct lua_State *L)
static int
lbox_process(lua_State *L)
{
- u32 op = lua_tointeger(L, 1); /* Get the first arg. */
+ uint32_t op = lua_tointeger(L, 1); /* Get the first arg. */
size_t sz;
const char *req = luaL_checklstring(L, 2, &sz); /* Second arg. */
if (op == CALL) {
@@ -1390,12 +1281,12 @@ box_lua_execute(struct request *request, struct port *port)
luaL_unref(root_L, LUA_REGISTRYINDEX, coro_ref);
});
- u32 field_len;
+ uint32_t field_len;
/* proc name */
const char *field = pick_field_str(reqpos, reqend, &field_len);
box_lua_find(L, field, field + field_len);
/* Push the rest of args (a tuple). */
- u32 nargs = pick_u32(reqpos, reqend);
+ uint32_t nargs = pick_u32(reqpos, reqend);
luaL_checkstack(L, nargs, "call: out of stack");
for (int i = 0; i < nargs; i++) {
field = pick_field_str(reqpos, reqend, &field_len);
@@ -1496,36 +1387,21 @@ luaL_packsize(struct lua_State *L, int index)
static void
luaL_packvalue(struct lua_State *L, luaL_Buffer *b, int index)
{
- size_t size;
- const char *str;
- u32 u32buf;
- u64 u64buf;
+ struct lua_field field;
+ lua_tofield(L, index, &field);
+ if (field.type != UNKNOWN) {
+ luaL_addvarint32(b, field.len);
+ luaL_addlstring(b, field.data, field.len);
+ return;
+ }
+
switch (lua_type(L, index)) {
- case LUA_TNUMBER:
- u64buf = lua_tonumber(L, index);
- if (u64buf > UINT32_MAX) {
- str = (char *) &u64buf;
- size = sizeof(u64);
- } else {
- u32buf = (u32) u64buf;
- str = (char *) &u32buf;
- size = sizeof(u32);
- }
- break;
- case LUA_TCDATA:
- u64buf = tarantool_lua_tointeger64(L, index);
- str = (char *) &u64buf;
- size = sizeof(u64);
- break;
- case LUA_TSTRING:
- str = luaL_checklstring(L, index, &size);
- break;
case LUA_TUSERDATA:
{
- struct tuple *tu = lua_istuple(L, index);
- if (tu == NULL)
+ struct tuple *tuple = lua_istuple(L, index);
+ if (tuple == NULL)
luaL_error(L, "box.pack: unsupported type");
- luaL_addlstring(b, (char*)tu->data, tu->bsize);
+ tuple_to_luabuf(tuple, b);
return;
}
case LUA_TTABLE:
@@ -1542,8 +1418,6 @@ luaL_packvalue(struct lua_State *L, luaL_Buffer *b, int index)
luaL_error(L, "box.pack: unsupported type");
return;
}
- luaL_addvarint32(b, size);
- luaL_addlstring(b, str, size);
}
static void
@@ -1592,53 +1466,57 @@ lbox_pack(struct lua_State *L)
/* first arg comes second */
int i = 2;
int nargs = lua_gettop(L);
- u16 u16buf;
- u32 u32buf;
- u64 u64buf;
size_t size;
const char *str;
luaL_buffinit(L, &b);
+ struct lua_field field;
while (*format) {
if (i > nargs)
luaL_error(L, "box.pack: argument count does not match "
"the format");
+ lua_tofield(L, i, &field);
switch (*format) {
case 'B':
case 'b':
/* signed and unsigned 8-bit integers */
- u32buf = lua_tointeger(L, i);
- if (u32buf > 0xff)
- luaL_error(L, "box.pack: argument too big for "
- "8-bit integer");
- luaL_addchar(&b, (char) u32buf);
+ if (field.type != NUM || field.u32 > UINT8_MAX)
+ luaL_error(L, "box.pack: expected 8-bit int");
+ luaL_addchar(&b, field.u32);
break;
case 'S':
case 's':
- /* signed and unsigned 8-bit integers */
- u32buf = lua_tointeger(L, i);
- if (u32buf > 0xffff)
- luaL_error(L, "box.pack: argument too big for "
- "16-bit integer");
- u16buf = (u16) u32buf;
- luaL_addlstring(&b, (char *) &u16buf, sizeof(u16));
+ /* signed and unsigned 16-bit integers */
+ if (field.type != NUM || field.u32 > UINT16_MAX)
+ luaL_error(L, "box.pack: expected 16-bit int");
+ luaL_addlstring(&b, field.data, sizeof(uint16_t));
break;
case 'I':
case 'i':
/* signed and unsigned 32-bit integers */
- u32buf = lua_tointeger(L, i);
- luaL_addlstring(&b, (char *) &u32buf, sizeof(u32));
+ if (field.type != NUM)
+ luaL_error(L, "box.pack: expected 32-bit int");
+ luaL_addlstring(&b, field.data, sizeof(uint32_t));
break;
case 'L':
case 'l':
/* signed and unsigned 64-bit integers */
- u64buf = tarantool_lua_tointeger64(L, i);
- luaL_addlstring(&b, (char *) &u64buf, sizeof(u64));
+ if (field.type == NUM64) {
+ luaL_addlstring(&b, field.data, field.len);
+ } else if (field.type == NUM) {
+ /* extend 32-bit value to 64-bit */
+ uint64_t val = field.u32;
+ luaL_addlstring(&b, (char *)&val, sizeof(val));
+ } else {
+ luaL_error(L, "box.pack: expected 64-bit int");
+ }
break;
case 'w':
/* Perl 'pack' BER-encoded integer */
- luaL_addvarint32(&b, lua_tointeger(L, i));
+ if (field.type != NUM)
+ luaL_error(L, "box.pack: expected 32-bit int");
+ luaL_addvarint32(&b, field.u32);
break;
case 'A':
case 'a':
@@ -1677,12 +1555,14 @@ lbox_pack(struct lua_State *L)
case '#':
/* delete field */
case '!':
+ {
/* insert field */
/* field no */
- u32buf = (u32) lua_tointeger(L, i);
- luaL_addlstring(&b, (char *) &u32buf, sizeof(u32));
+ uint32_t u32buf = (uint32_t) lua_tointeger(L, i);
+ luaL_addlstring(&b, (char *) &u32buf, sizeof(uint32_t));
luaL_addchar(&b, format_to_opcode(*format));
break;
+ }
default:
luaL_error(L, "box.pack: unsupported pack "
"format specifier '%c'", *format);
@@ -1697,11 +1577,11 @@ lbox_pack(struct lua_State *L)
const char *
box_unpack_response(struct lua_State *L, const char *s, const char *end)
{
- u32 tuple_count = pick_u32(&s, end);
+ uint32_t tuple_count = pick_u32(&s, end);
/* Unpack and push tuples. */
while (tuple_count--) {
- u32 bsize = pick_u32(&s, end);
+ uint32_t bsize = pick_u32(&s, end);
uint32_t field_count = pick_u32(&s, end);
const char *tend = s + bsize;
if (tend > end)
@@ -1729,9 +1609,9 @@ lbox_unpack(struct lua_State *L)
int save_stacksize = lua_gettop(L);
char charbuf;
- u8 u8buf;
- u16 u16buf;
- u32 u32buf;
+ uint8_t u8buf;
+ uint16_t u16buf;
+ uint32_t u32buf;
#define CHECK_SIZE(cur) if (unlikely((cur) >= end)) { \
luaL_error(L, "box.unpack('%c'): got %d bytes (expected: %d+)", \
@@ -1741,19 +1621,19 @@ lbox_unpack(struct lua_State *L)
switch (*f) {
case 'b':
CHECK_SIZE(s);
- u8buf = *(u8 *) s;
+ u8buf = *(uint8_t *) s;
lua_pushnumber(L, u8buf);
s++;
break;
case 's':
CHECK_SIZE(s + 1);
- u16buf = *(u16 *) s;
+ u16buf = *(uint16_t *) s;
lua_pushnumber(L, u16buf);
s += 2;
break;
case 'i':
CHECK_SIZE(s + 3);
- u32buf = *(u32 *) s;
+ u32buf = *(uint32_t *) s;
lua_pushnumber(L, u32buf);
s += 4;
break;
@@ -1802,7 +1682,7 @@ lbox_unpack(struct lua_State *L)
CHECK_SIZE(s + 4);
/* field no */
- u32buf = *(u32 *) s;
+ u32buf = *(uint32_t *) s;
/* opcode */
charbuf = *(s + 4);
@@ -1860,6 +1740,8 @@ mod_lua_init(struct lua_State *L)
tarantool_lua_register_type(L, tuplelib_name, lbox_tuple_meta);
luaL_register(L, tuplelib_name, lbox_tuplelib);
lua_pop(L, 1);
+ tarantool_lua_register_type(L, tuple_iteratorlib_name,
+ lbox_tuple_iterator_meta);
luaL_register(L, "box", boxlib);
lua_pop(L, 1);
/* box.index */
diff --git a/src/box/box_lua_space.cc b/src/box/box_lua_space.cc
index e70722f8565cb4d4054f47de42ba0b967e185525..6fff336d785478c95a5de32f228cd0983bbb2b66 100644
--- a/src/box/box_lua_space.cc
+++ b/src/box/box_lua_space.cc
@@ -92,7 +92,7 @@ lbox_pushspace(struct lua_State *L, struct space *space)
lua_pushstring(L, "key_field");
lua_newtable(L);
- for (u32 j = 0; j < space->key_defs[i].part_count; j++) {
+ for (uint32_t j = 0; j < space->key_defs[i].part_count; j++) {
lua_pushnumber(L, j);
lua_newtable(L);
diff --git a/src/box/hash_index.cc b/src/box/hash_index.cc
index fd5161cd3fc7976c51c1c53314eeb0b2da81e140..8b800cbb8a20376827ba81b3492f804b43f04c3e 100644
--- a/src/box/hash_index.cc
+++ b/src/box/hash_index.cc
@@ -32,75 +32,125 @@
#include "pickle.h"
#include "exception.h"
#include "space.h"
-#include "assoc.h"
#include "errinj.h"
-/* {{{ HashIndex Iterators ****************************************/
-
-struct hash_i32_iterator {
- struct iterator base; /* Must be the first member. */
- struct mh_i32ptr_t *hash;
- mh_int_t h_pos;
-};
-
-struct hash_i64_iterator {
- struct iterator base;
- struct mh_i64ptr_t *hash;
- mh_int_t h_pos;
-};
+#include "third_party/PMurHash.h"
-struct hash_lstr_iterator {
- struct iterator base;
- struct mh_lstrptr_t *hash;
- mh_int_t h_pos;
+enum {
+ HASH_SEED = 13U
};
-void
-hash_iterator_free(struct iterator *iterator)
+static inline bool
+mh_index_eq(struct tuple *const *tuple_a, struct tuple *const *tuple_b,
+ const struct key_def *key_def)
{
- assert(iterator->free == hash_iterator_free);
- free(iterator);
+ return tuple_compare(*tuple_a, *tuple_b, key_def) == 0;
}
-struct tuple *
-hash_iterator_i32_ge(struct iterator *ptr)
+static inline bool
+mh_index_eq_key(const char *key, struct tuple *const *tuple,
+ const struct key_def *key_def)
{
- assert(ptr->free == hash_iterator_free);
- struct hash_i32_iterator *it = (struct hash_i32_iterator *) ptr;
+ return tuple_compare_with_key(*tuple, key, key_def->part_count,
+ key_def) == 0;
+}
- while (it->h_pos < mh_end(it->hash)) {
- if (mh_exist(it->hash, it->h_pos))
- return (struct tuple *) mh_i32ptr_node(it->hash, it->h_pos++)->val;
- it->h_pos++;
+
+static inline uint32_t
+mh_index_hash(struct tuple *const *tuple, const struct key_def *key_def)
+{
+ struct key_part *part = key_def->parts;
+ uint32_t size;
+ /*
+ * Speed up the simplest case when we have a
+ * single-part hash over an integer field.
+ */
+ if (key_def->part_count == 1 && part->type == NUM)
+ return *(uint32_t *) tuple_field(*tuple, part->fieldno, &size);
+
+ uint32_t h = HASH_SEED;
+ uint32_t carry = 0;
+ uint32_t total_size = 0;
+
+ for ( ; part < key_def->parts + key_def->part_count; part++) {
+ const char *field = tuple_field(*tuple, part->fieldno, &size);
+ assert(size < INT32_MAX);
+ PMurHash32_Process(&h, &carry, field, size);
+ total_size += size;
}
- return NULL;
+
+ return PMurHash32_Result(h, carry, total_size);
}
-struct tuple *
-hash_iterator_i64_ge(struct iterator *ptr)
+static inline uint32_t
+mh_index_hash_key(const char *key, const struct key_def *key_def)
{
- assert(ptr->free == hash_iterator_free);
- struct hash_i64_iterator *it = (struct hash_i64_iterator *) ptr;
+ struct key_part *part = key_def->parts;
- while (it->h_pos < mh_end(it->hash)) {
- if (mh_exist(it->hash, it->h_pos))
- return (struct tuple *) mh_i64ptr_node(
- it->hash,it->h_pos++)->val;
- it->h_pos++;
+ if (key_def->part_count == 1 && part->type == NUM) {
+ (void) load_varint32(&key);
+ return *(uint32_t *) key;
}
- return NULL;
+ uint32_t h = HASH_SEED;
+ uint32_t carry = 0;
+ uint32_t total_size = 0;
+
+ for ( ; part < key_def->parts + key_def->part_count; part++) {
+ uint32_t size = load_varint32(&key);
+ if (part->type == NUM64 && size == sizeof(uint32_t)) {
+ /* Allow search in NUM64 indexes using NUM keys. */
+ uint64_t u64 = *(uint32_t *) key;
+ PMurHash32_Process(&h, &carry, &u64, sizeof(uint64_t));
+ total_size += sizeof(uint64_t);
+ } else {
+ assert(size < INT32_MAX);
+ PMurHash32_Process(&h, &carry, key, size);
+ total_size += size;
+ }
+ key += size;
+ }
+
+ return PMurHash32_Result(h, carry, total_size);
+}
+
+#define mh_int_t uint32_t
+#define mh_arg_t const struct key_def *
+
+#define mh_hash(a, arg) mh_index_hash(a, arg)
+#define mh_hash_key(a, arg) mh_index_hash_key(a, arg)
+#define mh_eq(a, b, arg) mh_index_eq(a, b, arg)
+#define mh_eq_key(a, b, arg) mh_index_eq_key(a, b, arg)
+
+#define mh_key_t const char *
+typedef struct tuple * mh_node_t;
+#define mh_name _index
+#define MH_SOURCE 1
+#include <mhash.h>
+
+/* {{{ HashIndex Iterators ****************************************/
+
+struct hash_iterator {
+ struct iterator base; /* Must be the first member. */
+ struct mh_index_t *hash;
+ uint32_t h_pos;
+};
+
+void
+hash_iterator_free(struct iterator *iterator)
+{
+ assert(iterator->free == hash_iterator_free);
+ free(iterator);
}
struct tuple *
-hash_iterator_lstr_ge(struct iterator *ptr)
+hash_iterator_ge(struct iterator *ptr)
{
assert(ptr->free == hash_iterator_free);
- struct hash_lstr_iterator *it = (struct hash_lstr_iterator *) ptr;
+ struct hash_iterator *it = (struct hash_iterator *) ptr;
while (it->h_pos < mh_end(it->hash)) {
if (mh_exist(it->hash, it->h_pos))
- return (struct tuple *) mh_lstrptr_node(
- it->hash,it->h_pos++)->val;
+ return *mh_index_node(it->hash, it->h_pos++);
it->h_pos++;
}
return NULL;
@@ -113,147 +163,29 @@ hash_iterator_eq_next(struct iterator *it __attribute__((unused)))
}
static struct tuple *
-hash_iterator_i32_eq(struct iterator *it)
-{
- it->next = hash_iterator_eq_next;
- return hash_iterator_i32_ge(it);
-}
-
-static struct tuple *
-hash_iterator_i64_eq(struct iterator *it)
-{
- it->next = hash_iterator_eq_next;
- return hash_iterator_i64_ge(it);
-}
-
-static struct tuple *
-hash_iterator_lstr_eq(struct iterator *it)
+hash_iterator_eq(struct iterator *it)
{
it->next = hash_iterator_eq_next;
- return hash_iterator_lstr_ge(it);
+ return hash_iterator_ge(it);
}
/* }}} */
/* {{{ HashIndex -- base class for all hashes. ********************/
-class Hash32Index: public HashIndex {
-public:
- Hash32Index(struct key_def *key_def, struct space *space);
- ~Hash32Index();
-
- virtual size_t
- size() const;
-
- virtual struct tuple *
- random(u32 rnd) const;
-
- virtual struct tuple *
- findByKey(const char *key, u32 part_count) const;
-
- virtual struct tuple *
- replace(struct tuple *old_tuple, struct tuple *new_tuple,
- enum dup_replace_mode mode);
-
- struct iterator *
- allocIterator() const;
-
- void
- initIterator(struct iterator *iterator, enum iterator_type type,
- const char *key, u32 part_count) const;
-
- virtual void
- reserve(u32 n_tuples);
-private:
- struct mh_i32ptr_t *int_hash;
-};
-
-class Hash64Index: public HashIndex {
-public:
- Hash64Index(struct key_def *key_def, struct space *space);
- ~Hash64Index();
-
- virtual size_t
- size() const;
-
- virtual struct tuple *
- random(u32 rnd) const;
-
- virtual struct tuple *
- findByKey(const char *key, u32 part_count) const;
-
- virtual struct tuple *
- replace(struct tuple *old_tuple, struct tuple *new_tuple,
- enum dup_replace_mode mode);
-
- struct iterator *
- allocIterator() const;
-
- void
- initIterator(struct iterator *iterator, enum iterator_type type,
- const char *key, u32 part_count) const;
-
- virtual void
- reserve(u32 n_tuples);
-private:
- struct mh_i64ptr_t *int64_hash;
-};
-
-class HashStrIndex: public HashIndex {
-public:
- HashStrIndex(struct key_def *key_def, struct space *space);
- ~HashStrIndex();
-
- virtual size_t
- size() const;
-
- virtual struct tuple *
- random(u32 rnd) const;
-
- virtual struct tuple *
- findByKey(const char *key, u32 part_count) const;
-
- virtual struct tuple *
- replace(struct tuple *old_tuple, struct tuple *new_tuple,
- enum dup_replace_mode mode);
-
- struct iterator *
- allocIterator() const;
-
- void
- initIterator(struct iterator *iterator, enum iterator_type type,
- const char *key, u32 part_count) const;
-
- virtual void
- reserve(u32 n_tuples);
-private:
- struct mh_lstrptr_t *str_hash;
-};
-
-HashIndex *
-HashIndex::factory(struct key_def *key_def, struct space *space)
+HashIndex::HashIndex(struct key_def *key_def, struct space *space)
+ : Index(key_def, space)
{
- /*
- * Hash index always has a single-field key.
- */
- switch (key_def->parts[0].type) {
- case NUM:
- return new Hash32Index(key_def, space); /* 32-bit integer hash */
- case NUM64:
- return new Hash64Index(key_def, space); /* 64-bit integer hash */
- case STRING:
- return new HashStrIndex(key_def, space); /* string hash */
- default:
- assert(false);
+ hash = mh_index_new();
+ if (hash == NULL) {
+ tnt_raise(ClientError, ER_MEMORY_ISSUE, sizeof(hash),
+ "HashIndex", "hash");
}
-
- return NULL;
}
-HashIndex::HashIndex(struct key_def *key_def, struct space *space)
- : Index(key_def, space)
+HashIndex::~HashIndex()
{
- /* Nothing */
+ mh_index_delete(hash);
}
void
@@ -275,7 +207,7 @@ HashIndex::endBuild()
void
HashIndex::build(Index *pk)
{
- u32 n_tuples = pk->size();
+ uint32_t n_tuples = pk->size();
if (n_tuples == 0)
return;
@@ -293,309 +225,84 @@ HashIndex::build(Index *pk)
replace(NULL, tuple, DUP_INSERT);
}
-struct tuple *
-HashIndex::min() const
-{
- tnt_raise(ClientError, ER_UNSUPPORTED, "Hash index", "min()");
- return NULL;
-}
-
-struct tuple *
-HashIndex::max() const
-{
- tnt_raise(ClientError, ER_UNSUPPORTED, "Hash index", "max()");
- return NULL;
-}
-
-struct tuple *
-HashIndex::findByTuple(struct tuple *tuple) const
-{
- assert(key_def->is_unique);
- if (tuple->field_count < key_def->max_fieldno)
- tnt_raise(IllegalParams, "tuple must have all indexed fields");
-
- /* Hash index currently is always single-part. */
- const char *field = tuple_field_old(tuple, key_def->parts[0].fieldno);
- return findByKey(field, 1);
-}
-
-/* }}} */
-
-/* {{{ Hash32Index ************************************************/
-
-static inline struct mh_i32ptr_node_t
-int32_key_to_node(const char *key)
-{
- u32 key_size = load_varint32(&key);
- if (key_size != 4)
- tnt_raise(ClientError, ER_KEY_FIELD_TYPE, "u32");
- struct mh_i32ptr_node_t node = { *(u32 *) key, NULL };
- return node;
-}
-
-static inline struct mh_i32ptr_node_t
-int32_tuple_to_node(struct tuple *tuple, struct key_def *key_def)
-{
- const char *field = tuple_field_old(tuple, key_def->parts[0].fieldno);
- struct mh_i32ptr_node_t node = int32_key_to_node(field);
- node.val = tuple;
- return node;
-}
-
-
-Hash32Index::Hash32Index(struct key_def *key_def, struct space *space)
- : HashIndex(key_def, space)
-{
- int_hash = mh_i32ptr_new();
-}
-
-Hash32Index::~Hash32Index()
-{
- mh_i32ptr_delete(int_hash);
-}
-
void
-Hash32Index::reserve(u32 n_tuples)
+HashIndex::reserve(uint32_t n_tuples)
{
- mh_i32ptr_reserve(int_hash, n_tuples, NULL);
+ mh_index_reserve(hash, n_tuples, key_def);
}
size_t
-Hash32Index::size() const
+HashIndex::size() const
{
- return mh_size(int_hash);
+ return mh_size(hash);
}
struct tuple *
-Hash32Index::random(u32 rnd) const
+HashIndex::min() const
{
- mh_int_t k = mh_i32ptr_random(int_hash, rnd);
- if (k != mh_end(int_hash))
- return (struct tuple *) mh_i32ptr_node(int_hash, k)->val;
+ tnt_raise(ClientError, ER_UNSUPPORTED, "Hash index", "min()");
return NULL;
}
struct tuple *
-Hash32Index::findByKey(const char *key, u32 part_count) const
-{
- assert(key_def->is_unique && part_count == key_def->part_count);
- struct tuple *ret = NULL;
- struct mh_i32ptr_node_t node = int32_key_to_node(key);
- mh_int_t k = mh_i32ptr_get(int_hash, &node, NULL);
- if (k != mh_end(int_hash))
- ret = (struct tuple *) mh_i32ptr_node(int_hash, k)->val;
-#ifdef DEBUG
- say_debug("Hash32Index find(self:%p, key:%i) = %p", self, node.key, ret);
-#endif
- return ret;
-}
-
-struct tuple *
-Hash32Index::replace(struct tuple *old_tuple, struct tuple *new_tuple,
- enum dup_replace_mode mode)
-{
- struct mh_i32ptr_node_t new_node, old_node;
- uint32_t errcode;
-
- if (new_tuple) {
- struct mh_i32ptr_node_t *dup_node = &old_node;
- new_node = int32_tuple_to_node(new_tuple, key_def);
- mh_int_t pos = mh_i32ptr_put(int_hash, &new_node,
- &dup_node, NULL);
-
- ERROR_INJECT(ERRINJ_INDEX_ALLOC,
- {
- mh_i32ptr_del(int_hash, pos, NULL);
- pos = mh_end(int_hash);
- });
-
- if (pos == mh_end(int_hash)) {
- tnt_raise(LoggedError, ER_MEMORY_ISSUE, (ssize_t) pos,
- "int hash", "key");
- }
- struct tuple *dup_tuple = (dup_node ?
- (struct tuple *) dup_node->val
- : NULL);
- errcode = replace_check_dup(old_tuple, dup_tuple, mode);
-
- if (errcode) {
- mh_i32ptr_remove(int_hash, &new_node, NULL);
- if (dup_node) {
- pos = mh_i32ptr_put(int_hash, dup_node,
- NULL, NULL);
- if (pos == mh_end(int_hash)) {
- panic("Failed to allocate memory in "
- "recover of int hash");
- }
- }
- tnt_raise(ClientError, errcode, index_n(this));
- }
- if (dup_tuple)
- return dup_tuple;
- }
- if (old_tuple) {
- old_node = int32_tuple_to_node(old_tuple, key_def);
- mh_i32ptr_remove(int_hash, &old_node, NULL);
- }
- return old_tuple;
-}
-
-
-struct iterator *
-Hash32Index::allocIterator() const
-{
- struct hash_i32_iterator *it = (struct hash_i32_iterator *)
- malloc(sizeof(struct hash_i32_iterator));
- if (it) {
- memset(it, 0, sizeof(*it));
- it->base.next = hash_iterator_i32_ge;
- it->base.free = hash_iterator_free;
- }
- return (struct iterator *) it;
-}
-
-void
-Hash32Index::initIterator(struct iterator *ptr, enum iterator_type type,
- const char *key, u32 part_count) const
-{
- assert ((part_count == 1 && key != NULL) || part_count == 0);
- (void) part_count;
- assert(ptr->free == hash_iterator_free);
-
- struct hash_i32_iterator *it = (struct hash_i32_iterator *) ptr;
- struct mh_i32ptr_node_t node;
-
- switch (type) {
- case ITER_GE:
- if (key != NULL) {
- node = int32_key_to_node(key);
- it->h_pos = mh_i32ptr_get(int_hash, &node, NULL);
- it->base.next = hash_iterator_i32_ge;
- break;
- }
- /* Fall through. */
- case ITER_ALL:
- it->h_pos = mh_begin(int_hash);
- it->base.next = hash_iterator_i32_ge;
- break;
- case ITER_EQ:
- node = int32_key_to_node(key);
- it->h_pos = mh_i32ptr_get(int_hash, &node, NULL);
- it->base.next = hash_iterator_i32_eq;
- break;
- default:
- tnt_raise(ClientError, ER_UNSUPPORTED,
- "Hash index", "requested iterator type");
- }
- it->hash = int_hash;
-}
-
-/* }}} */
-
-/* {{{ Hash64Index ************************************************/
-
-static inline struct mh_i64ptr_node_t
-int64_key_to_node(const char *key)
-{
- u32 key_size = load_varint32(&key);
- if (key_size != 8)
- tnt_raise(ClientError, ER_KEY_FIELD_TYPE, "u64");
- struct mh_i64ptr_node_t node = { *(u64 *) key, NULL };
- return node;
-}
-
-static inline struct mh_i64ptr_node_t
-int64_tuple_to_node(struct tuple *tuple, struct key_def *key_def)
-{
- const char *field = tuple_field_old(tuple, key_def->parts[0].fieldno);
- struct mh_i64ptr_node_t node = int64_key_to_node(field);
- node.val = tuple;
- return node;
-}
-
-Hash64Index::Hash64Index(struct key_def *key_def, struct space *space)
- : HashIndex(key_def, space)
-{
- int64_hash = mh_i64ptr_new();
-}
-
-Hash64Index::~Hash64Index()
-{
- mh_i64ptr_delete(int64_hash);
-}
-
-void
-Hash64Index::reserve(u32 n_tuples)
-{
- mh_i64ptr_reserve(int64_hash, n_tuples, NULL);
-}
-
-size_t
-Hash64Index::size() const
+HashIndex::max() const
{
- return mh_size(int64_hash);
+ tnt_raise(ClientError, ER_UNSUPPORTED, "Hash index", "max()");
+ return NULL;
}
struct tuple *
-Hash64Index::random(u32 rnd) const
+HashIndex::random(uint32_t rnd) const
{
- mh_int_t k = mh_i64ptr_random(int64_hash, rnd);
- if (k != mh_end(int64_hash))
- return (struct tuple *) mh_i64ptr_node(int64_hash, k)->val;
+ uint32_t k = mh_index_random(hash, rnd);
+ if (k != mh_end(hash))
+ return *mh_index_node(hash, k);
return NULL;
}
struct tuple *
-Hash64Index::findByKey(const char *key, u32 part_count) const
+HashIndex::findByKey(const char *key, uint32_t part_count) const
{
assert(key_def->is_unique && part_count == key_def->part_count);
- (void) part_count;
struct tuple *ret = NULL;
- struct mh_i64ptr_node_t node = int64_key_to_node(key);
- mh_int_t k = mh_i64ptr_get(int64_hash, &node, NULL);
- if (k != mh_end(int64_hash))
- ret = (struct tuple *) mh_i64ptr_node(int64_hash, k)->val;
-#ifdef DEBUG
- say_debug("Hash64Index find(self:%p, key:%i) = %p", self, node.key, ret);
-#endif
+ uint32_t k = mh_index_find(hash, key, key_def);
+ if (k != mh_end(hash))
+ ret = *mh_index_node(hash, k);
return ret;
}
struct tuple *
-Hash64Index::replace(struct tuple *old_tuple, struct tuple *new_tuple,
- enum dup_replace_mode mode)
+HashIndex::replace(struct tuple *old_tuple, struct tuple *new_tuple,
+ enum dup_replace_mode mode)
{
- struct mh_i64ptr_node_t new_node, old_node;
uint32_t errcode;
if (new_tuple) {
- struct mh_i64ptr_node_t *dup_node = &old_node;
- new_node = int64_tuple_to_node(new_tuple, key_def);
- mh_int_t pos = mh_i64ptr_put(int64_hash, &new_node,
- &dup_node, NULL);
+ struct tuple *dup_tuple = NULL;
+ struct tuple **dup_node = &dup_tuple;
+ uint32_t pos = mh_index_put(hash, &new_tuple,
+ &dup_node, key_def);
ERROR_INJECT(ERRINJ_INDEX_ALLOC,
{
- mh_i64ptr_del(int64_hash, pos, NULL);
- pos = mh_end(int64_hash);
+ mh_index_del(hash, pos, key_def);
+ pos = mh_end(hash);
});
- if (pos == mh_end(int64_hash)) {
+ if (pos == mh_end(hash)) {
tnt_raise(LoggedError, ER_MEMORY_ISSUE, (ssize_t) pos,
- "int hash", "key");
+ "hash", "key");
}
- struct tuple *dup_tuple = (dup_node ?
- (struct tuple *) dup_node->val :
- NULL);
errcode = replace_check_dup(old_tuple, dup_tuple, mode);
if (errcode) {
- mh_i64ptr_remove(int64_hash, &new_node, NULL);
- if (dup_node) {
- pos = mh_i64ptr_put(int64_hash, dup_node, NULL, NULL);
- if (pos == mh_end(int64_hash)) {
+ mh_index_remove(hash, &new_tuple, key_def);
+ if (dup_tuple) {
+ pos = mh_index_put(hash, &dup_tuple, NULL,
+ key_def);
+ if (pos == mh_end(hash)) {
panic("Failed to allocate memory in "
"recover of int hash");
}
@@ -608,229 +315,57 @@ Hash64Index::replace(struct tuple *old_tuple, struct tuple *new_tuple,
}
if (old_tuple) {
- old_node = int64_tuple_to_node(old_tuple, key_def);
- mh_i64ptr_remove(int64_hash, &old_node, NULL);
+ mh_index_remove(hash, &old_tuple, key_def);
}
-
return old_tuple;
}
-
struct iterator *
-Hash64Index::allocIterator() const
-{
- struct hash_i64_iterator *it = (struct hash_i64_iterator *)
- malloc(sizeof(struct hash_i64_iterator));
- if (it) {
- memset(it, 0, sizeof(*it));
- it->base.next = hash_iterator_i64_ge;
- it->base.free = hash_iterator_free;
+HashIndex::allocIterator() const
+{
+ struct hash_iterator *it = (struct hash_iterator *)
+ calloc(1, sizeof(*it));
+ if (it == NULL) {
+ tnt_raise(ClientError, ER_MEMORY_ISSUE,
+ sizeof(struct hash_iterator),
+ "HashIndex", "iterator");
}
+ it->base.next = hash_iterator_ge;
+ it->base.free = hash_iterator_free;
return (struct iterator *) it;
}
void
-Hash64Index::initIterator(struct iterator *ptr, enum iterator_type type,
- const char *key, u32 part_count) const
+HashIndex::initIterator(struct iterator *ptr, enum iterator_type type,
+ const char *key, uint32_t part_count) const
{
- assert ((part_count == 1 && key != NULL) || part_count == 0);
+ assert (key != NULL || part_count == 0);
(void) part_count;
assert(ptr->free == hash_iterator_free);
- struct hash_i64_iterator *it = (struct hash_i64_iterator *) ptr;
- struct mh_i64ptr_node_t node;
-
- switch (type) {
- case ITER_GE:
- if (key != NULL) {
- node = int64_key_to_node(key);
- it->h_pos = mh_i64ptr_get(int64_hash, &node, NULL);
- it->base.next = hash_iterator_i64_ge;
- break;
- }
- /* Fall through. */
- case ITER_ALL:
- it->h_pos = mh_begin(int64_hash);
- it->base.next = hash_iterator_i64_ge;
- break;
- case ITER_EQ:
- node = int64_key_to_node(key);
- it->h_pos = mh_i64ptr_get(int64_hash, &node, NULL);
- it->base.next = hash_iterator_i64_eq;
- break;
- default:
- tnt_raise(ClientError, ER_UNSUPPORTED,
- "Hash index", "requested iterator type");
- }
- it->hash = int64_hash;
-}
-
-/* }}} */
-
-/* {{{ HashStrIndex ***********************************************/
-
-static inline struct mh_lstrptr_node_t
-lstrptr_tuple_to_node(struct tuple *tuple, struct key_def *key_def)
-{
- const char *field = tuple_field_old(tuple, key_def->parts[0].fieldno);
- if (field == NULL)
- tnt_raise(ClientError, ER_NO_SUCH_FIELD,
- key_def->parts[0].fieldno);
-
- struct mh_lstrptr_node_t node = { field, tuple };
- return node;
-}
-
-HashStrIndex::HashStrIndex(struct key_def *key_def, struct space *space)
- : HashIndex(key_def, space)
-{
- str_hash = mh_lstrptr_new();
-}
-
-HashStrIndex::~HashStrIndex()
-{
- mh_lstrptr_delete(str_hash);
-}
-
-void
-HashStrIndex::reserve(u32 n_tuples)
-{
- mh_lstrptr_reserve(str_hash, n_tuples, NULL);
-}
-
-
-size_t
-HashStrIndex::size() const
-{
- return mh_size(str_hash);
-}
-
-struct tuple *
-HashStrIndex::random(u32 rnd) const
-{
- mh_int_t k = mh_lstrptr_random(str_hash, rnd);
- if (k != mh_end(str_hash))
- return (struct tuple *) mh_lstrptr_node(str_hash, k)->val;
- return NULL;
-}
-
-struct tuple *
-HashStrIndex::findByKey(const char *key, u32 part_count) const
-{
- assert(key_def->is_unique && part_count == key_def->part_count);
- (void) part_count;
-
- struct tuple *ret = NULL;
- const struct mh_lstrptr_node_t node = { key, NULL };
- mh_int_t k = mh_lstrptr_get(str_hash, &node, NULL);
- if (k != mh_end(str_hash))
- ret = (struct tuple *) mh_lstrptr_node(str_hash, k)->val;
-#ifdef DEBUG
- u32 key_size = load_varint32(&key);
- say_debug("HashStrIndex find(self:%p, key:(%i)'%.*s') = %p",
- self, key_size, key_size, key, ret);
-#endif
- return ret;
-}
-
-struct tuple *
-HashStrIndex::replace(struct tuple *old_tuple, struct tuple *new_tuple,
- enum dup_replace_mode mode)
-{
- struct mh_lstrptr_node_t new_node, old_node;
- uint32_t errcode;
-
- if (new_tuple) {
- struct mh_lstrptr_node_t *dup_node = &old_node;
- new_node = lstrptr_tuple_to_node(new_tuple, key_def);
- mh_int_t pos = mh_lstrptr_put(str_hash, &new_node,
- &dup_node, NULL);
-
- ERROR_INJECT(ERRINJ_INDEX_ALLOC,
- {
- mh_lstrptr_del(str_hash, pos, NULL);
- pos = mh_end(str_hash);
- });
- if (pos == mh_end(str_hash)) {
- tnt_raise(LoggedError, ER_MEMORY_ISSUE, (ssize_t) pos,
- "str hash", "key");
- }
- struct tuple *dup_tuple = dup_node
- ? (struct tuple *) dup_node->val
- : NULL;
- errcode = replace_check_dup(old_tuple, dup_tuple, mode);
-
- if (errcode) {
- mh_lstrptr_remove(str_hash, &new_node, NULL);
- if (dup_node) {
- pos = mh_lstrptr_put(str_hash, dup_node,
- NULL, NULL);
- if (pos == mh_end(str_hash)) {
- panic("Failed to allocate memory in "
- "recover of str hash");
- }
- }
- tnt_raise(ClientError, errcode, index_n(this));
- }
- if (dup_tuple)
- return dup_tuple;
- }
- if (old_tuple) {
- old_node = lstrptr_tuple_to_node(old_tuple, key_def);
- mh_lstrptr_remove(str_hash, &old_node, NULL);
- }
- return old_tuple;
-}
-
-struct iterator *
-HashStrIndex::allocIterator() const
-{
- struct hash_lstr_iterator *it = (struct hash_lstr_iterator *)
- malloc(sizeof(struct hash_lstr_iterator));
- if (it) {
- memset(it, 0, sizeof(*it));
- it->base.next = hash_iterator_lstr_ge;
- it->base.free = hash_iterator_free;
- }
- return (struct iterator *) it;
-}
-
-void
-HashStrIndex::initIterator(struct iterator *ptr, enum iterator_type type,
- const char *key, u32 part_count) const
-{
- assert ((part_count == 1 && key != NULL) || part_count == 0);
- (void) part_count;
-
- assert(ptr->free == hash_iterator_free);
- struct hash_lstr_iterator *it = (struct hash_lstr_iterator *) ptr;
- struct mh_lstrptr_node_t node;
+ struct hash_iterator *it = (struct hash_iterator *) ptr;
switch (type) {
case ITER_GE:
if (key != NULL) {
- node.key = key;
- it->h_pos = mh_lstrptr_get(str_hash, &node, NULL);
- it->base.next = hash_iterator_lstr_ge;
+ it->h_pos = mh_index_find(hash, key, key_def);
+ it->base.next = hash_iterator_ge;
break;
}
/* Fall through. */
case ITER_ALL:
- it->base.next = hash_iterator_lstr_ge;
- it->h_pos = mh_begin(str_hash);
+ it->h_pos = mh_begin(hash);
+ it->base.next = hash_iterator_ge;
break;
case ITER_EQ:
- node.key = key;
- it->h_pos = mh_lstrptr_get(str_hash, &node, NULL);
- it->base.next = hash_iterator_lstr_eq;
+ it->h_pos = mh_index_find(hash, key, key_def);
+ it->base.next = hash_iterator_eq;
break;
default:
tnt_raise(ClientError, ER_UNSUPPORTED,
"Hash index", "requested iterator type");
}
- it->hash = str_hash;
+ it->hash = hash;
}
-
/* }}} */
-
diff --git a/src/box/hash_index.h b/src/box/hash_index.h
index e6ce4423b710e799dd40d88e7bbca70ca4f5e57b..3fdb7d54f78841ec7197009a46b920bf43e2fb71 100644
--- a/src/box/hash_index.h
+++ b/src/box/hash_index.h
@@ -31,34 +31,35 @@
#include "index.h"
+struct mh_index_t;
class HashIndex: public Index {
public:
- static HashIndex *
- factory(struct key_def *key_def, struct space *space);
-
HashIndex(struct key_def *key_def, struct space *space);
+ ~HashIndex();
virtual void beginBuild();
virtual void buildNext(struct tuple *tuple);
virtual void endBuild();
virtual void build(Index *pk);
- virtual size_t size() const = 0;
+ virtual size_t size() const;
virtual struct tuple *min() const;
virtual struct tuple *max() const;
- virtual struct tuple *random(u32 rnd) const = 0;
- virtual struct tuple *findByKey(const char *key, u32 part_count) const = 0;
- virtual struct tuple *findByTuple(struct tuple *tuple) const;
+ virtual struct tuple *random(uint32_t rnd) const;
+ virtual struct tuple *findByKey(const char *key, uint32_t part_count) const;
virtual struct tuple *replace(struct tuple *old_tuple,
struct tuple *new_tuple,
- enum dup_replace_mode mode) = 0;
+ enum dup_replace_mode mode);
- virtual struct iterator *allocIterator() const = 0;
+ virtual struct iterator *allocIterator() const;
virtual void initIterator(struct iterator *iterator,
enum iterator_type type,
- const char *key, u32 part_count) const = 0;
+ const char *key, uint32_t part_count) const;
+
+ virtual void reserve(uint32_t n_tuples);
- virtual void reserve(u32 n_tuples) = 0;
+protected:
+ struct mh_index_t *hash;
};
#endif /* TARANTOOL_BOX_HASH_INDEX_H_INCLUDED */
diff --git a/src/box/index.cc b/src/box/index.cc
index d4fae7e735920a75767dd3783bdbd2752c995530..9a7c212c5c6a254df8237dc12ce37e803ce5f976 100644
--- a/src/box/index.cc
+++ b/src/box/index.cc
@@ -143,9 +143,9 @@ Index::factory(enum index_type type, struct key_def *key_def, struct space *spac
{
switch (type) {
case HASH:
- return HashIndex::factory(key_def, space);
+ return new HashIndex(key_def, space);
case TREE:
- return TreeIndex::factory(key_def, space);
+ return new TreeIndex(key_def, space);
case BITSET:
return new BitsetIndex(key_def, space);
default:
@@ -168,4 +168,11 @@ Index::~Index()
m_position->free(m_position);
}
+struct tuple *
+Index::findByTuple(struct tuple *tuple) const
+{
+ (void) tuple;
+ tnt_raise(ClientError, ER_UNSUPPORTED, "Index", "findByTuple()");
+ return NULL;
+}
/* }}} */
diff --git a/src/box/index.h b/src/box/index.h
index c11df7bd25fb1ccf019d12d2bcd6b93f4e5faf1b..bc60a10399d5ff59f16b6aa29a7dd55b49539116 100644
--- a/src/box/index.h
+++ b/src/box/index.h
@@ -101,7 +101,7 @@ struct iterator {
/** Descriptor of a single part in a multipart key. */
struct key_part {
- u32 fieldno;
+ uint32_t fieldno;
enum field_data_type type;
};
@@ -118,14 +118,14 @@ struct key_def {
* max_fieldno is 5, and cmp_order array holds offsets of
* field 3 and 5 in 'parts' array: -1, -1, 0, -1, 1.
*/
- u32 *cmp_order;
+ uint32_t *cmp_order;
/* The size of the 'parts' array. */
- u32 part_count;
+ uint32_t part_count;
/*
* The size of 'cmp_order' array (= max fieldno in 'parts'
* array).
*/
- u32 max_fieldno;
+ uint32_t max_fieldno;
bool is_unique;
enum index_type type;
};
@@ -218,9 +218,9 @@ class Index: public Object {
virtual size_t size() const = 0;
virtual struct tuple *min() const = 0;
virtual struct tuple *max() const = 0;
- virtual struct tuple *random(u32 rnd) const = 0;
- virtual struct tuple *findByKey(const char *key, u32 part_count) const = 0;
- virtual struct tuple *findByTuple(struct tuple *tuple) const = 0;
+ virtual struct tuple *random(uint32_t rnd) const = 0;
+ virtual struct tuple *findByKey(const char *key, uint32_t part_count) const = 0;
+ virtual struct tuple *findByTuple(struct tuple *tuple) const;
virtual struct tuple *replace(struct tuple *old_tuple,
struct tuple *new_tuple,
enum dup_replace_mode mode) = 0;
@@ -231,7 +231,7 @@ class Index: public Object {
virtual struct iterator *allocIterator() const = 0;
virtual void initIterator(struct iterator *iterator,
enum iterator_type type,
- const char *key, u32 part_count) const = 0;
+ const char *key, uint32_t part_count) const = 0;
inline struct iterator *position()
{
diff --git a/src/box/lua/box.lua b/src/box/lua/box.lua
index bff256631437f6f31bf930754e359bdf31ac536a..ca90a1a69727e343b8604e6dc709263ea51312ff 100644
--- a/src/box/lua/box.lua
+++ b/src/box/lua/box.lua
@@ -8,7 +8,8 @@ box.flags = { BOX_RETURN_TUPLE = 0x01, BOX_ADD = 0x02, BOX_REPLACE = 0x04 }
--
--
function box.select_limit(space, index, offset, limit, ...)
- return box.net.self:select_limit(space, index, offset, limit, ...)
+ return box.net.self:select_limit(tonumber(space), tonumber(index),
+ tonumber(offset), tonumber(limit), ...)
end
@@ -16,7 +17,7 @@ end
--
--
function box.select(space, index, ...)
- return box.net.self:select(space, index, ...)
+ return box.net.self:select(tonumber(space), tonumber(index), ...)
end
--
@@ -25,7 +26,8 @@ end
-- starts from the key.
--
function box.select_range(sno, ino, limit, ...)
- return box.net.self:select_range(sno, ino, limit, ...)
+ return box.net.self:select_range(tonumber(sno), tonumber(ino),
+ tonumber(limit), ...)
end
--
@@ -34,7 +36,8 @@ end
-- starts from the key.
--
function box.select_reverse_range(sno, ino, limit, ...)
- return box.net.self:select_reverse_range(sno, ino, limit, ...)
+ return box.net.self:select_reverse_range(tonumber(sno), tonumber(ino),
+ tonumber(limit), ...)
end
--
@@ -42,22 +45,22 @@ end
-- index is always 0. It doesn't accept compound keys
--
function box.delete(space, ...)
- return box.net.self:delete(space, ...)
+ return box.net.self:delete(tonumber(space), ...)
end
-- insert or replace a tuple
function box.replace(space, ...)
- return box.net.self:replace(space, ...)
+ return box.net.self:replace(tonumber(space), ...)
end
-- insert a tuple (produces an error if the tuple already exists)
function box.insert(space, ...)
- return box.net.self:insert(space, ...)
+ return box.net.self:insert(tonumber(space), ...)
end
--
function box.update(space, key, format, ...)
- return box.net.self:update(space, key, format, ...)
+ return box.net.self:update(tonumber(space), key, format, ...)
end
diff --git a/src/box/port.cc b/src/box/port.cc
index 98a8c9654214710fc2d2b29e18579941c761988f..417e7160050d0d3573bbcb4210da6baf8e9c4b16 100644
--- a/src/box/port.cc
+++ b/src/box/port.cc
@@ -29,23 +29,23 @@
#include "port.h"
void
-port_null_eof(struct port *port __attribute__((unused)))
+null_port_eof(struct port *port __attribute__((unused)))
{
}
static void
-port_null_add_tuple(struct port *port __attribute__((unused)),
+null_port_add_tuple(struct port *port __attribute__((unused)),
struct tuple *tuple __attribute__((unused)),
- u32 flags __attribute__((unused)))
+ uint32_t flags __attribute__((unused)))
{
}
-static struct port_vtab port_null_vtab = {
- port_null_add_tuple,
- port_null_eof,
+static struct port_vtab null_port_vtab = {
+ null_port_add_tuple,
+ null_port_eof,
};
-struct port port_null = {
- /* .vtab = */ &port_null_vtab,
+struct port null_port = {
+ /* .vtab = */ &null_port_vtab,
};
diff --git a/src/box/port.h b/src/box/port.h
index ba6e7333dae72929b0a09024f7e0d7a40821723a..2a0baa373d2589f0f62519c778102fb455dad346 100644
--- a/src/box/port.h
+++ b/src/box/port.h
@@ -33,9 +33,29 @@
struct tuple;
struct port;
+/**
+ * A single port represents a destination of box_process output.
+ * One such destination can be a Lua stack, or the binary
+ * protocol.
+ * An instance of a port is usually short lived, as it is created
+ * for every server request. State of the instance is represented
+ * by the tuples added to it. E.g.:
+ *
+ * struct port_iproto *port = port_iproto_new(...)
+ * for (tuple in tuples)
+ * port_add_tuple(tuple);
+ * port_eof(port); // end of request
+ *
+ * Beginning with Tarantool 1.5, tuple can have different internal
+ * structure and port_add_tuple() requires a double
+ * dispatch: first, by the type of the port the tuple is being
+ * added to, second, by the type of the tuple format, since the
+ * format defines the internal structure of the tuple.
+ */
+
struct port_vtab
{
- void (*add_tuple)(struct port *port, struct tuple *tuple, u32 flags);
+ void (*add_tuple)(struct port *port, struct tuple *tuple, uint32_t flags);
/** Must be called in the end of execution of a single request. */
void (*eof)(struct port *port);
};
@@ -52,19 +72,19 @@ port_eof(struct port *port)
}
static inline void
-port_add_tuple(struct port *port, struct tuple *tuple, u32 flags)
+port_add_tuple(struct port *port, struct tuple *tuple, uint32_t flags)
{
(port->vtab->add_tuple)(port, tuple, flags);
}
/** Reused in port_lua */
void
-port_null_eof(struct port *port __attribute__((unused)));
+null_port_eof(struct port *port __attribute__((unused)));
/**
* This one does not have state currently, thus a single
* instance is sufficient.
*/
-extern struct port port_null;
+extern struct port null_port;
#endif /* INCLUDES_TARANTOOL_BOX_PORT_H */
diff --git a/src/box/request.cc b/src/box/request.cc
index 306732110741b91285dcc22a04ede3bc198f8ae1..4a476811f8e2bb1d3a821ab387ef6b3713cad969 100644
--- a/src/box/request.cc
+++ b/src/box/request.cc
@@ -41,12 +41,12 @@
STRS(requests, REQUESTS);
static const char *
-read_key(const char **reqpos, const char *reqend, u32 *key_part_count)
+read_key(const char **reqpos, const char *reqend, uint32_t *key_part_count)
{
*key_part_count = pick_u32(reqpos, reqend);
const char *key = *key_part_count ? *reqpos : NULL;
/* Advance remaining fields of a key */
- for (u32 i = 0; i < *key_part_count; i++)
+ for (uint32_t i = 0; i < *key_part_count; i++)
pick_field(reqpos, reqend);
return key;
}
@@ -54,7 +54,7 @@ read_key(const char **reqpos, const char *reqend, u32 *key_part_count)
static struct space *
read_space(const char **reqpos, const char *reqend)
{
- u32 space_no = pick_u32(reqpos, reqend);
+ uint32_t space_no = pick_u32(reqpos, reqend);
return space_find(space_no);
}
@@ -101,7 +101,7 @@ execute_update(struct request *request, struct txn *txn)
BOX_ALLOWED_REQUEST_FLAGS);
/* Parse UPDATE request. */
/** Search key and key part count. */
- u32 key_part_count;
+ uint32_t key_part_count;
const char *key = read_key(reqpos, reqend, &key_part_count);
Index *pk = space_index(sp, 0);
@@ -131,26 +131,26 @@ execute_select(struct request *request, struct port *port)
const char **reqpos = &request->data;
const char *reqend = request->data + request->len;
struct space *sp = read_space(reqpos, reqend);
- u32 index_no = pick_u32(reqpos, reqend);
+ uint32_t index_no = pick_u32(reqpos, reqend);
Index *index = index_find(sp, index_no);
- u32 offset = pick_u32(reqpos, reqend);
- u32 limit = pick_u32(reqpos, reqend);
- u32 count = pick_u32(reqpos, reqend);
+ uint32_t offset = pick_u32(reqpos, reqend);
+ uint32_t limit = pick_u32(reqpos, reqend);
+ uint32_t count = pick_u32(reqpos, reqend);
if (count == 0)
tnt_raise(IllegalParams, "tuple count must be positive");
ERROR_INJECT_EXCEPTION(ERRINJ_TESTING);
- u32 found = 0;
+ uint32_t found = 0;
- for (u32 i = 0; i < count; i++) {
+ for (uint32_t i = 0; i < count; i++) {
/* End the loop if reached the limit. */
if (limit == found)
return;
/* read key */
- u32 key_part_count;
+ uint32_t key_part_count;
const char *key = read_key(reqpos, reqend, &key_part_count);
struct iterator *it = index->position();
@@ -177,7 +177,7 @@ execute_select(struct request *request, struct port *port)
static void
execute_delete(struct request *request, struct txn *txn)
{
- u32 type = request->type;
+ uint32_t type = request->type;
txn_add_redo(txn, type, request->data, request->len);
const char **reqpos = &request->data;
const char *reqend = request->data + request->len;
@@ -187,7 +187,7 @@ execute_delete(struct request *request, struct txn *txn)
BOX_ALLOWED_REQUEST_FLAGS;
}
/* read key */
- u32 key_part_count;
+ uint32_t key_part_count;
const char *key = read_key(reqpos, reqend, &key_part_count);
/* Try to find tuple by primary key */
Index *pk = space_index(sp, 0);
@@ -205,7 +205,7 @@ execute_delete(struct request *request, struct txn *txn)
* Check request type here for now.
*/
static bool
-request_check_type(u32 type)
+request_check_type(uint32_t type)
{
return (type != REPLACE && type != SELECT &&
type != UPDATE && type != DELETE_1_3 &&
@@ -213,7 +213,7 @@ request_check_type(u32 type)
}
const char *
-request_name(u32 type)
+request_name(uint32_t type)
{
if (request_check_type(type))
return "unsupported";
@@ -221,7 +221,7 @@ request_name(u32 type)
}
struct request *
-request_create(u32 type, const char *data, u32 len)
+request_create(uint32_t type, const char *data, uint32_t len)
{
if (request_check_type(type)) {
say_error("Unsupported request = %" PRIi32 "", type);
diff --git a/src/box/request.h b/src/box/request.h
index 5befeec28c8d42d1ebfdc89c1a712869eb48e9ef..e8b768c1c3e209fe56f48d5a45ab7ed68d21edd3 100644
--- a/src/box/request.h
+++ b/src/box/request.h
@@ -73,22 +73,22 @@ ENUM(requests, REQUESTS);
extern const char *requests_strs[];
static inline bool
-request_is_select(u32 type)
+request_is_select(uint32_t type)
{
return type == SELECT || type == CALL;
}
-const char *request_name(u32 type);
+const char *request_name(uint32_t type);
struct request
{
- u32 type;
- u32 flags;
+ uint32_t type;
+ uint32_t flags;
const char *data;
- u32 len;
+ uint32_t len;
};
-struct request *request_create(u32 type, const char *data, u32 len);
+struct request *request_create(uint32_t type, const char *data, uint32_t len);
void request_execute(struct request *request, struct txn *txn, struct port *port);
diff --git a/src/box/space.cc b/src/box/space.cc
index dc9eb92017f1d9a74ecb3514e291fd0f9e264f9d..19b739d220fd4c7f3496aca6406ba7783b872cc5 100644
--- a/src/box/space.cc
+++ b/src/box/space.cc
@@ -48,7 +48,7 @@ bool secondary_indexes_enabled = false;
bool primary_indexes_enabled = false;
struct space *
-space_create(u32 space_no, struct key_def *key_defs, u32 key_count, u32 arity)
+space_create(uint32_t space_no, struct key_def *key_defs, uint32_t key_count, uint32_t arity)
{
struct space *space = space_by_n(space_no);
@@ -70,7 +70,7 @@ space_create(u32 space_no, struct key_def *key_defs, u32 key_count, u32 arity)
/* return space by its number */
struct space *
-space_by_n(u32 n)
+space_by_n(uint32_t n)
{
const struct mh_i32ptr_node_t node = { n, NULL };
mh_int_t space = mh_i32ptr_get(spaces, &node, NULL);
@@ -111,7 +111,7 @@ space_foreach(void (*func)(struct space *sp, void *udata), void *udata) {
/** Set index by index no */
void
-space_set_index(struct space *sp, u32 index_no, Index *idx)
+space_set_index(struct space *sp, uint32_t index_no, Index *idx)
{
assert(index_no < BOX_INDEX_MAX);
sp->index[index_no] = idx;
@@ -129,7 +129,7 @@ struct tuple *
space_replace(struct space *sp, struct tuple *old_tuple,
struct tuple *new_tuple, enum dup_replace_mode mode)
{
- u32 i = 0;
+ uint32_t i = 0;
try {
/* Update the primary key */
Index *pk = sp->index[0];
@@ -142,7 +142,7 @@ space_replace(struct space *sp, struct tuple *old_tuple,
old_tuple = pk->replace(old_tuple, new_tuple, mode);
assert(old_tuple || new_tuple);
- u32 n = index_count(sp);
+ uint32_t n = index_count(sp);
/* Update secondary keys */
for (i = i + 1; i < n; i++) {
Index *index = sp->index[i];
@@ -188,13 +188,13 @@ space_validate_tuple(struct space *sp, struct tuple *new_tuple)
* skip undefined size fields (STRING and UNKNOWN).
*/
if (sp->field_types[fieldno] == NUM) {
- if (len != sizeof(u32))
+ if (len != sizeof(uint32_t))
tnt_raise(ClientError, ER_KEY_FIELD_TYPE,
- "u32");
+ "NUM");
} else if (sp->field_types[fieldno] == NUM64) {
- if (len != sizeof(u64))
+ if (len != sizeof(uint64_t))
tnt_raise(ClientError, ER_KEY_FIELD_TYPE,
- "u64");
+ "NUM64");
}
fieldno++;
}
@@ -210,7 +210,7 @@ space_free(void)
mh_i32ptr_node(spaces, i)->val;
mh_i32ptr_del(spaces, i, NULL);
- for (u32 j = 0 ; j < space->key_count; j++) {
+ for (uint32_t j = 0 ; j < space->key_count; j++) {
Index *index = space->index[j];
delete index;
key_free(&space->key_defs[j]);
@@ -234,7 +234,7 @@ key_init(struct key_def *def, struct tarantool_cfg_space_index *cfg_index)
panic("Wrong index type: %s", cfg_index->type);
/* Calculate key part count and maximal field number. */
- for (u32 k = 0; cfg_index->key_field[k] != NULL; ++k) {
+ for (uint32_t k = 0; cfg_index->key_field[k] != NULL; ++k) {
auto cfg_key = cfg_index->key_field[k];
if (cfg_key->fieldno == -1) {
@@ -255,16 +255,16 @@ key_init(struct key_def *def, struct tarantool_cfg_space_index *cfg_index)
/* init compare order array */
def->max_fieldno++;
- def->cmp_order = (u32 *) malloc(def->max_fieldno * sizeof(u32));
+ def->cmp_order = (uint32_t *) malloc(def->max_fieldno * sizeof(uint32_t));
if (def->cmp_order == NULL) {
panic("can't allocate def cmp_order array for index");
}
- for (u32 fieldno = 0; fieldno < def->max_fieldno; fieldno++) {
+ for (uint32_t fieldno = 0; fieldno < def->max_fieldno; fieldno++) {
def->cmp_order[fieldno] = BOX_FIELD_MAX;
}
/* fill fields and compare order */
- for (u32 k = 0; cfg_index->key_field[k] != NULL; ++k) {
+ for (uint32_t k = 0; cfg_index->key_field[k] != NULL; ++k) {
auto cfg_key = cfg_index->key_field[k];
if (cfg_key->fieldno == -1) {
@@ -292,8 +292,8 @@ key_init(struct key_def *def, struct tarantool_cfg_space_index *cfg_index)
static void
space_init_field_types(struct space *space)
{
- u32 i, max_fieldno;
- u32 key_count = space->key_count;
+ uint32_t i, max_fieldno;
+ uint32_t key_count = space->key_count;
struct key_def *key_defs = space->key_defs;
/* find max max field no */
@@ -310,7 +310,7 @@ space_init_field_types(struct space *space)
/* extract field type info */
for (i = 0; i < key_count; i++) {
struct key_def *def = &key_defs[i];
- for (u32 pi = 0; pi < def->part_count; pi++) {
+ for (uint32_t pi = 0; pi < def->part_count; pi++) {
struct key_part *part = &def->parts[pi];
assert(part->fieldno < max_fieldno);
space->field_types[part->fieldno] = part->type;
@@ -321,7 +321,7 @@ space_init_field_types(struct space *space)
/* validate field type info */
for (i = 0; i < key_count; i++) {
struct key_def *def = &key_defs[i];
- for (u32 pi = 0; pi < def->part_count; pi++) {
+ for (uint32_t pi = 0; pi < def->part_count; pi++) {
struct key_part *part = &def->parts[pi];
assert(space->field_types[part->fieldno] == part->type);
}
@@ -338,7 +338,7 @@ space_config()
}
/* fill box spaces */
- for (u32 i = 0; cfg.space[i] != NULL; ++i) {
+ for (uint32_t i = 0; cfg.space[i] != NULL; ++i) {
tarantool_cfg_space *cfg_space = cfg.space[i];
if (!CNF_STRUCT_DEFINED(cfg_space) || !cfg_space->enabled)
@@ -361,7 +361,7 @@ space_config()
* indexes.
*/
space->key_count = 0;
- for (u32 j = 0; cfg_space->index[j] != NULL; ++j) {
+ for (uint32_t j = 0; cfg_space->index[j] != NULL; ++j) {
++space->key_count;
}
@@ -371,14 +371,14 @@ space_config()
if (space->key_defs == NULL) {
panic("can't allocate key def array");
}
- for (u32 j = 0; cfg_space->index[j] != NULL; ++j) {
+ for (uint32_t j = 0; cfg_space->index[j] != NULL; ++j) {
auto cfg_index = cfg_space->index[j];
key_init(&space->key_defs[j], cfg_index);
}
space_init_field_types(space);
/* fill space indexes */
- for (u32 j = 0; cfg_space->index[j] != NULL; ++j) {
+ for (uint32_t j = 0; cfg_space->index[j] != NULL; ++j) {
auto cfg_index = cfg_space->index[j];
enum index_type type = STR2ENUM(index_type, cfg_index->type);
struct key_def *key_def = &space->key_defs[j];
@@ -448,7 +448,7 @@ build_secondary_indexes(void)
say_info("Building secondary keys in space %d...", space->no);
Index *pk = space->index[0];
- for (u32 j = 1; j < space->key_count; j++) {
+ for (uint32_t j = 1; j < space->key_count; j++) {
Index *index = space->index[j];
index->build(pk);
}
@@ -501,12 +501,12 @@ check_spaces(struct tarantool_cfg *conf)
return -1;
}
- u32 max_key_fieldno = 0;
+ uint32_t max_key_fieldno = 0;
/* check spaces indexes */
for (size_t j = 0; space->index[j] != NULL; ++j) {
auto index = space->index[j];
- u32 key_part_count = 0;
+ uint32_t key_part_count = 0;
enum index_type index_type;
/* check index bound */
@@ -586,12 +586,6 @@ check_spaces(struct tarantool_cfg *conf)
switch (index_type) {
case HASH:
/* check hash index */
- /* hash index must has single-field key */
- if (key_part_count != 1) {
- out_warning(CNF_OK, "(space = %zu index = %zu) "
- "hash index must has a single-field key", i, j);
- return -1;
- }
/* hash index must be unique */
if (!index->unique) {
out_warning(CNF_OK, "(space = %zu index = %zu) "
@@ -633,7 +627,7 @@ check_spaces(struct tarantool_cfg *conf)
if (key->fieldno == -1)
break;
- u32 f = key->fieldno;
+ uint32_t f = key->fieldno;
enum field_data_type t = STR2ENUM(field_data_type, key->type);
assert(t != field_data_type_MAX);
if (types[f] != t) {
diff --git a/src/box/space.h b/src/box/space.h
index 7f60c6913e280ab2f2790fa4bc104e732b02f88e..ec996baa95d21b8baa2a671e834b33d085d1a53e 100644
--- a/src/box/space.h
+++ b/src/box/space.h
@@ -42,7 +42,7 @@ struct space {
* @sa max_fieldno). If set, Each tuple
* must have exactly this many fields.
*/
- u32 arity;
+ uint32_t arity;
/**
* The number of indexes in the space.
@@ -50,7 +50,7 @@ struct space {
* It is equal to the number of non-nil members of the index
* array and defines the key_defs array size as well.
*/
- u32 key_count;
+ uint32_t key_count;
/**
* The descriptors for all indexes that belong to the space.
@@ -72,15 +72,15 @@ struct space {
* Each tuple in this space must have, therefore, at least
* field_count fields.
*/
- u32 max_fieldno;
+ uint32_t max_fieldno;
/** Space number. */
- u32 no;
+ uint32_t no;
};
/** Get space ordinal number. */
-static inline u32 space_n(struct space *sp) { return sp->no; }
+static inline uint32_t space_n(struct space *sp) { return sp->no; }
/**
* @brief A single method to handle REPLACE, DELETE and UPDATE.
@@ -183,7 +183,7 @@ space_validate_tuple(struct space *sp, struct tuple *new_tuple);
* @return NULL if index not found.
*/
static inline Index *
-space_index(struct space *sp, u32 index_no)
+space_index(struct space *sp, uint32_t index_no)
{
if (index_no < BOX_INDEX_MAX)
return sp->index[index_no];
@@ -192,7 +192,7 @@ space_index(struct space *sp, u32 index_no)
/** Set index by index no. */
void
-space_set_index(struct space *sp, u32 index_no, Index *idx);
+space_set_index(struct space *sp, uint32_t index_no, Index *idx);
/**
* Call a visitor function on every enabled space.
@@ -205,10 +205,10 @@ space_foreach(void (*func)(struct space *sp, void *udata), void *udata);
*
* @return NULL if space not found, otherwise space object.
*/
-struct space *space_by_n(u32 space_no);
+struct space *space_by_n(uint32_t space_no);
static inline struct space *
-space_find(u32 space_no)
+space_find(uint32_t space_no)
{
struct space *s = space_by_n(space_no);
if (s)
@@ -219,32 +219,32 @@ space_find(u32 space_no)
/** Get key_def ordinal number. */
-static inline u32
+static inline uint32_t
key_def_n(struct space *sp, struct key_def *kp)
{
assert(kp >= sp->key_defs && kp < (sp->key_defs + sp->key_count));
return kp - sp->key_defs;
}
-static inline u32
+static inline uint32_t
space_max_fieldno(struct space *sp)
{
return sp->max_fieldno;
}
static inline enum field_data_type
-space_field_type(struct space *sp, u32 no)
+space_field_type(struct space *sp, uint32_t no)
{
return sp->field_types[no];
}
struct space *
-space_create(u32 space_no, struct key_def *key_defs, u32 key_count, u32 arity);
+space_create(uint32_t space_no, struct key_def *key_defs, uint32_t key_count, uint32_t arity);
/** Get index ordinal number in space. */
-static inline u32
+static inline uint32_t
index_n(Index *index)
{
return key_def_n(index->space, index->key_def);
@@ -279,7 +279,7 @@ void build_secondary_indexes(void);
static inline Index *
-index_find(struct space *sp, u32 index_no)
+index_find(struct space *sp, uint32_t index_no)
{
Index *idx = space_index(sp, index_no);
if (idx == NULL)
diff --git a/src/box/tree_index.cc b/src/box/tree_index.cc
index 8b45c7e7a89ff22661c8c45bd927e8095800caed..add8e54ae8a99564c523018f2c8cbce0c78511bc 100644
--- a/src/box/tree_index.cc
+++ b/src/box/tree_index.cc
@@ -30,717 +30,80 @@
#include "tuple.h"
#include "space.h"
#include "exception.h"
-#include "errinj.h"
-#include <pickle.h>
/* {{{ Utilities. *************************************************/
-/**
- * Unsigned 32-bit int comparison.
- */
-static inline int
-u32_cmp(u32 a, u32 b)
-{
- return a < b ? -1 : (a > b);
-}
-
-/**
- * Unsigned 64-bit int comparison.
- */
-static inline int
-u64_cmp(u64 a, u64 b)
-{
- return a < b ? -1 : (a > b);
-}
-
-/**
- * Tuple address comparison.
- */
-static inline int
-ta_cmp(struct tuple *tuple_a, struct tuple *tuple_b)
-{
- if (!tuple_a)
- return 0;
- if (!tuple_b)
- return 0;
- return tuple_a < tuple_b ? -1 : (tuple_a > tuple_b);
-}
-
-/* }}} */
-
-/* {{{ Tree internal data types. **********************************/
-
-/**
- * Tree types
- *
- * There are four specialized kinds of tree indexes optimized for different
- * combinations of index fields.
- *
- * In the most general case tuples consist of variable length fields and the
- * index uses a sparsely distributed subset of these fields. So to determine
- * the field location in the tuple it is required to scan all the preceding
- * fields. To avoid such scans on each access to a tree node we use the SPARSE
- * tree index structure. It pre-computes on the per-tuple basis the required
- * field offsets (or immediate field values for NUMs) and stores them in the
- * corresponding tree node.
- *
- * In case the index fields form a dense sequence it is possible to find
- * each successive field location based on the previous field location. So it
- * is only required to find the offset of the first index field in the tuple
- * and store it in the tree node. In this case we use the DENSE tree index
- * structure.
- *
- * In case the index consists of only one small field it is cheaper to
- * store the field value immediately in the node rather than store the field
- * offset. In this case we use the NUM32 tree index structure.
- *
- * In case the first field offset in a dense sequence is constant there is no
- * need to store any extra data in the node. For instance, the first index
- * field may be the first field in the tuple so the offset is always zero or
- * all the preceding fields may be fixed-size NUMs so the offset is a non-zero
- * constant. In this case we use the FIXED tree structure.
- *
- * Note that there may be fields with unknown types. In particular, if a field
- * is not used by any index then it doesn't have to be typed. So in many cases
- * we cannot actually determine if the fields preceding to the index are fixed
- * size or not. Therefore we may miss the opportunity to use this optimization
- * in such cases.
- */
-enum tree_type { TREE_SPARSE, TREE_DENSE, TREE_NUM32, TREE_FIXED };
-
-/**
- * Representation of a STR field within a sparse tree index.
-
- * Depending on the STR length we keep either the offset of the field within
- * the tuple or a copy of the field. Specifically, if the STR length is less
- * than or equal to 7 then the length is stored in the "length" field while
- * the copy of the STR data in the "data" field. Otherwise the STR offset in
- * the tuple is stored in the "offset" field. The "length" field in this case
- * is set to 0xFF. The actual length has to be read from the tuple.
- */
-struct sparse_str
-{
- union
- {
- char data[7];
- u32 offset;
- };
- u8 length;
-} __attribute__((packed));
-
-#define BIG_LENGTH 0xff
-
-/**
- * Reprsentation of a tuple field within a sparse tree index.
- *
- * For all NUMs and short STRs it keeps a copy of the field, for long STRs
- * it keeps the offset of the field in the tuple.
- */
-union sparse_part {
- u32 num32;
- u64 num64;
- struct sparse_str str;
-};
-
-#define _SIZEOF_SPARSE_PARTS(part_count) \
- (sizeof(union sparse_part) * (part_count))
-
-#define SIZEOF_SPARSE_PARTS(def) _SIZEOF_SPARSE_PARTS((def)->part_count)
-
-/**
- * Tree nodes for different tree types
- */
-
-struct sparse_node {
- struct tuple *tuple;
- union sparse_part parts[];
-} __attribute__((packed));
-
-struct dense_node {
- struct tuple *tuple;
- u32 offset;
-} __attribute__((packed));
-
-struct num32_node {
- struct tuple *tuple;
- u32 value;
-} __attribute__((packed));
-
-struct fixed_node {
+struct sptree_index_node {
struct tuple *tuple;
};
-/**
- * Representation of data for key search. The data corresponds to some
- * struct key_def. The part_count field from struct key_data may be less
- * than or equal to the part_count field from the struct key_def. Thus
- * the search data may be partially specified.
- *
- * For simplicity sake the key search data uses sparse_part internally
- * regardless of the target kind of tree because there is little benefit
- * of having the most compact representation of transient search data.
- */
-struct key_data
+struct sptree_index_key_data
{
- const char *data;
- u32 part_count;
- union sparse_part parts[];
+ const char *key;
+ uint32_t part_count;
};
-/* }}} */
-
-/* {{{ Tree auxiliary functions. **********************************/
-
-/**
- * Find if the field has fixed offset.
- */
-static int
-find_fixed_offset(struct space *space, u32 fieldno, u32 skip)
-{
- u32 i = skip;
- u32 offset = 0;
-
- while (i < fieldno) {
- /* if the field is unknown give up on it */
- if (i >= space_max_fieldno(space) || space_field_type(space, i) == UNKNOWN) {
- return -1;
- }
-
- /* On a fixed length field account for the appropiate
- varint length code and for the actual data length */
- if (space_field_type(space, i) == NUM) {
- offset += 1 + 4;
- } else if (space_field_type(space, i) == NUM64) {
- offset += 1 + 8;
- }
- /* On a variable length field give up */
- else {
- return -1;
- }
-
- ++i;
- }
-
- return offset;
-}
-
-/**
- * Find the first index field.
- */
-static u32
-find_first_field(struct key_def *key_def)
-{
- for (u32 field = 0; field < key_def->max_fieldno; ++field) {
- u32 part = key_def->cmp_order[field];
- if (part != BOX_FIELD_MAX) {
- return field;
- }
- }
- panic("index field not found");
-}
-
-/**
- * Find the appropriate tree type for a given key.
- */
-static enum tree_type
-find_tree_type(struct space *space, struct key_def *key_def)
-{
- int dense = 1;
- int fixed = 1;
-
- /* Scan for the first tuple field used by the index */
- u32 field = find_first_field(key_def);
- if (find_fixed_offset(space, field, 0) < 0) {
- fixed = 0;
- }
-
- /* Check that there are no gaps after the first field */
- for (; field < key_def->max_fieldno; ++field) {
- u32 part = key_def->cmp_order[field];
- if (part == BOX_FIELD_MAX) {
- dense = 0;
- break;
- }
- }
-
- /* Return the appropriate type */
- if (!dense) {
- return TREE_SPARSE;
- } else if (fixed) {
- return TREE_FIXED;
- } else if (key_def->part_count == 1 && key_def->parts[0].type == NUM) {
- return TREE_NUM32;
- } else {
- return TREE_DENSE;
- }
-}
-
-/**
- * Check if key parts make a linear sequence of fields.
- */
-static bool
-key_is_linear(struct key_def *key_def)
-{
- if (key_def->part_count > 1) {
- u32 prev = key_def->parts[0].fieldno;
- for (u32 i = 1; i < key_def->part_count; ++i) {
- u32 next = key_def->parts[i].fieldno;
- if (next != (prev + 1)) {
- return false;
- }
- prev = next;
- }
- }
- return true;
-}
-
-/**
- * Find field offsets/values for a sparse node.
- */
-static void
-fold_with_sparse_parts(struct key_def *key_def, struct tuple *tuple, union sparse_part* parts)
-{
- assert(tuple->field_count >= key_def->max_fieldno);
-
- const char *part_data = tuple->data;
-
- memset(parts, 0, sizeof(parts[0]) * key_def->part_count);
-
- for (u32 field = 0; field < key_def->max_fieldno; ++field) {
- assert(field < tuple->field_count);
-
- const char *data = part_data;
- u32 len = load_varint32(&data);
-
- u32 part = key_def->cmp_order[field];
- if (part != BOX_FIELD_MAX) {
- if (key_def->parts[part].type == NUM) {
- if (len != sizeof parts[part].num32) {
- tnt_raise(IllegalParams, "key is not u32");
- }
- memcpy(&parts[part].num32, data, len);
- } else if (key_def->parts[part].type == NUM64) {
- if (len != sizeof parts[part].num64) {
- tnt_raise(IllegalParams, "key is not u64");
- }
- memcpy(&parts[part].num64, data, len);
- } else if (len <= sizeof(parts[part].str.data)) {
- parts[part].str.length = len;
- memcpy(parts[part].str.data, data, len);
- } else {
- parts[part].str.length = BIG_LENGTH;
- parts[part].str.offset = (u32) (part_data - tuple->data);
- }
- }
-
- part_data = data + len;
- }
-}
-
-/**
- * Find field offsets/values for a key.
- */
-static void
-fold_with_key_parts(struct key_def *key_def, struct key_data *key_data)
-{
- const char *part_data = key_data->data;
- union sparse_part* parts = key_data->parts;
-
- memset(parts, 0, sizeof(parts[0]) * key_def->part_count);
-
- u32 part_count = MIN(key_def->part_count, key_data->part_count);
- for (u32 part = 0; part < part_count; ++part) {
- const char *data = part_data;
- u32 len = load_varint32(&data);
-
- if (key_def->parts[part].type == NUM) {
- if (len != sizeof parts[part].num32)
- tnt_raise(IllegalParams, "key is not u32");
- memcpy(&parts[part].num32, data, len);
- } else if (key_def->parts[part].type == NUM64) {
- if (len != sizeof parts[part].num64)
- tnt_raise(IllegalParams, "key is not u64");
- memcpy(&parts[part].num64, data, len);
- } else if (len <= sizeof(parts[part].str.data)) {
- parts[part].str.length = len;
- memcpy(parts[part].str.data, data, len);
- } else {
- parts[part].str.length = BIG_LENGTH;
- parts[part].str.offset = (u32) (part_data - key_data->data);
- }
-
- part_data = data + len;
- }
-}
-
-/**
- * Find the offset for a dense node.
- */
-static u32
-fold_with_dense_offset(struct key_def *key_def, struct tuple *tuple)
-{
- const char *tuple_data = tuple->data;
-
- for (u32 field = 0; field < key_def->max_fieldno; ++field) {
- assert(field < tuple->field_count);
-
- const char *data = tuple_data;
- u32 len = load_varint32(&data);
-
- u32 part = key_def->cmp_order[field];
- if (part != BOX_FIELD_MAX) {
- return (u32) (tuple_data - tuple->data);
- }
-
- tuple_data = data + len;
- }
-
- panic("index field not found");
-}
-
-/**
- * Find the value for a num32 node.
- */
-static u32
-fold_with_num32_value(struct key_def *key_def, struct tuple *tuple)
+static inline struct tuple *
+sptree_index_unfold(const void *node)
{
- const char *tuple_data = tuple->data;
-
- for (u32 field = 0; field < key_def->max_fieldno; ++field) {
- assert(field < tuple->field_count);
-
- const char *data = tuple_data;
- u32 len = load_varint32(&data);
-
- u32 part = key_def->cmp_order[field];
- if (part != BOX_FIELD_MAX) {
- u32 value;
- assert(len == sizeof value);
- memcpy(&value, data, sizeof value);
- return value;
- }
-
- tuple_data = data + len;
- }
+ if (node == NULL)
+ return NULL;
- panic("index field not found");
+ struct sptree_index_node *node_x = (struct sptree_index_node *) node;
+ assert (node_x->tuple != NULL);
+ return node_x->tuple;
}
-/**
- * Compare a part for two keys.
- */
-static int
-sparse_part_compare(enum field_data_type type,
- const char *data_a, union sparse_part part_a,
- const char *data_b, union sparse_part part_b)
+static inline void
+sptree_index_fold(void *node, struct tuple *tuple)
{
- if (type == NUM) {
- return u32_cmp(part_a.num32, part_b.num32);
- } else if (type == NUM64) {
- return u64_cmp(part_a.num64, part_b.num64);
- } else {
- int cmp;
- const char *ad, *bd;
- u32 al = part_a.str.length;
- u32 bl = part_b.str.length;
- if (al == BIG_LENGTH) {
- ad = data_a + part_a.str.offset;
- al = load_varint32(&ad);
- } else {
- assert(al <= sizeof(part_a.str.data));
- ad = part_a.str.data;
- }
- if (bl == BIG_LENGTH) {
- bd = data_b + part_b.str.offset;
- bl = load_varint32(&bd);
- } else {
- assert(bl <= sizeof(part_b.str.data));
- bd = part_b.str.data;
- }
-
- cmp = memcmp(ad, bd, MIN(al, bl));
- if (cmp == 0) {
- cmp = (int) al - (int) bl;
- }
+ assert (node != NULL);
+ assert (tuple != NULL);
- return cmp;
- }
-}
-
-/**
- * Compare a key for two sparse nodes.
- */
-static int
-sparse_node_compare(struct key_def *key_def,
- struct tuple *tuple_a,
- const union sparse_part* parts_a,
- struct tuple *tuple_b,
- const union sparse_part* parts_b)
-{
- for (u32 part = 0; part < key_def->part_count; ++part) {
- int r = sparse_part_compare(key_def->parts[part].type,
- tuple_a->data, parts_a[part],
- tuple_b->data, parts_b[part]);
- if (r) {
- return r;
- }
- }
- return 0;
+ struct sptree_index_node *node_x = (struct sptree_index_node *) node;
+ node_x->tuple = tuple;
}
-/**
- * Compare a key for a key search data and a sparse node.
- */
static int
-sparse_key_node_compare(struct key_def *key_def,
- const struct key_data *key_data,
- struct tuple *tuple,
- const union sparse_part* parts)
+sptree_index_node_compare(const void *node_a, const void *node_b, void *arg)
{
- u32 part_count = MIN(key_def->part_count, key_data->part_count);
- for (u32 part = 0; part < part_count; ++part) {
- int r = sparse_part_compare(key_def->parts[part].type,
- key_data->data,
- key_data->parts[part],
- tuple->data, parts[part]);
- if (r) {
- return r;
- }
- }
- return 0;
-}
+ TreeIndex *self = (TreeIndex *) arg;
+ struct tuple *tuple_a = sptree_index_unfold(node_a);
+ struct tuple *tuple_b = sptree_index_unfold(node_b);
-/**
- * Compare a part for two dense keys.
- */
-static int
-dense_part_compare(enum field_data_type type,
- const char *ad, u32 al,
- const char *bd, u32 bl)
-{
- if (type == NUM) {
- u32 an, bn;
- assert(al == sizeof an && bl == sizeof bn);
- memcpy(&an, ad, sizeof an);
- memcpy(&bn, bd, sizeof bn);
- return u32_cmp(an, bn);
- } else if (type == NUM64) {
- u64 an, bn;
- assert(al == sizeof an && bl == sizeof bn);
- memcpy(&an, ad, sizeof an);
- memcpy(&bn, bd, sizeof bn);
- return u64_cmp(an, bn);
- } else {
- int cmp = memcmp(ad, bd, MIN(al, bl));
- if (cmp == 0) {
- cmp = (int) al - (int) bl;
- }
- return cmp;
- }
+ return tuple_compare(tuple_a, tuple_b, self->key_def);
}
-/**
- * Compare a key for two dense nodes.
- */
static int
-dense_node_compare(struct key_def *key_def, u32 first_field,
- struct tuple *tuple_a, u32 offset_a,
- struct tuple *tuple_b, u32 offset_b)
+sptree_index_node_compare_dup(const void *node_a, const void *node_b, void *arg)
{
- u32 part_count = key_def->part_count;
- assert(first_field + part_count <= tuple_a->field_count);
- assert(first_field + part_count <= tuple_b->field_count);
-
- /* Allocate space for offsets. */
- u32 *off_a = (u32 *) alloca(2 * part_count * sizeof(u32));
- u32 *off_b = off_a + part_count;
-
- /* Find field offsets. */
- off_a[0] = offset_a;
- off_b[0] = offset_b;
- if (part_count > 1) {
- const char *ad = tuple_a->data + offset_a;
- const char *bd = tuple_b->data + offset_b;
- for (u32 i = 1; i < part_count; ++i) {
- u32 al = load_varint32(&ad);
- u32 bl = load_varint32(&bd);
- ad += al;
- bd += bl;
- off_a[i] = ad - tuple_a->data;
- off_b[i] = bd - tuple_b->data;
- }
- }
+ TreeIndex *self = (TreeIndex *) arg;
+ struct tuple *tuple_a = sptree_index_unfold(node_a);
+ struct tuple *tuple_b = sptree_index_unfold(node_b);
- /* Compare key parts. */
- for (u32 part = 0; part < part_count; ++part) {
- u32 field = key_def->parts[part].fieldno;
- const char *ad = tuple_a->data + off_a[field - first_field];
- const char *bd = tuple_b->data + off_b[field - first_field];
- u32 al = load_varint32(&ad);
- u32 bl = load_varint32(&bd);
- int r = dense_part_compare(key_def->parts[part].type,
- ad, al, bd, bl);
- if (r) {
- return r;
- }
- }
- return 0;
+ return tuple_compare_dup(tuple_a, tuple_b, self->key_def);
}
-/**
- * Compare a part for two dense keys with parts in linear order.
- */
static int
-linear_node_compare(struct key_def *key_def,
- u32 first_field __attribute__((unused)),
- struct tuple *tuple_a, u32 offset_a,
- struct tuple *tuple_b, u32 offset_b)
+sptree_index_node_compare_with_key(const void *key, const void *node, void *arg)
{
- u32 part_count = key_def->part_count;
- assert(first_field + part_count <= tuple_a->field_count);
- assert(first_field + part_count <= tuple_b->field_count);
-
- /* Compare key parts. */
- const char *ad = tuple_a->data + offset_a;
- const char *bd = tuple_b->data + offset_b;
- for (u32 part = 0; part < part_count; ++part) {
- u32 al = load_varint32(&ad);
- u32 bl = load_varint32(&bd);
- int r = dense_part_compare(key_def->parts[part].type,
- ad, al, bd, bl);
- if (r) {
- return r;
- }
- ad += al;
- bd += bl;
- }
- return 0;
-}
+ TreeIndex *self = (TreeIndex *) arg;
+ struct sptree_index_key_data *key_data =
+ (struct sptree_index_key_data *) key;
+ struct tuple *tuple = sptree_index_unfold(node);
-/**
- * Compare a part for a key search data and a dense key.
- */
-static int
-dense_key_part_compare(enum field_data_type type,
- const char *data_a, union sparse_part part_a,
- const char *bd, u32 bl)
-{
- if (type == NUM) {
- u32 an, bn;
- an = part_a.num32;
- assert(bl == sizeof bn);
- memcpy(&bn, bd, sizeof bn);
- return u32_cmp(an, bn);
- } else if (type == NUM64) {
- u64 an, bn;
- an = part_a.num64;
- assert(bl == sizeof bn);
- memcpy(&bn, bd, sizeof bn);
- return u64_cmp(an, bn);
- } else {
- int cmp;
- const char *ad;
- u32 al = part_a.str.length;
- if (al == BIG_LENGTH) {
- ad = data_a + part_a.str.offset;
- al = load_varint32(&ad);
- } else {
- assert(al <= sizeof(part_a.str.data));
- ad = part_a.str.data;
- }
-
- cmp = memcmp(ad, bd, MIN(al, bl));
- if (cmp == 0) {
- cmp = (int) al - (int) bl;
- }
-
- return cmp;
- }
+ /* the result is inverted because arguments are swapped */
+ return -tuple_compare_with_key(tuple, key_data->key,
+ key_data->part_count, self->key_def);
}
-/**
- * Compare a key for a key search data and a dense node.
- */
-static int
-dense_key_node_compare(struct key_def *key_def,
- const struct key_data *key_data,
- u32 first_field, struct tuple *tuple, u32 offset)
-{
- u32 part_count = key_def->part_count;
- assert(first_field + part_count <= tuple->field_count);
-
- /* Allocate space for offsets. */
- u32 *off = (u32 *) alloca(part_count * sizeof(u32));
-
- /* Find field offsets. */
- off[0] = offset;
- if (part_count > 1) {
- const char *data = tuple->data + offset;
- for (u32 i = 1; i < part_count; ++i) {
- u32 len = load_varint32(&data);
- data += len;
- off[i] = data - tuple->data;
- }
- }
-
- /* Compare key parts. */
- if (part_count > key_data->part_count)
- part_count = key_data->part_count;
- for (u32 part = 0; part < part_count; ++part) {
- u32 field = key_def->parts[part].fieldno;
- const char *bd = tuple->data + off[field - first_field];
- u32 bl = load_varint32(&bd);
- int r = dense_key_part_compare(key_def->parts[part].type,
- key_data->data,
- key_data->parts[part],
- bd, bl);
- if (r) {
- return r;
- }
- }
- return 0;
-}
-
-/**
- * Compare a key for a key search data and a dense node with parts in
- * linear order.
- */
-static int
-linear_key_node_compare(struct key_def *key_def,
- const struct key_data *key_data,
- u32 first_field __attribute__((unused)),
- struct tuple *tuple, u32 offset)
-{
- u32 part_count = key_def->part_count;
- assert(first_field + part_count <= tuple->field_count);
-
- /* Compare key parts. */
- if (part_count > key_data->part_count)
- part_count = key_data->part_count;
- const char *bd = tuple->data + offset;
- for (u32 part = 0; part < part_count; ++part) {
- u32 bl = load_varint32(&bd);
- int r = dense_key_part_compare(key_def->parts[part].type,
- key_data->data,
- key_data->parts[part],
- bd, bl);
- if (r) {
- return r;
- }
- bd += bl;
- }
- return 0;
-}
-
-/* }}} */
-
/* {{{ TreeIndex Iterators ****************************************/
struct tree_iterator {
struct iterator base;
const TreeIndex *index;
struct sptree_index_iterator *iter;
- struct key_data key_data;
+ struct sptree_index_key_data key_data;
};
static void
@@ -767,7 +130,7 @@ tree_iterator_ge(struct iterator *iterator)
{
struct tree_iterator *it = tree_iterator(iterator);
void *node = sptree_index_iterator_next(it->iter);
- return it->index->unfold(node);
+ return sptree_index_unfold(node);
}
static struct tuple *
@@ -775,7 +138,7 @@ tree_iterator_le(struct iterator *iterator)
{
struct tree_iterator *it = tree_iterator(iterator);
void *node = sptree_index_iterator_reverse_next(it->iter);
- return it->index->unfold(node);
+ return sptree_index_unfold(node);
}
static struct tuple *
@@ -786,7 +149,7 @@ tree_iterator_eq(struct iterator *iterator)
void *node = sptree_index_iterator_next(it->iter);
if (node && it->index->tree.compare(&it->key_data, node,
(void *) it->index) == 0)
- return it->index->unfold(node);
+ return sptree_index_unfold(node);
return NULL;
}
@@ -800,7 +163,7 @@ tree_iterator_req(struct iterator *iterator)
if (node != NULL
&& it->index->tree.compare(&it->key_data, node,
(void *) it->index) == 0) {
- return it->index->unfold(node);
+ return sptree_index_unfold(node);
}
return NULL;
@@ -816,7 +179,7 @@ tree_iterator_lt(struct iterator *iterator)
if (it->index->tree.compare(&it->key_data, node,
(void *) it->index) != 0) {
it->base.next = tree_iterator_le;
- return it->index->unfold(node);
+ return sptree_index_unfold(node);
}
}
@@ -833,7 +196,7 @@ tree_iterator_gt(struct iterator *iterator)
if (it->index->tree.compare(&it->key_data, node,
(void *) it->index) != 0) {
it->base.next = tree_iterator_ge;
- return it->index->unfold(node);
+ return sptree_index_unfold(node);
}
}
@@ -842,132 +205,7 @@ tree_iterator_gt(struct iterator *iterator)
/* }}} */
-/* {{{ TreeIndex -- base tree index class *************************/
-
-class SparseTreeIndex: public TreeIndex {
-public:
- SparseTreeIndex(struct key_def *key_def, struct space *space);
-
-// protected:
- size_t
- node_size() const;
-
- tree_cmp_t
- node_cmp() const;
-
- tree_cmp_t
- dup_node_cmp() const;
-
- tree_cmp_t
- key_node_cmp() const;
-
- void
- fold(void *node, struct tuple *tuple) const;
-
- struct tuple *
- unfold(const void *node) const;
-};
-
-
-class DenseTreeIndex: public TreeIndex {
-public:
- DenseTreeIndex(struct key_def *key_def, struct space *space);
-
-// protected:
- size_t
- node_size() const;
-
- tree_cmp_t
- node_cmp() const;
-
- tree_cmp_t
- dup_node_cmp() const;
-
- tree_cmp_t
- key_node_cmp() const;
-
- void
- fold(void *node, struct tuple *tuple) const;
-
- struct tuple *
- unfold(const void *node) const;
-
-//private:
- u32 first_field;
-};
-
-class Num32TreeIndex: public TreeIndex {
-public:
- Num32TreeIndex(struct key_def *key_def, struct space *space);
-
-// protected:
- size_t
- node_size() const;
-
- tree_cmp_t
- node_cmp() const;
-
- tree_cmp_t
- dup_node_cmp() const;
-
- tree_cmp_t
- key_node_cmp() const;
-
- void
- fold(void *node, struct tuple *tuple) const;
-
- struct tuple *
- unfold(const void *node) const;
-};
-
-
-class FixedTreeIndex: public TreeIndex {
-public:
- FixedTreeIndex(struct key_def *key_def, struct space *space);
-
-protected:
- size_t
- node_size() const;
-
- tree_cmp_t
- node_cmp() const;
-
- tree_cmp_t
- dup_node_cmp() const;
-
- tree_cmp_t
- key_node_cmp() const;
-
- void
- fold(void *node, struct tuple *tuple) const;
-
- struct tuple *
- unfold(const void *node) const;
-//private:
-public:
- u32 first_field;
- u32 first_offset;
-};
-
-
-TreeIndex *
-TreeIndex::factory(struct key_def *key_def, struct space *space)
-{
- enum tree_type type = find_tree_type(space, key_def);
- switch (type) {
- case TREE_SPARSE:
- return new SparseTreeIndex(key_def, space);
- case TREE_DENSE:
- return new DenseTreeIndex(key_def, space);
- case TREE_NUM32:
- return new Num32TreeIndex(key_def, space);
- case TREE_FIXED:
- return new FixedTreeIndex(key_def, space);
- default:
- assert(false);
- return 0;
- }
-}
+/* {{{ TreeIndex **********************************************************/
TreeIndex::TreeIndex(struct key_def *key_def, struct space *space)
: Index(key_def, space)
@@ -990,90 +228,65 @@ struct tuple *
TreeIndex::min() const
{
void *node = sptree_index_first(&tree);
- return unfold(node);
+ return sptree_index_unfold(node);
}
struct tuple *
TreeIndex::max() const
{
void *node = sptree_index_last(&tree);
- return unfold(node);
+ return sptree_index_unfold(node);
}
struct tuple *
-TreeIndex::random(u32 rnd) const
+TreeIndex::random(uint32_t rnd) const
{
void *node = sptree_index_random(&tree, rnd);
- return unfold(node);
+ return sptree_index_unfold(node);
}
struct tuple *
-TreeIndex::findByKey(const char *key, u32 part_count) const
+TreeIndex::findByKey(const char *key, uint32_t part_count) const
{
assert(key_def->is_unique && part_count == key_def->part_count);
- struct key_data *key_data = (struct key_data *)
- alloca(sizeof(struct key_data) +
- _SIZEOF_SPARSE_PARTS(part_count));
-
- key_data->data = key;
- key_data->part_count = part_count;
- fold_with_key_parts(key_def, key_data);
-
- void *node = sptree_index_find(&tree, key_data);
- return unfold(node);
-}
-
-struct tuple *
-TreeIndex::findByTuple(struct tuple *tuple) const
-{
- assert(key_def->is_unique);
- if (tuple->field_count < key_def->max_fieldno)
- tnt_raise(IllegalParams, "tuple must have all indexed fields");
-
- struct key_data *key_data = (struct key_data *)
- alloca(sizeof(struct key_data) +
- _SIZEOF_SPARSE_PARTS(tuple->field_count));
-
- key_data->data = tuple->data;
- key_data->part_count = tuple->field_count;
- fold_with_sparse_parts(key_def, tuple, key_data->parts);
-
- void *node = sptree_index_find(&tree, key_data);
- return unfold(node);
+ struct sptree_index_key_data key_data;
+ key_data.key = key;
+ key_data.part_count = part_count;
+ void *node = sptree_index_find(&tree, &key_data);
+ return sptree_index_unfold(node);
}
struct tuple *
TreeIndex::replace(struct tuple *old_tuple, struct tuple *new_tuple,
enum dup_replace_mode mode)
{
- size_t node_size = this->node_size();
- void *new_node = alloca(node_size);
- void *old_node = alloca(node_size);
+ struct sptree_index_node new_node;
+ struct sptree_index_node old_node;
uint32_t errcode;
if (new_tuple) {
- void *dup_node = old_node;
- fold(new_node, new_tuple);
+ struct sptree_index_node *p_dup_node = &old_node;
+ sptree_index_fold(&new_node, new_tuple);
/* Try to optimistically replace the new_tuple. */
- sptree_index_replace(&tree, new_node, &dup_node);
+ sptree_index_replace(&tree, &new_node, (void **) &p_dup_node);
- struct tuple *dup_tuple = unfold(dup_node);
+ struct tuple *dup_tuple = sptree_index_unfold(p_dup_node);
errcode = replace_check_dup(old_tuple, dup_tuple, mode);
if (errcode) {
- sptree_index_delete(&tree, new_node);
- if (dup_node)
- sptree_index_replace(&tree, dup_node, NULL);
+ sptree_index_delete(&tree, &new_node);
+ if (p_dup_node != NULL)
+ sptree_index_replace(&tree, p_dup_node, NULL);
tnt_raise(ClientError, errcode, index_n(this));
}
if (dup_tuple)
return dup_tuple;
}
if (old_tuple) {
- fold(old_node, old_tuple);
- sptree_index_delete(&tree, old_node);
+ sptree_index_fold(&old_node, old_tuple);
+ sptree_index_delete(&tree, &old_node);
}
return old_tuple;
}
@@ -1081,22 +294,22 @@ TreeIndex::replace(struct tuple *old_tuple, struct tuple *new_tuple,
struct iterator *
TreeIndex::allocIterator() const
{
- assert(key_def->part_count);
struct tree_iterator *it = (struct tree_iterator *)
- malloc(sizeof(struct tree_iterator) +
- SIZEOF_SPARSE_PARTS(key_def));
-
- if (it) {
- memset(it, 0, sizeof(struct tree_iterator));
- it->index = this;
- it->base.free = tree_iterator_free;
+ calloc(1, sizeof(*it));
+ if (it == NULL) {
+ tnt_raise(ClientError, ER_MEMORY_ISSUE,
+ sizeof(struct tree_iterator),
+ "TreeIndex", "iterator");
}
+
+ it->index = this;
+ it->base.free = tree_iterator_free;
return (struct iterator *) it;
}
void
TreeIndex::initIterator(struct iterator *iterator, enum iterator_type type,
- const char *key, u32 part_count) const
+ const char *key, uint32_t part_count) const
{
assert (key != NULL || part_count == 0);
struct tree_iterator *it = tree_iterator(iterator);
@@ -1109,11 +322,9 @@ TreeIndex::initIterator(struct iterator *iterator, enum iterator_type type,
type = iterator_type_is_reverse(type) ? ITER_LE : ITER_GE;
key = NULL;
}
- it->key_data.data = key;
+ it->key_data.key = key;
it->key_data.part_count = part_count;
- fold_with_key_parts(key_def, &it->key_data);
-
if (iterator_type_is_reverse(type))
sptree_index_iterator_reverse_init_set(&tree, &it->iter,
&it->key_data);
@@ -1155,8 +366,7 @@ TreeIndex::beginBuild()
tree.size = 0;
tree.max_size = 64;
- size_t node_size = this->node_size();
- size_t sz = tree.max_size * node_size;
+ size_t sz = tree.max_size * sizeof(struct sptree_index_node);
tree.members = malloc(sz);
if (tree.members == NULL) {
panic("malloc(): failed to allocate %" PRI_SZ " bytes", sz);
@@ -1166,20 +376,19 @@ TreeIndex::beginBuild()
void
TreeIndex::buildNext(struct tuple *tuple)
{
- size_t node_size = this->node_size();
-
if (tree.size == tree.max_size) {
tree.max_size *= 2;
- size_t sz = tree.max_size * node_size;
+ size_t sz = tree.max_size * sizeof(struct sptree_index_node);
tree.members = realloc(tree.members, sz);
if (tree.members == NULL) {
panic("malloc(): failed to allocate %" PRI_SZ " bytes", sz);
}
}
- void *node = ((char *) tree.members + tree.size * node_size);
- fold(node, tuple);
+ struct sptree_index_node *node = (struct sptree_index_node *)
+ tree.members + tree.size;
+ sptree_index_fold(node, tuple);
tree.size++;
}
@@ -1188,22 +397,22 @@ TreeIndex::endBuild()
{
assert(index_is_primary(this));
- u32 n_tuples = tree.size;
- u32 estimated_tuples = tree.max_size;
+ uint32_t n_tuples = tree.size;
+ uint32_t estimated_tuples = tree.max_size;
void *nodes = tree.members;
- sptree_index_init(&tree,
- node_size(), nodes, n_tuples, estimated_tuples,
- key_node_cmp(), node_cmp(),
+ sptree_index_init(&tree, sizeof(struct tuple *),
+ nodes, n_tuples, estimated_tuples,
+ sptree_index_node_compare_with_key,
+ sptree_index_node_compare,
this);
}
void
TreeIndex::build(Index *pk)
{
- u32 n_tuples = pk->size();
- u32 estimated_tuples = n_tuples * 1.2;
- size_t node_size = this->node_size();
+ uint32_t n_tuples = pk->size();
+ uint32_t estimated_tuples = n_tuples * 1.2;
void *nodes = NULL;
if (n_tuples) {
@@ -1212,7 +421,7 @@ TreeIndex::build(Index *pk)
* unnecessary realloc() when more data is
* inserted.
*/
- size_t sz = estimated_tuples * node_size;
+ size_t sz = estimated_tuples * sizeof(struct sptree_index_node);
nodes = malloc(sz);
if (nodes == NULL) {
panic("malloc(): failed to allocate %" PRI_SZ " bytes", sz);
@@ -1224,9 +433,10 @@ TreeIndex::build(Index *pk)
struct tuple *tuple;
- for (u32 i = 0; (tuple = it->next(it)) != NULL; ++i) {
- void *node = ((char *) nodes + i * node_size);
- fold(node, tuple);
+ for (uint32_t i = 0; (tuple = it->next(it)) != NULL; ++i) {
+ struct sptree_index_node *node = (struct sptree_index_node *)
+ nodes + i;
+ sptree_index_fold(node, tuple);
}
if (n_tuples) {
@@ -1235,437 +445,10 @@ TreeIndex::build(Index *pk)
}
/* If n_tuples == 0 then estimated_tuples = 0, elem == NULL, tree is empty */
- sptree_index_init(&tree,
- node_size, nodes, n_tuples, estimated_tuples,
- key_node_cmp(),
- key_def->is_unique ? node_cmp() : dup_node_cmp(),
+ sptree_index_init(&tree, sizeof(struct sptree_index_node),
+ nodes, n_tuples, estimated_tuples,
+ sptree_index_node_compare_with_key,
+ key_def->is_unique ? sptree_index_node_compare
+ : sptree_index_node_compare_dup,
this);
}
-
-/* }}} */
-
-/* {{{ SparseTreeIndex ********************************************/
-
-static int
-sparse_node_cmp(const void *node_a, const void *node_b, void *arg)
-{
- SparseTreeIndex *index = (SparseTreeIndex *) arg;
- const struct sparse_node *node_xa = (const struct sparse_node *) node_a;
- const struct sparse_node *node_xb = (const struct sparse_node *) node_b;
- return sparse_node_compare(index->key_def,
- node_xa->tuple, node_xa->parts,
- node_xb->tuple, node_xb->parts);
-}
-
-static int
-sparse_dup_node_cmp(const void *node_a, const void *node_b, void *arg)
-{
- int r = sparse_node_cmp(node_a, node_b, arg);
- if (r == 0) {
- const struct sparse_node *node_xa =
- (const struct sparse_node *) node_a;
- const struct sparse_node *node_xb =
- (const struct sparse_node *) node_b;
- r = ta_cmp(node_xa->tuple, node_xb->tuple);
- }
- return r;
-}
-
-static int
-sparse_key_node_cmp(const void *key, const void *node, void *arg)
-{
- SparseTreeIndex *index = (SparseTreeIndex *) arg;
- const struct key_data *key_data = (const struct key_data *) key;
- const struct sparse_node *node_x = (const struct sparse_node *) node;
- return sparse_key_node_compare(index->key_def, key_data,
- node_x->tuple, node_x->parts);
-}
-
-SparseTreeIndex::SparseTreeIndex(struct key_def *key_def, struct space *space)
- : TreeIndex(key_def, space)
-{
- /* Nothing */
-}
-
-size_t
-SparseTreeIndex::node_size() const
-{
- return sizeof(struct sparse_node) + SIZEOF_SPARSE_PARTS(key_def);
-}
-
-
-tree_cmp_t
-SparseTreeIndex::node_cmp() const
-{
- return sparse_node_cmp;
-}
-
-tree_cmp_t
-SparseTreeIndex::dup_node_cmp() const
-{
- return sparse_dup_node_cmp;
-}
-
-tree_cmp_t
-SparseTreeIndex::key_node_cmp() const
-{
- return sparse_key_node_cmp;
-}
-
-void
-SparseTreeIndex::fold(void *node, struct tuple *tuple) const
-{
- struct sparse_node *node_x = (struct sparse_node *) node;
- node_x->tuple = tuple;
- fold_with_sparse_parts(key_def, tuple, node_x->parts);
-}
-
-struct tuple *
-SparseTreeIndex::unfold(const void *node) const
-{
- const struct sparse_node *node_x = (const struct sparse_node *) node;
- return node_x ? node_x->tuple : NULL;
-}
-
-/* }}} */
-
-/* {{{ DenseTreeIndex *********************************************/
-
-static int
-dense_node_cmp(const void *node_a, const void *node_b, void *arg)
-{
- DenseTreeIndex *index = (DenseTreeIndex *) arg;
- const struct dense_node *node_xa = (const struct dense_node *) node_a;
- const struct dense_node *node_xb = (const struct dense_node *) node_b;
- return dense_node_compare(index->key_def, index->first_field,
- node_xa->tuple, node_xa->offset,
- node_xb->tuple, node_xb->offset);
-}
-
-static int
-dense_dup_node_cmp(const void *node_a, const void *node_b, void *arg)
-{
- int r = dense_node_cmp(node_a, node_b, arg);
- if (r == 0) {
- const struct dense_node *node_xa =
- (const struct dense_node *) node_a;
- const struct dense_node *node_xb =
- (const struct dense_node *) node_b;
- r = ta_cmp(node_xa->tuple, node_xb->tuple);
- }
- return r;
-}
-
-static int
-dense_key_node_cmp(const void *key, const void * node, void *arg)
-{
- DenseTreeIndex *index = (DenseTreeIndex *) arg;
- const struct key_data *key_data = (const struct key_data *) key;
- const struct dense_node *node_x = (const struct dense_node *) node;
- return dense_key_node_compare(index->key_def, key_data,
- index->first_field,
- node_x->tuple, node_x->offset);
-}
-
-static int
-linear_dense_node_cmp(const void *node_a, const void *node_b, void *arg)
-{
- DenseTreeIndex *index = (DenseTreeIndex *) arg;
- const struct dense_node *node_xa = (const struct dense_node *) node_a;
- const struct dense_node *node_xb = (const struct dense_node *) node_b;
- return linear_node_compare(index->key_def, index->first_field,
- node_xa->tuple, node_xa->offset,
- node_xb->tuple, node_xb->offset);
-}
-
-static int
-linear_dense_dup_node_cmp(const void *node_a, const void *node_b, void *arg)
-{
- int r = linear_dense_node_cmp(node_a, node_b, arg);
- if (r == 0) {
- const struct dense_node *node_xa =
- (const struct dense_node *) node_a;
- const struct dense_node *node_xb =
- (const struct dense_node *) node_b;
- r = ta_cmp(node_xa->tuple, node_xb->tuple);
- }
- return r;
-}
-
-static int
-linear_dense_key_node_cmp(const void *key, const void * node, void *arg)
-{
- DenseTreeIndex *index = (DenseTreeIndex *) arg;
- const struct key_data *key_data = (const struct key_data *) key;
- const struct dense_node *node_x = (const struct dense_node *) node;
- return linear_key_node_compare(index->key_def, key_data,
- index->first_field,
- node_x->tuple, node_x->offset);
-}
-
-
-DenseTreeIndex::DenseTreeIndex(struct key_def *key_def, struct space *space)
- : TreeIndex(key_def, space)
-{
- first_field = find_first_field(key_def);
-}
-
-size_t
-DenseTreeIndex::node_size() const
-{
- return sizeof(struct dense_node);
-}
-
-tree_cmp_t
-DenseTreeIndex::node_cmp() const
-{
- return key_is_linear(key_def)
- ? linear_dense_node_cmp
- : dense_node_cmp;
-}
-
-tree_cmp_t
-DenseTreeIndex::dup_node_cmp() const
-{
- return key_is_linear(key_def)
- ? linear_dense_dup_node_cmp
- : dense_dup_node_cmp;
-}
-
-tree_cmp_t
-DenseTreeIndex::key_node_cmp() const
-{
- return key_is_linear(key_def)
- ? linear_dense_key_node_cmp
- : dense_key_node_cmp;
-}
-
-void
-DenseTreeIndex::fold(void *node, struct tuple *tuple) const
-{
- struct dense_node *node_x = (struct dense_node *) node;
- node_x->tuple = tuple;
- node_x->offset = fold_with_dense_offset(key_def, tuple);
-}
-
-struct tuple *
-DenseTreeIndex::unfold(const void *node) const
-{
- const struct dense_node *node_x = (const struct dense_node *) node;
- return node_x ? node_x->tuple : NULL;
-}
-
-/* }}} */
-
-/* {{{ Num32TreeIndex *********************************************/
-
-static int
-num32_node_cmp(const void * node_a, const void * node_b, void *arg)
-{
- (void) arg;
- const struct num32_node *node_xa = (const struct num32_node *) node_a;
- const struct num32_node *node_xb = (const struct num32_node *) node_b;
- return u32_cmp(node_xa->value, node_xb->value);
-}
-
-static int
-num32_dup_node_cmp(const void * node_a, const void * node_b, void *arg)
-{
- int r = num32_node_cmp(node_a, node_b, arg);
- if (r == 0) {
- const struct num32_node *node_xa =
- (const struct num32_node *) node_a;
- const struct num32_node *node_xb =
- (const struct num32_node *) node_b;
- r = ta_cmp(node_xa->tuple, node_xb->tuple);
- }
- return r;
-}
-
-static int
-num32_key_node_cmp(const void * key, const void * node, void *arg)
-{
- (void) arg;
- const struct key_data *key_data = (const struct key_data *) key;
- const struct num32_node *node_x = (const struct num32_node *) node;
- if (key_data->part_count)
- return u32_cmp(key_data->parts[0].num32, node_x->value);
- return 0;
-}
-
-Num32TreeIndex::Num32TreeIndex(struct key_def *key_def, struct space *space)
- : TreeIndex(key_def, space)
-{
- /* Nothing */
-}
-
-size_t
-Num32TreeIndex::node_size() const
-{
- return sizeof(struct num32_node);
-}
-
-tree_cmp_t
-Num32TreeIndex::node_cmp() const
-{
- return num32_node_cmp;
-}
-
-tree_cmp_t
-Num32TreeIndex::dup_node_cmp() const
-{
- return num32_dup_node_cmp;
-}
-
-tree_cmp_t
-Num32TreeIndex::key_node_cmp() const
-{
- return num32_key_node_cmp;
-}
-
-void
-Num32TreeIndex::fold(void *node, struct tuple *tuple) const
-{
- struct num32_node *node_x = (struct num32_node *) node;
- node_x->tuple = tuple;
- node_x->value = fold_with_num32_value(key_def, tuple);
-}
-
-struct tuple *
-Num32TreeIndex::unfold(const void *node) const
-{
- const struct num32_node *node_x = (const struct num32_node *) node;
- return node_x ? node_x->tuple : NULL;
-}
-
-/* }}} */
-
-/* {{{ FixedTreeIndex *********************************************/
-
-static int
-fixed_node_cmp(const void *node_a, const void *node_b, void *arg)
-{
- FixedTreeIndex *index = (FixedTreeIndex *) arg;
- const struct fixed_node *node_xa = (const struct fixed_node *) node_a;
- const struct fixed_node *node_xb = (const struct fixed_node *) node_b;
- return dense_node_compare(index->key_def, index->first_field,
- node_xa->tuple, index->first_offset,
- node_xb->tuple, index->first_offset);
-}
-
-static int
-fixed_dup_node_cmp(const void *node_a, const void *node_b, void *arg)
-{
- int r = fixed_node_cmp(node_a, node_b, arg);
- if (r == 0) {
- const struct fixed_node *node_xa =
- (const struct fixed_node *) node_a;
- const struct fixed_node *node_xb =
- (const struct fixed_node *) node_b;
- r = ta_cmp(node_xa->tuple, node_xb->tuple);
- }
- return r;
-}
-
-static int
-fixed_key_node_cmp(const void *key, const void * node, void *arg)
-{
- FixedTreeIndex *index = (FixedTreeIndex *) arg;
- const struct key_data *key_data = (const struct key_data *) key;
- const struct fixed_node *node_x = (const struct fixed_node *) node;
- return dense_key_node_compare(index->key_def, key_data,
- index->first_field,
- node_x->tuple, index->first_offset);
-}
-
-static int
-linear_fixed_node_cmp(const void *node_a, const void *node_b, void *arg)
-{
- FixedTreeIndex *index = (FixedTreeIndex *) arg;
- const struct fixed_node *node_xa = (const struct fixed_node *) node_a;
- const struct fixed_node *node_xb = (const struct fixed_node *) node_b;
- return linear_node_compare(index->key_def, index->first_field,
- node_xa->tuple, index->first_offset,
- node_xb->tuple, index->first_offset);
-}
-
-static int
-linear_fixed_dup_node_cmp(const void *node_a, const void *node_b, void *arg)
-{
- int r = linear_fixed_node_cmp(node_a, node_b, arg);
- if (r == 0) {
- const struct fixed_node *node_xa =
- (const struct fixed_node *) node_a;
- const struct fixed_node *node_xb =
- (const struct fixed_node *) node_b;
- r = ta_cmp(node_xa->tuple, node_xb->tuple);
- }
- return r;
-}
-
-static int
-linear_fixed_key_node_cmp(const void *key, const void * node, void *arg)
-{
- const FixedTreeIndex *index = (const FixedTreeIndex *) arg;
- const struct key_data *key_data = (const struct key_data *) key;
- const struct fixed_node *node_x = (const struct fixed_node *) node;
- return linear_key_node_compare(index->key_def, key_data,
- index->first_field,
- node_x->tuple, index->first_offset);
-}
-
-
-FixedTreeIndex::FixedTreeIndex(struct key_def *key_def, struct space *space)
- : TreeIndex(key_def, space)
-{
- first_field = find_first_field(key_def);
- first_offset = find_fixed_offset(space, first_field, 0);
-}
-
-
-size_t
-FixedTreeIndex::node_size() const
-{
- return sizeof(struct fixed_node);
-}
-
-tree_cmp_t
-FixedTreeIndex::node_cmp() const
-{
- return key_is_linear(key_def)
- ? linear_fixed_node_cmp
- : fixed_node_cmp;
-}
-
-tree_cmp_t
-FixedTreeIndex::dup_node_cmp() const
-{
- return key_is_linear(key_def)
- ? linear_fixed_dup_node_cmp
- : fixed_dup_node_cmp;
-}
-
-tree_cmp_t
-FixedTreeIndex::key_node_cmp() const
-{
- return key_is_linear(key_def)
- ? linear_fixed_key_node_cmp
- : fixed_key_node_cmp;
-}
-
-void
-FixedTreeIndex::fold(void *node, struct tuple *tuple) const
-{
- struct fixed_node *node_x = (struct fixed_node *) node;
- node_x->tuple = tuple;
-}
-
-struct tuple *
-FixedTreeIndex::unfold(const void *node) const
-{
- const struct fixed_node *node_x = (const struct fixed_node *) node;
- return node_x ? node_x->tuple : NULL;
-}
-
-/* }}} */
-
diff --git a/src/box/tree_index.h b/src/box/tree_index.h
index 33ed75887991e7d5e5776a6aa8f8b460d07f18c9..c19380303fddaa3d3594bd61e8d6381e675147ed 100644
--- a/src/box/tree_index.h
+++ b/src/box/tree_index.h
@@ -38,12 +38,10 @@
*/
SPTREE_DEF(index, realloc);
-typedef int (*tree_cmp_t)(const void *, const void *, void *);
-
class TreeIndex: public Index {
public:
- static TreeIndex *
- factory(struct key_def *key_def, struct space *space);
+ TreeIndex(struct key_def *key_def, struct space *space);
+ virtual ~TreeIndex();
virtual void beginBuild();
virtual void buildNext(struct tuple *tuple);
@@ -52,9 +50,8 @@ class TreeIndex: public Index {
virtual size_t size() const;
virtual struct tuple *min() const;
virtual struct tuple *max() const;
- virtual struct tuple *random(u32 rnd) const;
- virtual struct tuple *findByKey(const char *key, u32 part_count) const;
- virtual struct tuple *findByTuple(struct tuple *tuple) const;
+ virtual struct tuple *random(uint32_t rnd) const;
+ virtual struct tuple *findByKey(const char *key, uint32_t part_count) const;
virtual struct tuple *replace(struct tuple *old_tuple,
struct tuple *new_tuple,
enum dup_replace_mode mode);
@@ -62,23 +59,10 @@ class TreeIndex: public Index {
virtual struct iterator *allocIterator() const;
virtual void initIterator(struct iterator *iterator,
enum iterator_type type,
- const char *key, u32 part_count) const;
+ const char *key, uint32_t part_count) const;
// protected:
- /* Needed by iterators */
- virtual size_t node_size() const = 0;
- virtual tree_cmp_t node_cmp() const = 0;
- virtual tree_cmp_t dup_node_cmp() const = 0;
- virtual tree_cmp_t key_node_cmp() const= 0;
-
- virtual void fold(void *node, struct tuple *tuple) const = 0;
- virtual struct tuple *unfold(const void *node) const = 0;
-
sptree_index tree;
-
-protected:
- TreeIndex(struct key_def *key_def, struct space *space);
- virtual ~TreeIndex();
};
#endif /* TARANTOOL_BOX_TREE_INDEX_H_INCLUDED */
diff --git a/src/box/tuple.cc b/src/box/tuple.cc
index 19efa145d86a596b1e49e2a152c29208c8e5fd82..76d1e5dc79bfb5bda2e80dc9d10e36e61285665e 100644
--- a/src/box/tuple.cc
+++ b/src/box/tuple.cc
@@ -31,6 +31,7 @@
#include <salloc.h>
#include "tbuf.h"
+#include "index.h"
#include "tuple_update.h"
#include <exception.h>
#include <palloc.h>
@@ -86,7 +87,7 @@ tuple_ref(struct tuple *tuple, int count)
* @returns field data if field exists or NULL
*/
const char *
-tuple_field_old(struct tuple *tuple, u32 i)
+tuple_field_old(struct tuple *tuple, uint32_t i)
{
const char *field = tuple->data;
const char *tuple_end = tuple->data + tuple->bsize;
@@ -139,22 +140,22 @@ print_field(struct tbuf *buf, const char *field, uint32_t len)
{
switch (len) {
case 2:
- tbuf_printf(buf, "%hu", *(u16 *)field);
+ tbuf_printf(buf, "%hu", *(uint16_t *)field);
break;
case 4:
- tbuf_printf(buf, "%u", *(u32 *)field);
+ tbuf_printf(buf, "%u", *(uint32_t *)field);
break;
case 8:
- tbuf_printf(buf, "%" PRIu64, *(u64 *)field);
+ tbuf_printf(buf, "%" PRIu64, *(uint64_t *)field);
break;
default:
tbuf_printf(buf, "'");
const char *field_end = field + len;
while (field < field_end) {
- if (0x20 <= *(u8 *)field && *(u8 *)field < 0x7f) {
- tbuf_printf(buf, "%c", *(u8 *) field);
+ if (0x20 <= *(uint8_t *)field && *(uint8_t *)field < 0x7f) {
+ tbuf_printf(buf, "%c", *(uint8_t *) field);
} else {
- tbuf_printf(buf, "\\x%02X", *(u8 *)field);
+ tbuf_printf(buf, "\\x%02X", *(uint8_t *)field);
}
field++;
}
@@ -239,3 +240,112 @@ tuple_new(uint32_t field_count, const char **data, const char *end)
memcpy(new_tuple->data, end - tuple_len, tuple_len);
return new_tuple;
}
+
+static inline int
+tuple_compare_field(const char *field_a, uint32_t size_a,
+ const char *field_b, uint32_t size_b,
+ enum field_data_type type)
+{
+ /*
+ * field_a is always a tuple field.
+ * field_b can be either a tuple field or a key part.
+ * All tuple fields were validated before by space_validate_tuple().
+ * All key parts were validated before by key_validate().
+ */
+ switch (type) {
+ case NUM:
+ {
+ assert(size_a == sizeof(uint32_t));
+ assert(size_b == sizeof(uint32_t));
+ uint32_t a = *(uint32_t *) field_a;
+ uint32_t b = *(uint32_t *) field_b;
+ return a < b ? -1 : (a > b);
+ }
+ case NUM64:
+ {
+ assert(size_a == sizeof(uint64_t));
+ uint64_t a = *(uint64_t *) field_a;
+ uint64_t b;
+ /* Allow search in NUM64 indexes using NUM keys. */
+ if (size_b == sizeof(uint32_t)) {
+ b = *(uint32_t *) field_b;
+ } else {
+ assert(size_b == sizeof(uint64_t));
+ b = *(uint64_t *) field_b;
+ }
+ return a < b ? -1 : (a > b);
+ }
+ case STRING:
+ {
+ int cmp = memcmp(field_a, field_b, MIN(size_a, size_b));
+ if (cmp != 0)
+ return cmp;
+
+ if (size_a > size_b) {
+ return 1;
+ } else if (size_a < size_b){
+ return -1;
+ } else {
+ return 0;
+ }
+ }
+ default:
+ assert(false);
+ }
+}
+
+int
+tuple_compare(const struct tuple *tuple_a, const struct tuple *tuple_b,
+ const struct key_def *key_def)
+{
+ for (uint32_t part = 0; part < key_def->part_count; part++) {
+ uint32_t field_no = key_def->parts[part].fieldno;
+ uint32_t size_a, size_b;
+ const char *field_a = tuple_field(tuple_a, field_no, &size_a);
+ const char *field_b = tuple_field(tuple_b, field_no, &size_b);
+
+ int r = tuple_compare_field(field_a, size_a, field_b, size_b,
+ key_def->parts[part].type);
+ if (r != 0) {
+ return r;
+ }
+ }
+
+ return 0;
+}
+
+int
+tuple_compare_dup(const struct tuple *tuple_a, const struct tuple *tuple_b,
+ const struct key_def *key_def)
+{
+ int r = tuple_compare(tuple_a, tuple_b, key_def);
+ if (r != 0) {
+ return r;
+ }
+
+ return tuple_a < tuple_b ? -1 : (tuple_a > tuple_b);
+}
+
+int
+tuple_compare_with_key(const struct tuple *tuple_a, const char *key,
+ uint32_t part_count, const struct key_def *key_def)
+{
+ part_count = MIN(part_count, key_def->part_count);
+ for (uint32_t part = 0; part < part_count; part++) {
+ uint32_t field_no = key_def->parts[part].fieldno;
+
+ uint32_t size_a;
+ const char *field_a = tuple_field(tuple_a, field_no, &size_a);
+
+ uint32_t key_size = load_varint32(&key);
+ int r = tuple_compare_field(field_a, size_a, key, key_size,
+ key_def->parts[part].type);
+ if (r != 0) {
+ return r;
+ }
+
+ key += key_size;
+ }
+
+ return 0;
+}
diff --git a/src/box/tuple.h b/src/box/tuple.h
index 05c8f25f22bdd0ef25cd86b82f3ef0114fc5e666..401b21a26f67ca318e194091b456de5d474e2445 100644
--- a/src/box/tuple.h
+++ b/src/box/tuple.h
@@ -32,6 +32,7 @@
#include <pickle.h>
struct tbuf;
+struct key_def;
/**
* An atom of Tarantool/Box storage. Consists of a list of fields.
@@ -40,13 +41,13 @@ struct tbuf;
struct tuple
{
/** reference counter */
- u16 refs;
+ uint16_t refs;
/* see enum tuple_flags */
- u16 flags;
+ uint16_t flags;
/** length of the variable part of the tuple */
- u32 bsize;
+ uint32_t bsize;
/** number of fields in the variable part. */
- u32 field_count;
+ uint32_t field_count;
/**
* Fields can have variable length, and thus are packed
* into a contiguous byte array. Each field is prefixed
@@ -88,7 +89,7 @@ tuple_ref(struct tuple *tuple, int count);
* @returns field data if the field exists, or NULL
*/
const char *
-tuple_field_old(struct tuple *tuple, u32 i);
+tuple_field_old(struct tuple *tuple, uint32_t i);
/**
* @brief Return field data of the field
@@ -188,5 +189,56 @@ tuple_range_size(const char **begin, const char *end, uint32_t count)
void tuple_free(struct tuple *tuple);
+/**
+ * @brief Compare two tuples using field by field using key definition
+ * @param tuple_a tuple
+ * @param tuple_b tuple
+ * @param key_def key definition
+ * @retval 0 if key_fields(tuple_a) == key_fields(tuple_b)
+ * @retval <0 if key_fields(tuple_a) < key_fields(tuple_b)
+ * @retval >0 if key_fields(tuple_a) > key_fields(tuple_b)
+ */
+int
+tuple_compare(const struct tuple *tuple_a, const struct tuple *tuple_b,
+ const struct key_def *key_def);
+
+/**
+ * @brief Compare two tuples field by field for duplicate using key definition
+ * @param tuple_a tuple
+ * @param tuple_b tuple
+ * @param key_def key definition
+ * @retval 0 if key_fields(tuple_a) == key_fields(tuple_b) and
+ * tuple_a == tuple_b - tuple_a is the same object as tuple_b
+ * @retval <0 if key_fields(tuple_a) <= key_fields(tuple_b)
+ * @retval >0 if key_fields(tuple_a > key_fields(tuple_b)
+ */
+int
+tuple_compare_dup(const struct tuple *tuple_a, const struct tuple *tuple_b,
+ const struct key_def *key_def);
+
+/**
+ * @brief Compare a tuple with a key field by field using key definition
+ * @param tuple_a tuple
+ * @param key BER-encoded key
+ * @param part_count number of parts in \a key
+ * @param key_def key definition
+ * @retval 0 if key_fields(tuple_a) == parts(key)
+ * @retval <0 if key_fields(tuple_a) < parts(key)
+ * @retval >0 if key_fields(tuple_a) > parts(key)
+ */
+int
+tuple_compare_with_key(const struct tuple *tuple_a, const char *key,
+ uint32_t part_count, const struct key_def *key_def);
+
+/** These functions are implemented in tuple_convert.cc. */
+
+/* Store tuple in the output buffer in iproto format. */
+void
+tuple_to_obuf(struct tuple *tuple, struct obuf *buf);
+
+/* Store tuple fields in the Lua buffer, BER-length-encoded. */
+void
+tuple_to_luabuf(struct tuple *tuple, struct luaL_Buffer *b);
+
#endif /* TARANTOOL_BOX_TUPLE_H_INCLUDED */
diff --git a/src/box/tuple_convert.cc b/src/box/tuple_convert.cc
new file mode 100644
index 0000000000000000000000000000000000000000..fa790ec6a637f5dd173c33c81ec93ce0ccc85532
--- /dev/null
+++ b/src/box/tuple_convert.cc
@@ -0,0 +1,47 @@
+/*
+ * 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 <COPYRIGHT HOLDER> ``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 "tuple.h"
+#include "iobuf.h"
+extern "C" {
+#include <lua.h>
+#include <lauxlib.h>
+#include <lualib.h>
+} /* extern "C" */
+
+void
+tuple_to_obuf(struct tuple *tuple, struct obuf *buf)
+{
+ obuf_dup(buf, &tuple->bsize, tuple_len(tuple));
+}
+
+void
+tuple_to_luabuf(struct tuple *tuple, struct luaL_Buffer *b)
+{
+ luaL_addlstring(b, (char*)tuple->data, tuple->bsize);
+}
diff --git a/src/box/tuple_update.cc b/src/box/tuple_update.cc
index 837b5339c413b82aef3401e2a0b3b9e18b2cdbd6..451b579ce5478aa689603abfdf91ac89f579c145 100644
--- a/src/box/tuple_update.cc
+++ b/src/box/tuple_update.cc
@@ -106,37 +106,37 @@ struct tuple_update
void *alloc_ctx;
struct rope *rope;
struct update_op *ops;
- uint32_t ops_count;
+ uint32_t op_count;
uint32_t new_tuple_size;
uint32_t new_tuple_fcount;
};
/** Argument of SET operation. */
struct op_set_arg {
- u32 length;
+ uint32_t length;
const char *value;
};
/** Argument of ADD, AND, XOR, OR operations. */
struct op_arith_arg {
- u32 val_size;
+ uint32_t val_size;
union {
- i32 i32_val;
- i64 i64_val;
+ int32_t i32_val;
+ int64_t i64_val;
};
};
/** Argument of SPLICE. */
struct op_splice_arg {
- i32 offset; /** splice position */
- i32 cut_length; /** cut this many bytes. */
+ int32_t offset; /** splice position */
+ int32_t cut_length; /** cut this many bytes. */
const char *paste; /** paste what? */
- i32 paste_length; /** paste this many bytes. */
+ int32_t paste_length; /** paste this many bytes. */
/** Offset of the tail in the old field */
- i32 tail_offset;
+ int32_t tail_offset;
/** Size of the tail. */
- i32 tail_length;
+ int32_t tail_length;
};
union update_op_arg {
@@ -163,9 +163,9 @@ struct update_op {
STAILQ_ENTRY(update_op) next;
struct update_op_meta *meta;
union update_op_arg arg;
- u32 field_no;
- u32 new_field_len;
- u8 opcode;
+ uint32_t field_no;
+ uint32_t new_field_len;
+ uint8_t opcode;
};
STAILQ_HEAD(op_list, update_op);
@@ -186,12 +186,12 @@ struct update_field {
* of old data to the beginning of the field in the
* next update_field structure.
*/
- u32 tail_len;
+ uint32_t tail_len;
};
static void
update_field_init(struct update_field *field,
- const char *old, u32 old_len, u32 tail_len)
+ const char *old, uint32_t old_len, uint32_t tail_len)
{
STAILQ_INIT(&field->ops);
field->old = old;
@@ -199,7 +199,7 @@ update_field_init(struct update_field *field,
field->tail_len = tail_len;
}
-static inline u32
+static inline uint32_t
update_field_len(struct update_field *f)
{
struct update_op *last = STAILQ_LAST(&f->ops, update_op, next);
@@ -207,14 +207,14 @@ update_field_len(struct update_field *f)
}
static inline void
-op_check_field_no(u32 field_no, u32 field_max)
+op_check_field_no(uint32_t field_no, uint32_t field_max)
{
if (field_no > field_max)
tnt_raise(ClientError, ER_NO_SUCH_FIELD, field_no);
}
static inline void
-op_adjust_field_no(struct update_op *op, u32 field_max)
+op_adjust_field_no(struct update_op *op, uint32_t field_max)
{
if (op->field_no == UINT32_MAX)
op->field_no = field_max;
@@ -233,46 +233,46 @@ do_update_op_set(struct op_set_arg *arg, const char *in __attribute__((unused)),
static void
do_update_op_add(struct op_arith_arg *arg, const char *in, char *out)
{
- if (arg->val_size == sizeof(i32))
- *(i32 *)out = *(i32 *)in + arg->i32_val;
+ if (arg->val_size == sizeof(int32_t))
+ *(int32_t *)out = *(int32_t *)in + arg->i32_val;
else
- *(i64 *)out = *(i64 *)in + arg->i64_val;
+ *(int64_t *)out = *(int64_t *)in + arg->i64_val;
}
static void
do_update_op_subtract(struct op_arith_arg *arg, const char *in, char *out)
{
- if (arg->val_size == sizeof(i32))
- *(i32 *)out = *(i32 *)in - arg->i32_val;
+ if (arg->val_size == sizeof(int32_t))
+ *(int32_t *)out = *(int32_t *)in - arg->i32_val;
else
- *(i64 *)out = *(i64 *)in - arg->i64_val;
+ *(int64_t *)out = *(int64_t *)in - arg->i64_val;
}
static void
do_update_op_and(struct op_arith_arg *arg, const char *in, char *out)
{
- if (arg->val_size == sizeof(i32))
- *(i32 *)out = *(i32 *)in & arg->i32_val;
+ if (arg->val_size == sizeof(int32_t))
+ *(int32_t *)out = *(int32_t *)in & arg->i32_val;
else
- *(i64 *)out = *(i64 *)in & arg->i64_val;
+ *(int64_t *)out = *(int64_t *)in & arg->i64_val;
}
static void
do_update_op_xor(struct op_arith_arg *arg, const char *in, char *out)
{
- if (arg->val_size == sizeof(i32))
- *(i32 *)out = *(i32 *)in ^ arg->i32_val;
+ if (arg->val_size == sizeof(int32_t))
+ *(int32_t *)out = *(int32_t *)in ^ arg->i32_val;
else
- *(i64 *)out = *(i64 *)in ^ arg->i64_val;
+ *(int64_t *)out = *(int64_t *)in ^ arg->i64_val;
}
static void
do_update_op_or(struct op_arith_arg *arg, const char *in, char *out)
{
- if (arg->val_size == sizeof(i32))
- *(i32 *)out = *(i32 *)in | arg->i32_val;
+ if (arg->val_size == sizeof(int32_t))
+ *(int32_t *)out = *(int32_t *)in | arg->i32_val;
else
- *(i64 *)out = *(i64 *)in | arg->i64_val;
+ *(int64_t *)out = *(int64_t *)in | arg->i64_val;
}
static void
@@ -333,30 +333,30 @@ init_update_op_arith(struct tuple_update *update, struct update_op *op)
struct update_field *field = (struct update_field *)
rope_extract(update->rope, op->field_no);
struct op_arith_arg *arg = &op->arg.arith;
- u32 field_len = update_field_len(field);
+ uint32_t field_len = update_field_len(field);
switch (field_len) {
- case sizeof(i32):
+ case sizeof(int32_t):
/* 32-bit operation */
/* Check the operand type. */
- if (op->arg.set.length != sizeof(i32))
+ if (op->arg.set.length != sizeof(int32_t))
tnt_raise(ClientError, ER_ARG_TYPE,
"32-bit int");
- arg->i32_val = *(i32 *)op->arg.set.value;
+ arg->i32_val = *(int32_t *)op->arg.set.value;
break;
- case sizeof(i64):
+ case sizeof(int64_t):
/* 64-bit operation */
switch (op->arg.set.length) {
- case sizeof(i32):
+ case sizeof(int32_t):
/* 32-bit operand */
/* cast 32-bit operand to 64-bit */
- arg->i64_val = *(i32 *)op->arg.set.value;
+ arg->i64_val = *(int32_t *)op->arg.set.value;
break;
- case sizeof(i64):
+ case sizeof(int64_t):
/* 64-bit operand */
- arg->i64_val = *(i64 *)op->arg.set.value;
+ arg->i64_val = *(int64_t *)op->arg.set.value;
break;
default:
tnt_raise(ClientError, ER_ARG_TYPE,
@@ -378,7 +378,7 @@ init_update_op_splice(struct tuple_update *update, struct update_op *op)
struct update_field *field = (struct update_field *)
rope_extract(update->rope, op->field_no);
- u32 field_len = update_field_len(field);
+ uint32_t field_len = update_field_len(field);
struct op_splice_arg *arg = &op->arg.splice;
const char *value = op->arg.set.value;
@@ -408,7 +408,7 @@ init_update_op_splice(struct tuple_update *update, struct update_op *op)
}
/* Read the paste. */
- arg->paste = pick_field_str(&value, end, (u32 *) &arg->paste_length);
+ arg->paste = pick_field_str(&value, end, (uint32_t *) &arg->paste_length);
/* Fill tail part */
arg->tail_offset = arg->offset + arg->cut_length;
@@ -465,7 +465,7 @@ update_field_split(void *split_ctx, void *data, size_t size __attribute__((unuse
const char *end = field + prev->tail_len;
prev->tail_len = tuple_range_size(&field, end, offset - 1);
- u32 field_len = load_varint32(&field);
+ uint32_t field_len = load_varint32(&field);
update_field_init(next, field, field_len, end - field - field_len);
return next;
@@ -497,12 +497,12 @@ update_create_rope(struct tuple_update *update,
update->alloc(update->alloc_ctx, sizeof(*first));
const char *field = tuple_data;
const char *end = tuple_data_end;
- u32 field_len = load_varint32(&field);
+ uint32_t field_len = load_varint32(&field);
update_field_init(first, field, field_len,
end - field - field_len);
rope_append(update->rope, first, field_count);
- for (uint32_t i = 0; i < update->ops_count; i++) {
+ for (uint32_t i = 0; i < update->op_count; i++) {
update->ops[i].meta->init_op(update, &update->ops[i]);
}
}
@@ -544,8 +544,8 @@ do_update_ops(struct tuple_update *update, char *new_data)
struct update_field *field = (struct update_field *)
rope_leaf_data(node);
- u32 field_count = rope_leaf_size(node);
- u32 field_len = update_field_len(field);
+ uint32_t field_count = rope_leaf_size(node);
+ uint32_t field_len = update_field_len(field);
new_data = pack_varint32(new_data, field_len);
@@ -608,18 +608,18 @@ update_read_ops(struct tuple_update *update, const char *expr,
const char *expr_end)
{
/* number of operations */
- update->ops_count = pick_u32(&expr, expr_end);
+ update->op_count = pick_u32(&expr, expr_end);
- if (update->ops_count > BOX_UPDATE_OP_CNT_MAX)
+ if (update->op_count > BOX_UPDATE_OP_CNT_MAX)
tnt_raise(IllegalParams, "too many operations for update");
- if (update->ops_count == 0)
+ if (update->op_count == 0)
tnt_raise(IllegalParams, "no operations for update");
/* Read update operations. */
update->ops = (struct update_op *) update->alloc(update->alloc_ctx,
- update->ops_count * sizeof(struct update_op));
+ update->op_count * sizeof(struct update_op));
struct update_op *op = update->ops;
- struct update_op *ops_end = op + update->ops_count;
+ struct update_op *ops_end = op + update->op_count;
for (; op < ops_end; op++) {
/* Read operation */
op->field_no = pick_u32(&expr, expr_end);
diff --git a/src/box/txn.cc b/src/box/txn.cc
index 6bfaaf278524a5c1af0d555ac512b2baee43f1b1..f4885074a0eb83c66fc9ce6af4067c6377f8dc40 100644
--- a/src/box/txn.cc
+++ b/src/box/txn.cc
@@ -36,7 +36,7 @@
#include "request.h" /* for request_name */
void
-txn_add_redo(struct txn *txn, u16 op, const char *data, u32 len)
+txn_add_redo(struct txn *txn, uint16_t op, const char *data, uint32_t len)
{
txn->op = op;
txn->data = data;
diff --git a/src/box/txn.h b/src/box/txn.h
index eee411172bddcfcace6047c326229e2a3c9cc84a..32520ca68d5336158e9576aacbba59466a6b0aff 100644
--- a/src/box/txn.h
+++ b/src/box/txn.h
@@ -41,15 +41,15 @@ struct txn {
/* Redo info: binary packet */
const char *data;
- u32 len;
- u16 op;
+ uint32_t len;
+ uint16_t op;
};
struct txn *txn_begin();
void txn_commit(struct txn *txn);
void txn_finish(struct txn *txn);
void txn_rollback(struct txn *txn);
-void txn_add_redo(struct txn *txn, u16 op, const char *data, u32 len);
+void txn_add_redo(struct txn *txn, uint16_t op, const char *data, uint32_t len);
void txn_replace(struct txn *txn, struct space *space,
struct tuple *old_tuple, struct tuple *new_tuple,
enum dup_replace_mode mode);
diff --git a/src/iproto.cc b/src/iproto.cc
index 50fb27c9b872e8324d7a48bc22229f4b8ed593ff..c21f05b1d4b911bdaf800bf827f9897752dadc9e 100644
--- a/src/iproto.cc
+++ b/src/iproto.cc
@@ -32,137 +32,19 @@
#include <stdarg.h>
#include <stdio.h>
+#include "iproto_port.h"
#include "tarantool.h"
#include "exception.h"
#include "errcode.h"
#include "fiber.h"
#include "say.h"
-#include "box/box.h"
-#include "box/port.h"
-#include "box/tuple.h"
-#include "box/request.h"
-#include "iobuf.h"
#include "evio.h"
#include "session.h"
#include "scoped_guard.h"
-enum {
- /** Maximal iproto package body length (2GiB) */
- IPROTO_BODY_LEN_MAX = 2147483648UL
-};
-
-/*
- * struct iproto_header and struct iproto_reply_header
- * share common prefix {msg_code, len, sync}
- */
-
-struct iproto_header {
- uint32_t msg_code;
- uint32_t len;
- uint32_t sync;
-} __attribute__((packed));
-
static struct iproto_header dummy_header = { 0, 0, 0 };
-
-struct iproto_reply_header {
- struct iproto_header hdr;
- uint32_t ret_code;
- uint32_t found;
-} __attribute__((packed));
-
const uint32_t msg_ping = 0xff00;
-static inline struct iproto_header *
-iproto(const char *pos)
-{
- return (struct iproto_header *) pos;
-}
-
-/* {{{ port_iproto */
-
-/**
- * struct port_iproto users need to be careful to:
- * - not unwind output of other fibers when
- * rolling back to a savepoint (provided that
- * multiple fibers work on the same session),
- * - not increment write position before there is a complete
- * response, i.e. a response which will not be rolled back
- * and which has a complete header.
- * - never increment write position without having
- * a complete response. Otherwise a situation can occur
- * when many requests started processing, but completed
- * in a different order, and thus incomplete output is
- * sent to the client.
- *
- * To ensure this, port_iproto must be used only in
- * atomic manner, i.e. once first port_add_tuple() is done,
- * there can be no yields until port_eof().
- */
-struct port_iproto
-{
- struct port_vtab *vtab;
- /** Output buffer. */
- struct obuf *buf;
- /** Reply header. */
- struct iproto_reply_header reply;
- /** A pointer in the reply buffer where the reply starts. */
- struct obuf_svp svp;
-};
-
-static inline struct port_iproto *
-port_iproto(struct port *port)
-{
- return (struct port_iproto *) port;
-}
-
-static void
-port_iproto_eof(struct port *ptr)
-{
- struct port_iproto *port = port_iproto(ptr);
- /* found == 0 means add_tuple wasn't called at all. */
- if (port->reply.found == 0) {
- port->reply.hdr.len = sizeof(port->reply) -
- sizeof(port->reply.hdr);
- obuf_dup(port->buf, &port->reply, sizeof(port->reply));
- } else {
- port->reply.hdr.len = obuf_size(port->buf) - port->svp.size -
- sizeof(port->reply.hdr);
- memcpy(obuf_svp_to_ptr(port->buf, &port->svp),
- &port->reply, sizeof(port->reply));
- }
-}
-
-static void
-port_iproto_add_tuple(struct port *ptr, struct tuple *tuple, u32 flags)
-{
- struct port_iproto *port = port_iproto(ptr);
- if (++port->reply.found == 1) {
- /* Found the first tuple, add header. */
- port->svp = obuf_book(port->buf, sizeof(port->reply));
- }
- if (flags & BOX_RETURN_TUPLE) {
- obuf_dup(port->buf, &tuple->bsize, tuple_len(tuple));
- }
-}
-
-static struct port_vtab port_iproto_vtab = {
- port_iproto_add_tuple,
- port_iproto_eof,
-};
-
-static void
-port_iproto_init(struct port_iproto *port, struct obuf *buf,
- struct iproto_header *req)
-{
- port->vtab = &port_iproto_vtab;
- port->buf = buf;
- port->reply.hdr = *req;
- port->reply.found = 0;
- port->reply.ret_code = 0;
-}
-
-/* }}} */
-
/* {{{ iproto_queue */
struct iproto_request;
@@ -305,9 +187,11 @@ iproto_queue_schedule(struct ev_async *watcher,
struct iproto_queue *i_queue = (struct iproto_queue *) watcher->data;
while (! iproto_queue_is_empty(i_queue)) {
- struct fiber *f = rlist_shift_entry(&i_queue->fiber_cache,
- struct fiber, state);
- if (f == NULL)
+ struct fiber *f;
+ if (! rlist_empty(&i_queue->fiber_cache))
+ f = rlist_shift_entry(&i_queue->fiber_cache,
+ struct fiber, state);
+ else
f = fiber_new("iproto", i_queue->handler);
fiber_call(f, i_queue);
}
@@ -752,7 +636,7 @@ iproto_reply_error(struct obuf *out, struct iproto_header *req,
/** Stack a reply to a single request to the fiber's io vector. */
static inline void
-iproto_reply(struct port_iproto *port, box_process_func callback,
+iproto_reply(struct iproto_port *port, box_process_func callback,
struct obuf *out, struct iproto_header *header)
{
if (header->msg_code == msg_ping)
@@ -760,7 +644,7 @@ iproto_reply(struct port_iproto *port, box_process_func callback,
/* Make request body point to iproto data */
char *body = (char *) &header[1];
- port_iproto_init(port, out, header);
+ iproto_port_init(port, out, header);
try {
callback((struct port *) port, header->msg_code,
body, header->len);
@@ -777,7 +661,7 @@ iproto_process_request(struct iproto_request *request)
struct iproto_session *session = request->session;
struct iproto_header *header = request->header;
struct iobuf *iobuf = request->iobuf;
- struct port_iproto port;
+ struct iproto_port port;
auto scope_guard = make_scoped_guard([=]{
iobuf->in.pos += sizeof(*header) + header->len;
@@ -845,7 +729,6 @@ iproto_process_disconnect(struct iproto_request *request)
/** }}} */
-
/**
* Create a session context and start input.
*/
diff --git a/src/iproto_port.cc b/src/iproto_port.cc
new file mode 100644
index 0000000000000000000000000000000000000000..b6501ce08f6a31a82910b8593e12df66dc37d418
--- /dev/null
+++ b/src/iproto_port.cc
@@ -0,0 +1,69 @@
+/*
+ * 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 <COPYRIGHT HOLDER> ``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 "iproto_port.h"
+
+static inline struct iproto_port *
+iproto_port(struct port *port)
+{
+ return (struct iproto_port *) port;
+}
+
+static inline void
+iproto_port_eof(struct port *ptr)
+{
+ struct iproto_port *port = iproto_port(ptr);
+ /* found == 0 means add_tuple wasn't called at all. */
+ if (port->reply.found == 0) {
+ port->reply.hdr.len = sizeof(port->reply) -
+ sizeof(port->reply.hdr);
+ obuf_dup(port->buf, &port->reply, sizeof(port->reply));
+ } else {
+ port->reply.hdr.len = obuf_size(port->buf) - port->svp.size -
+ sizeof(port->reply.hdr);
+ memcpy(obuf_svp_to_ptr(port->buf, &port->svp),
+ &port->reply, sizeof(port->reply));
+ }
+}
+
+static inline void
+iproto_port_add_tuple(struct port *ptr, struct tuple *tuple, uint32_t flags)
+{
+ struct iproto_port *port = iproto_port(ptr);
+ if (++port->reply.found == 1) {
+ /* Found the first tuple, add header. */
+ port->svp = obuf_book(port->buf, sizeof(port->reply));
+ }
+ if (flags & BOX_RETURN_TUPLE)
+ tuple_to_obuf(tuple, port->buf);
+}
+
+struct port_vtab iproto_port_vtab = {
+ iproto_port_add_tuple,
+ iproto_port_eof,
+};
diff --git a/src/iproto_port.h b/src/iproto_port.h
new file mode 100644
index 0000000000000000000000000000000000000000..47d1b52495023573698ebbeecc1cca11ffc7cf32
--- /dev/null
+++ b/src/iproto_port.h
@@ -0,0 +1,107 @@
+#ifndef TARANTOOL_IPROTO_PORT_H_INCLUDED
+#define TARANTOOL_IPROTO_PORT_H_INCLUDED
+/*
+ * 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 <COPYRIGHT HOLDER> ``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 "box/box.h"
+#include "box/request.h"
+#include "box/port.h"
+#include "box/tuple.h"
+#include "iobuf.h"
+
+enum {
+ /** Maximal iproto package body length (2GiB) */
+ IPROTO_BODY_LEN_MAX = 2147483648UL
+};
+
+/*
+ * struct iproto_header and struct iproto_reply_header
+ * share common prefix {msg_code, len, sync}
+ */
+
+struct iproto_header {
+ uint32_t msg_code;
+ uint32_t len;
+ uint32_t sync;
+} __attribute__((packed));
+
+struct iproto_reply_header {
+ struct iproto_header hdr;
+ uint32_t ret_code;
+ uint32_t found;
+} __attribute__((packed));
+
+static inline struct iproto_header *
+iproto(const char *pos)
+{
+ return (struct iproto_header *) pos;
+}
+
+/**
+ * struct iproto_port users need to be careful to:
+ * - not unwind output of other fibers when
+ * rolling back to a savepoint (provided that
+ * multiple fibers work on the same session),
+ * - not increment write position before there is a complete
+ * response, i.e. a response which will not be rolled back
+ * and which has a complete header.
+ * - never increment write position without having
+ * a complete response. Otherwise a situation can occur
+ * when many requests started processing, but completed
+ * in a different order, and thus incomplete output is
+ * sent to the client.
+ *
+ * To ensure this, iproto_port must be used only in
+ * atomic manner, i.e. once first port_add_tuple() is done,
+ * there can be no yields until port_eof().
+ */
+struct iproto_port
+{
+ struct port_vtab *vtab;
+ /** Output buffer. */
+ struct obuf *buf;
+ /** Reply header. */
+ struct iproto_reply_header reply;
+ /** A pointer in the reply buffer where the reply starts. */
+ struct obuf_svp svp;
+};
+
+extern struct port_vtab iproto_port_vtab;
+
+static inline void
+iproto_port_init(struct iproto_port *port, struct obuf *buf,
+ struct iproto_header *req)
+{
+ port->vtab = &iproto_port_vtab;
+ port->buf = buf;
+ port->reply.hdr = *req;
+ port->reply.found = 0;
+ port->reply.ret_code = 0;
+}
+
+#endif /* TARANTOOL_IPROTO_PORT_H_INCLUDED */
diff --git a/src/lib/CMakeLists.txt b/src/lib/CMakeLists.txt
index c84b46a7784faa236e7cfbb1f6f6d481749de89b..1b2eb42effba2a2ccdde57b609e0ab7ae155782d 100644
--- a/src/lib/CMakeLists.txt
+++ b/src/lib/CMakeLists.txt
@@ -1,2 +1,3 @@
add_subdirectory(bit)
add_subdirectory(bitset)
+add_subdirectory(small)
diff --git a/src/lib/small/CMakeLists.txt b/src/lib/small/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e582e4eb5afedadeab3d3a2346868f39221622cf
--- /dev/null
+++ b/src/lib/small/CMakeLists.txt
@@ -0,0 +1,3 @@
+set(lib_sources slab_cache.c region.c mempool.c small.c)
+set_source_files_compile_flags(${lib_sources})
+add_library(small ${lib_sources})
diff --git a/src/lib/small/README b/src/lib/small/README
new file mode 100644
index 0000000000000000000000000000000000000000..8098fbc9aa9f5e816eac48a52c53e26517df3e32
--- /dev/null
+++ b/src/lib/small/README
@@ -0,0 +1,2 @@
+small - a collection of Specialized Memory ALLocators
+for small allocations.
diff --git a/src/lib/small/mempool.c b/src/lib/small/mempool.c
new file mode 100644
index 0000000000000000000000000000000000000000..a990193d6305c1384c22a232b39d20f6d2481380
--- /dev/null
+++ b/src/lib/small/mempool.c
@@ -0,0 +1,253 @@
+/*
+ * 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 <COPYRIGHT HOLDER> ``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 "lib/small/mempool.h"
+#include <stdlib.h>
+#include <string.h>
+#include "lib/small/slab_cache.h"
+
+static inline int
+mslab_cmp(struct mslab *lhs, struct mslab *rhs)
+{
+ /* pointer arithmetics may overflow int * range. */
+ return lhs > rhs ? 1 : (lhs < rhs ? -1 : 0);
+}
+
+
+rb_proto(, mslab_tree_, mslab_tree_t, struct mslab)
+
+rb_gen(, mslab_tree_, mslab_tree_t, struct mslab, node, mslab_cmp)
+
+static inline void
+mslab_create(struct mslab *slab, struct mempool *pool)
+{
+ slab->ffi = 0;
+ slab->nfree = pool->objcount;
+ slab->pool = pool;
+ /* A bit is set if a slot is free. */
+ memset(slab->map, 0xFF, sizeof(slab->map[0]) * pool->mapsize);
+}
+
+/** Beginning of object data in the slab. */
+void *
+mslab_offset(struct mslab *slab)
+{
+ return (char *) slab + mslab_sizeof() +
+ MEMPOOL_MAP_SIZEOF * slab->pool->mapsize;
+}
+
+/** Pointer to an object from object index. */
+static inline void *
+mslab_obj(struct mslab *slab, uint32_t idx)
+{
+ return mslab_offset(slab) + idx * slab->pool->objsize;
+}
+
+/** Object index from pointer to object */
+static inline uint32_t
+mslab_idx(struct mslab *slab, void *ptr)
+{
+ /*
+ * @todo: consider optimizing this division with
+ * multiply-shift method described in Hacker's Delight,
+ * p. 187.
+ */
+ return ((uint32_t)(ptr - mslab_offset(slab)))/slab->pool->objsize;
+}
+
+void *
+mslab_alloc(struct mslab *slab)
+{
+ assert(slab->nfree);
+ uint32_t idx = __builtin_ffsl(slab->map[slab->ffi]);
+ while (idx == 0) {
+ if (slab->ffi == slab->pool->mapsize - 1) {
+ /*
+ * mslab_alloc() shouldn't be called
+ * on a full slab.
+ */
+ assert(false);
+ return NULL;
+ }
+ slab->ffi++;
+ idx = __builtin_ffsl(slab->map[slab->ffi]);
+ }
+ /*
+ * find-first-set returns bit index starting from 1,
+ * or 0 if no bit is set. Rebase the index to offset 0.
+ */
+ idx--;
+ /* Mark the position as occupied. */
+ slab->map[slab->ffi] ^= ((mbitmap_t) 1) << idx;
+ /* If the slab is full, remove it from the rb tree. */
+ if (--slab->nfree == 0)
+ mslab_tree_remove(&slab->pool->free_slabs, slab);
+ /* Return the pointer at the free slot */
+ return mslab_obj(slab, idx + slab->ffi * MEMPOOL_MAP_BIT);
+}
+
+void
+mslab_free(struct mempool *pool, struct mslab *slab, void *ptr)
+{
+ uint32_t idx = mslab_idx(slab, ptr);
+ uint32_t bit_no = idx & (MEMPOOL_MAP_BIT-1);
+ idx /= MEMPOOL_MAP_BIT;
+ slab->map[idx] |= ((mbitmap_t) 1) << bit_no;
+ slab->nfree++;
+ if (idx < slab->ffi)
+ slab->ffi = idx;
+ if (slab->nfree == 1) {
+ /**
+ * Add this slab to the rbtree which contains partially
+ * populated slabs.
+ */
+ mslab_tree_insert(&pool->free_slabs, slab);
+ } else if (slab->nfree == pool->objcount) {
+ /** Free the slab. */
+ mslab_tree_remove(&pool->free_slabs, slab);
+ if (pool->spare > slab) {
+ slab_list_del(&pool->slabs, &pool->spare->slab,
+ next_in_list);
+ slab_put(pool->cache, &pool->spare->slab);
+ pool->spare = slab;
+ } else if (pool->spare) {
+ slab_list_del(&pool->slabs, &slab->slab,
+ next_in_list);
+ slab_put(pool->cache, &slab->slab);
+ } else {
+ pool->spare = slab;
+ }
+ }
+}
+
+void
+mempool_create_with_order(struct mempool *pool, struct slab_cache *cache,
+ uint32_t objsize, uint8_t order)
+{
+ assert(order <= SLAB_ORDER_LAST);
+ pool->cache = cache;
+ slab_list_create(&pool->slabs);
+ mslab_tree_new(&pool->free_slabs);
+ pool->spare = NULL;
+ pool->objsize = objsize;
+ pool->slab_order = order;
+ /* Account for slab meta. */
+ size_t slab_size = slab_order_size(pool->slab_order) -
+ mslab_sizeof();
+ /* Calculate how many objects will actually fit in a slab. */
+ /*
+ * We have 'slab_size' bytes for X objects and
+ * X / 8 bits in free/used array.
+ *
+ * Therefore the formula for objcount is:
+ *
+ * X * objsize + X/8 = slab_size
+ * X = (8 * slab_size)/(8 * objsize + 1)
+ */
+ size_t objcount = (CHAR_BIT * slab_size)/(CHAR_BIT * objsize + 1);
+ /* How many elements of slab->map can map objcount. */
+ assert(objcount);
+ size_t mapsize = (objcount + MEMPOOL_MAP_BIT - 1)/MEMPOOL_MAP_BIT;
+ /* Adjust the result of integer division, which may be too large. */
+ while (objcount * objsize + mapsize * MEMPOOL_MAP_SIZEOF > slab_size) {
+ objcount--;
+ mapsize = (objcount + MEMPOOL_MAP_BIT - 1)/MEMPOOL_MAP_BIT;
+ }
+ assert(mapsize * MEMPOOL_MAP_BIT >= objcount);
+ /* The wasted memory should be under objsize */
+ assert(slab_size - objcount * objsize -
+ mapsize * MEMPOOL_MAP_SIZEOF < objsize ||
+ mapsize * MEMPOOL_MAP_BIT == objcount);
+ pool->objcount = objcount;
+ pool->mapsize = mapsize;
+}
+
+void
+mempool_destroy(struct mempool *pool)
+{
+ struct slab *slab, *tmp;
+ rlist_foreach_entry_safe(slab, &pool->slabs.slabs,
+ next_in_list, tmp)
+ slab_put(pool->cache, slab);
+}
+
+void *
+mempool_alloc_nothrow(struct mempool *pool)
+{
+ struct mslab *slab = mslab_tree_first(&pool->free_slabs);
+ if (slab == NULL) {
+ if (pool->spare == NULL) {
+ slab = (struct mslab *)
+ slab_get_with_order(pool->cache,
+ pool->slab_order);
+ if (slab == NULL)
+ return NULL;
+ mslab_create(slab, pool);
+ slab_list_add(&pool->slabs, &slab->slab,
+ next_in_list);
+ } else {
+ slab = pool->spare;
+ pool->spare = NULL;
+ }
+ mslab_tree_insert(&pool->free_slabs, slab);
+ }
+ assert(slab->pool == pool);
+ pool->slabs.stats.used += pool->objsize;
+ return mslab_alloc(slab);
+}
+
+void
+mempool_free(struct mempool *pool, void *obj)
+{
+ struct mslab *slab = (struct mslab *)
+ slab_from_ptr(obj, pool->slab_order);
+ pool->slabs.stats.used -= pool->objsize;
+ mslab_free(pool, slab, obj);
+}
+
+void
+mempool_stats(struct mempool *pool, struct mempool_stats *stats)
+{
+ /* Object size. */
+ stats->objsize = pool->objsize;
+ /* Number of objects. */
+ stats->objcount = pool->slabs.stats.used/pool->objsize;
+ /* Size of the slab. */
+ stats->slabsize = slab_order_size(pool->slab_order);
+ /* The number of slabs. */
+ stats->slabcount = pool->slabs.stats.total/stats->slabsize;
+ /* How much memory is used for slabs. */
+ stats->totals.used = pool->slabs.stats.used;
+ /*
+ * How much memory is available. Subtract the slab size,
+ * which is allocation overhead and is not available
+ * memory.
+ */
+ stats->totals.total = pool->slabs.stats.total -
+ mslab_sizeof() * stats->slabcount;
+}
diff --git a/src/lib/small/region.c b/src/lib/small/region.c
new file mode 100644
index 0000000000000000000000000000000000000000..dd13e6e108914119b838ca9d9a8266f84e37c637
--- /dev/null
+++ b/src/lib/small/region.c
@@ -0,0 +1,91 @@
+/*
+ * 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 <COPYRIGHT HOLDER> ``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 "lib/small/region.h"
+
+void *
+region_alloc_slow(struct region *region, size_t size)
+{
+ /* The new slab must have at least this many bytes available. */
+ size_t slab_min_size = size + rslab_sizeof() - slab_sizeof();
+
+ struct rslab *slab;
+ slab = (struct rslab *) slab_get(region->cache, slab_min_size);
+ if (slab == NULL)
+ return NULL;
+ slab->used = size;
+ /*
+ * Sic: add the new slab to the beginning of the
+ * region, even if it is full, otherwise,
+ * region_truncate() won't work.
+ */
+ slab_list_add(®ion->slabs, &slab->slab, next_in_list);
+ region->slabs.stats.used += size;
+ return rslab_data(slab);
+}
+
+void
+region_free(struct region *region)
+{
+ struct slab *slab, *tmp;
+ rlist_foreach_entry_safe(slab, ®ion->slabs.slabs,
+ next_in_list, tmp)
+ slab_put(region->cache, slab);
+
+ slab_list_create(®ion->slabs);
+}
+
+/**
+ * Release all memory down to new_size; new_size has to be previously
+ * obtained by calling region_used().
+ */
+void
+region_truncate(struct region *region, size_t new_size)
+{
+ assert(new_size <= region_used(region));
+
+ ssize_t cut_size = region_used(region) - new_size;
+ while (! rlist_empty(®ion->slabs.slabs)) {
+ struct rslab *slab = rlist_first_entry(®ion->slabs.slabs,
+ struct rslab,
+ slab.next_in_list);
+ if (slab->used > cut_size) {
+ /* This is the last slab to trim. */
+ slab->used -= cut_size;
+ cut_size = 0;
+ break;
+ }
+ cut_size -= slab->used;
+ /* Remove the entire slab. */
+ slab_list_del(®ion->slabs, &slab->slab, next_in_list);
+ slab_put(region->cache, &slab->slab);
+ }
+ assert(cut_size == 0);
+ region->slabs.stats.used = new_size;
+}
+
diff --git a/src/lib/small/slab_cache.c b/src/lib/small/slab_cache.c
new file mode 100644
index 0000000000000000000000000000000000000000..940a0b4fdff80eb73bcbdf67a7b40fed2ec12a1c
--- /dev/null
+++ b/src/lib/small/slab_cache.c
@@ -0,0 +1,434 @@
+/*
+ * 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 <COPYRIGHT HOLDER> ``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 "lib/small/slab_cache.h"
+#include <sys/mman.h>
+#include <stdlib.h>
+#include <string.h>
+#include <errno.h>
+#include <stdio.h>
+#include <stdbool.h>
+
+static const uint32_t slab_magic = 0xeec0ffee;
+
+/**
+ * Given a pointer allocated in a slab, get the handle
+ * of the slab itself.
+ */
+struct slab *
+slab_from_ptr(void *ptr, uint8_t order)
+{
+ assert(order <= SLAB_ORDER_LAST);
+ intptr_t addr = (intptr_t) ptr;
+ /** All memory mapped slabs are slab->size aligned. */
+ struct slab *slab = (struct slab *)
+ (addr & ~(slab_order_size(order) - 1));
+ assert(slab->magic == slab_magic && slab->order == order);
+ return slab;
+}
+
+static inline void
+slab_assert(struct slab *slab)
+{
+ (void) slab;
+ assert(slab->magic == slab_magic);
+ assert(slab->order <= SLAB_HUGE);
+ assert(slab->order == SLAB_HUGE ||
+ (((intptr_t) slab & ~(slab_order_size(slab->order) - 1)) ==
+ (intptr_t) slab &&
+ slab->size == slab_order_size(slab->order)));
+}
+
+/** Mark a slab as free. */
+static inline void
+slab_set_free(struct slab_cache *cache, struct slab *slab)
+{
+ assert(slab->in_use == slab->order + 1); /* Sanity. */
+ cache->allocated.stats.used -= slab->size;
+ cache->orders[slab->order].stats.used -= slab->size;
+ slab->in_use = 0;
+}
+
+static inline void
+slab_set_used(struct slab_cache *cache, struct slab *slab)
+{
+ cache->allocated.stats.used += slab->size;
+ cache->orders[slab->order].stats.used += slab->size;
+ /* Not a boolean to have an extra assert. */
+ slab->in_use = 1 + slab->order;
+}
+
+static inline bool
+slab_is_free(struct slab *slab)
+{
+ return slab->in_use == 0;
+}
+
+static inline void
+slab_poison(struct slab *slab)
+{
+ static const char poison_char = 'P';
+ memset((char *) slab + slab_sizeof(), poison_char,
+ slab->size - slab_sizeof());
+}
+
+static inline void
+slab_create(struct slab *slab, uint8_t order, size_t size)
+{
+ assert(order <= SLAB_HUGE);
+ slab->magic = slab_magic;
+ slab->order = order;
+ slab->in_use = 0;
+ slab->size = size;
+}
+
+static inline void
+munmap_checked(void *addr, size_t length)
+{
+ if (munmap(addr, length)) {
+ char buf[64];
+ strerror_r(errno, buf, sizeof(buf));
+ fprintf(stderr, "Error in munmap(): %s\n", buf);
+ assert(false);
+ }
+}
+
+static inline struct slab *
+slab_mmap(uint8_t order)
+{
+ assert(order <= SLAB_ORDER_LAST);
+
+ size_t size = slab_order_size(order);
+ /*
+ * mmap twice the requested amount to be able to align
+ * the mapped address.
+ * @todo all mappings except the first are likely to
+ * be aligned already. Find out if trying to map
+ * optimistically exactly the requested amount and fall
+ * back to doulbe-size mapping is a viable strategy.
+ */
+ void *map = mmap(NULL, 2 * size,
+ PROT_READ | PROT_WRITE, MAP_PRIVATE |
+ MAP_ANONYMOUS, -1, 0);
+ if (map == MAP_FAILED)
+ return NULL;
+
+ /* Align the mapped address around slab size. */
+ size_t offset = (intptr_t) map & (size - 1);
+
+ if (offset != 0) {
+ /* Unmap unaligned prefix and postfix. */
+ munmap_checked(map, size - offset);
+ map += size - offset;
+ munmap_checked(map + size, offset);
+ } else {
+ /* The address is returned aligned. */
+ munmap_checked(map + size, size);
+ }
+ struct slab *slab = map;
+ slab_create(slab, order, size);
+ return slab;
+}
+
+static inline struct slab *
+slab_buddy(struct slab *slab)
+{
+ assert(slab->order <= SLAB_ORDER_LAST);
+
+ if (slab->order == SLAB_ORDER_LAST)
+ return NULL;
+ /* The buddy address has its respective bit negated. */
+ return (void *) ((intptr_t) slab ^ slab_order_size(slab->order));
+
+}
+
+static inline struct slab *
+slab_split(struct slab_cache *cache, struct slab *slab)
+{
+ assert(slab->order > 0);
+
+ uint8_t new_order = slab->order - 1;
+ size_t new_size = slab_order_size(new_order);
+
+ slab_create(slab, new_order, new_size);
+ struct slab *buddy = slab_buddy(slab);
+ slab_create(buddy, new_order, new_size);
+ slab_list_add(&cache->orders[buddy->order], buddy, next_in_list);
+ return slab;
+}
+
+static inline struct slab *
+slab_merge(struct slab_cache *cache, struct slab *slab, struct slab *buddy)
+{
+ assert(slab_buddy(slab) == buddy);
+ struct slab *merged = slab > buddy ? buddy : slab;
+ /** Remove the buddy from the free list. */
+ slab_list_del(&cache->orders[buddy->order], buddy, next_in_list);
+ merged->order++;
+ merged->size = slab_order_size(merged->order);
+ return merged;
+}
+
+void
+slab_cache_create(struct slab_cache *cache)
+{
+ for (uint8_t i = 0; i <= SLAB_ORDER_LAST; i++)
+ slab_list_create(&cache->orders[i]);
+ slab_list_create(&cache->allocated);
+}
+
+void
+slab_cache_destroy(struct slab_cache *cache)
+{
+ struct rlist *slabs = &cache->allocated.slabs;
+ /*
+ * cache->allocated contains huge allocations and
+ * slabs of the largest order. All smaller slabs are
+ * obtained from larger slabs by splitting.
+ */
+ struct slab *slab, *tmp;
+ rlist_foreach_entry_safe(slab, slabs, next_in_cache, tmp) {
+ if (slab->order == SLAB_HUGE)
+ free(slab);
+ else {
+ /*
+ * Don't trust slab->size or slab->order,
+ * it is wrong if the slab header was
+ * reformatted for a smaller order.
+ */
+ munmap_checked(slab, slab_order_size(SLAB_ORDER_LAST));
+ }
+ }
+}
+
+struct slab *
+slab_get_with_order(struct slab_cache *cache, uint8_t order)
+{
+ assert(order <= SLAB_ORDER_LAST);
+ struct slab *slab;
+ /* Search for the first available slab. If a slab
+ * of a bigger size is found, it can be split.
+ * If SLAB_ORDER_LAST is reached and there are no
+ * free slabs, allocate a new one.
+ */
+ struct slab_list *list= &cache->orders[order];
+
+ for ( ; rlist_empty(&list->slabs); list++) {
+ if (list == cache->orders + SLAB_ORDER_LAST) {
+ slab = slab_mmap(SLAB_ORDER_LAST);
+ if (slab == NULL)
+ return NULL;
+ slab_poison(slab);
+ slab_list_add(&cache->allocated, slab,
+ next_in_cache);
+ slab_list_add(list, slab, next_in_list);
+ break;
+ }
+ }
+ slab = rlist_shift_entry(&list->slabs, struct slab, next_in_list);
+ if (slab->order != order) {
+ /*
+ * Do not "bill" the size of this slab to this
+ * order, to prevent double accounting of the
+ * same memory.
+ */
+ list->stats.total -= slab->size;
+ /* Get a slab of the right order. */
+ do {
+ slab = slab_split(cache, slab);
+ } while (slab->order != order);
+ /*
+ * Count the slab in this order. The buddy is
+ * already taken care of by slab_split.
+ */
+ cache->orders[slab->order].stats.total += slab->size;
+ }
+ slab_set_used(cache, slab);
+ slab_assert(slab);
+ return slab;
+}
+
+/**
+ * Try to find a region of the requested order
+ * in the cache. On failure, mmap() a new region,
+ * optionally split it into a series of half.
+ * Returns a next-power-of-two(size) aligned address
+ * for all sizes below SLAB_SIZE_MAX.
+ */
+struct slab *
+slab_get(struct slab_cache *cache, size_t size)
+{
+ size += slab_sizeof();
+ uint8_t order = slab_order(size);
+
+ if (order == SLAB_HUGE) {
+ struct slab *slab = (struct slab *) malloc(size);
+ if (slab == NULL)
+ return NULL;
+ slab_create(slab, order, size);
+ slab_list_add(&cache->allocated, slab, next_in_cache);
+ cache->allocated.stats.used += size;
+ return slab;
+ }
+ return slab_get_with_order(cache, order);
+}
+
+/** Return a slab back to the slab cache. */
+void
+slab_put(struct slab_cache *cache, struct slab *slab)
+{
+ slab_assert(slab);
+ if (slab->order == SLAB_HUGE) {
+ /*
+ * Free a huge slab right away, we have no
+ * further business to do with it.
+ */
+ slab_list_del(&cache->allocated, slab, next_in_cache);
+ cache->allocated.stats.used -= slab->size;
+ free(slab);
+ return;
+ }
+ /* An "ordered" slab is returned to the cache. */
+ slab_set_free(cache, slab);
+ struct slab *buddy = slab_buddy(slab);
+ /*
+ * The buddy slab could also have been split into a pair
+ * of smaller slabs, the first of which happens to be
+ * free. To not merge with a slab which is in fact
+ * partially occupied, first check that slab orders match.
+ *
+ * A slab is not accounted in "used" or "total" counters
+ * if it was split into slabs of a lower order.
+ * cache->orders statistics only contains sizes of either
+ * slabs returned by slab_get, or present in the free
+ * list. This ensures that sums of cache->orders[i].stats
+ * match the totals in cache->allocated.stats.
+ */
+ if (buddy && buddy->order == slab->order && slab_is_free(buddy)) {
+ cache->orders[slab->order].stats.total -= slab->size;
+ do {
+ slab = slab_merge(cache, slab, buddy);
+ buddy = slab_buddy(slab);
+ } while (buddy && buddy->order == slab->order &&
+ slab_is_free(buddy));
+ cache->orders[slab->order].stats.total += slab->size;
+ }
+ slab_poison(slab);
+ rlist_add_entry(&cache->orders[slab->order].slabs, slab,
+ next_in_list);
+}
+
+void
+slab_cache_check(struct slab_cache *cache)
+{
+ size_t total = 0;
+ size_t used = 0;
+ size_t ordered = 0;
+ size_t huge = 0;
+ bool dont_panic = true;
+
+ struct rlist *slabs = &cache->allocated.slabs;
+ struct slab *slab;
+
+ rlist_foreach_entry(slab, slabs, next_in_cache) {
+ if (slab->magic != slab_magic) {
+ fprintf(stderr, "%s: incorrect slab magic,"
+ " expected %d, got %d", __func__,
+ slab_magic, slab->magic);
+ dont_panic = false;
+ }
+ if (slab->order == SLAB_HUGE) {
+ huge += slab->size;
+ used += slab->size;
+ total += slab->size;
+ } else {
+ if (slab->size != slab_order_size(slab->order)) {
+ fprintf(stderr, "%s: incorrect slab size,"
+ " expected %zu, got %zu", __func__,
+ slab_order_size(slab->order),
+ slab->size);
+ dont_panic = false;
+ }
+ /*
+ * The slab may have been reformatted
+ * and split into smaller slabs, don't
+ * trust slab->size.
+ */
+ total += slab_order_size(SLAB_ORDER_LAST);
+ }
+ }
+
+ if (total != cache->allocated.stats.total) {
+ fprintf(stderr, "%s: incorrect slab statistics, total %zu,"
+ " factual %zu\n", __func__,
+ cache->allocated.stats.total,
+ total);
+ dont_panic = false;
+ }
+
+ for (struct slab_list *list = cache->orders;
+ list <= cache->orders + SLAB_ORDER_LAST;
+ list++) {
+
+ uint8_t order = slab_order_size(list - cache->orders);
+ ordered += list->stats.total;
+ used += list->stats.used;
+
+ if (list->stats.total % slab_order_size(order)) {
+ fprintf(stderr, "%s: incorrect order statistics, the"
+ " total %zu is not multiple of slab size %zu\n",
+ __func__, list->stats.total,
+ slab_order_size(order));
+ dont_panic = false;
+ }
+ if (list->stats.used % slab_order_size(order)) {
+ fprintf(stderr, "%s: incorrect order statistics, the"
+ " used %zu is not multiple of slab size %zu\n",
+ __func__, list->stats.used,
+ slab_order_size(order));
+ dont_panic = false;
+ }
+ }
+
+ if (ordered + huge != total) {
+ fprintf(stderr, "%s: incorrect totals, ordered %zu, "
+ " huge %zu, total %zu\n", __func__,
+ ordered, huge, total);
+ dont_panic = false;
+ }
+ if (used != cache->allocated.stats.used) {
+ fprintf(stderr, "%s: incorrect used total, "
+ "total %zu, sum %zu\n", __func__,
+ cache->allocated.stats.used,
+ used);
+ dont_panic = false;
+ }
+ if (dont_panic)
+ return;
+ abort();
+}
diff --git a/src/lib/small/small.c b/src/lib/small/small.c
new file mode 100644
index 0000000000000000000000000000000000000000..f54c9e4c1b5f0e067444dbbe35f04f40caefbe23
--- /dev/null
+++ b/src/lib/small/small.c
@@ -0,0 +1,291 @@
+/*
+ * 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 <COPYRIGHT HOLDER> ``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 "lib/small/small.h"
+#include <assert.h>
+#include <stdlib.h>
+#include <string.h>
+
+enum {
+ /** Step size for stepped pools, in bytes */
+ STEP_SIZE = 8,
+ /**
+ * LB stands for logarithm with binary base, this constant
+ * is used for bit shifts, when we need to divide by
+ * STEP_SIZE.
+ */
+ STEP_SIZE_LB = 3,
+};
+
+rb_proto(, factor_tree_, factor_tree_t, struct factor_pool)
+
+/** Used for search in the tree. */
+static inline int
+factor_pool_cmp(struct factor_pool *a, struct factor_pool *b)
+{
+ return a->pool.objsize > b->pool.objsize ? 1 :
+ a->pool.objsize < b->pool.objsize ? -1 : 0;
+}
+
+rb_gen(, factor_tree_, factor_tree_t, struct factor_pool, node,
+ factor_pool_cmp)
+
+static inline struct factor_pool *
+factor_pool_create(struct small_alloc *alloc,
+ struct factor_pool *upper_bound,
+ size_t size)
+{
+ assert(size > alloc->step_pool_objsize_max);
+
+ if (alloc->factor_pool_next == NULL) {
+ /**
+ * Too many factored pools already, fall back
+ * to an imperfect one.
+ */
+ return upper_bound;
+ }
+ size_t objsize = alloc->step_pool_objsize_max;
+ size_t prevsize;
+ do {
+ prevsize = objsize;
+ /*
+ * Align objsize after each multiplication to
+ * ensure that the distance between objsizes of
+ * factored pools is a multiple of STEP_SIZE.
+ */
+ objsize = slab_size_align(objsize * alloc->factor,
+ sizeof(intptr_t));
+ assert(objsize > alloc->step_pool_objsize_max);
+ } while (objsize < size);
+ struct factor_pool *pool = alloc->factor_pool_next;
+ alloc->factor_pool_next= pool->next;
+ mempool_create_with_order(&pool->pool, alloc->cache,
+ objsize, alloc->slab_order);
+ pool->objsize_min = prevsize + 1;
+ factor_tree_insert(&alloc->factor_pools, pool);
+ return pool;
+}
+
+/** Initialize the small allocator. */
+void
+small_alloc_create(struct small_alloc *alloc, struct slab_cache *cache,
+ uint32_t objsize_min, uint32_t objsize_max,
+ float alloc_factor)
+{
+ alloc->cache = cache;
+ /* Align sizes. */
+ objsize_min = slab_size_align(objsize_min, sizeof(intptr_t));
+ objsize_max = slab_size_align(objsize_max, sizeof(intptr_t));
+ assert(objsize_max > objsize_min + STEP_POOL_MAX * STEP_SIZE);
+ /*
+ * Make sure at least 4 largest objects can fit in a slab.
+ * This asserts if objsize_max is too large to fit in an
+ * ordered slab nicely.
+ */
+ alloc->slab_order = slab_order(objsize_max * 4 + mslab_sizeof());
+
+ struct mempool *step_pool;
+ for (step_pool = alloc->step_pools;
+ step_pool < alloc->step_pools + STEP_POOL_MAX;
+ step_pool++) {
+
+ mempool_create_with_order(step_pool, alloc->cache,
+ objsize_min, alloc->slab_order);
+ objsize_min += STEP_SIZE;
+ }
+ alloc->step_pool_objsize_max = (step_pool - 1)->objsize;
+ if (alloc_factor > 2.0)
+ alloc_factor = 2.0;
+ /*
+ * Correct the user-supplied alloc_factor to ensure that
+ * it actually produces growing object sizes.
+ */
+ if (alloc->step_pool_objsize_max * alloc_factor <
+ alloc->step_pool_objsize_max + STEP_SIZE) {
+
+ alloc_factor =
+ (alloc->step_pool_objsize_max + STEP_SIZE + 0.5)/
+ alloc->step_pool_objsize_max;
+ }
+ alloc->factor = alloc_factor;
+
+ /* Initialize the factored pool cache. */
+ struct factor_pool *factor_pool = alloc->factor_pool_cache;
+ do {
+ factor_pool->next = factor_pool + 1;
+ factor_pool++;
+ } while (factor_pool !=
+ alloc->factor_pool_cache + FACTOR_POOL_MAX - 1);
+ factor_pool->next = NULL;
+ alloc->factor_pool_next = alloc->factor_pool_cache;
+ factor_tree_new(&alloc->factor_pools);
+ (void) factor_pool_create(alloc, NULL, objsize_max);
+}
+
+/**
+ * Allocate a small object.
+ *
+ * Find or create a mempool instance of the right size,
+ * and allocate the object on the pool.
+ *
+ * If object is small enough to fit a stepped pool,
+ * finding the right pool for it is just a matter of bit
+ * shifts. Otherwise, look up a pool in the red-black
+ * factored pool tree.
+ *
+ * @retval ptr success
+ * @retval NULL out of memory
+ */
+void *
+smalloc_nothrow(struct small_alloc *alloc, size_t size)
+{
+ struct mempool *pool;
+ if (size <= alloc->step_pool_objsize_max) {
+ /* Allocate in a stepped pool. */
+ int idx = (size + STEP_SIZE - 1) >> STEP_SIZE_LB;
+ const int objsize_min_lb =
+ alloc->step_pools[0].objsize >> STEP_SIZE_LB;
+ idx = idx > objsize_min_lb ? idx - objsize_min_lb : 0;
+ pool = &alloc->step_pools[idx];
+ assert(size <= pool->objsize &&
+ (size + STEP_SIZE > pool->objsize || idx == 0));
+ } else {
+ struct factor_pool pattern;
+ pattern.pool.objsize = size;
+ struct factor_pool *upper_bound =
+ factor_tree_nsearch(&alloc->factor_pools, &pattern);
+ if (upper_bound == NULL) {
+ assert(false);
+ return NULL; /* The requested size is too large. */
+ }
+
+ if (size < upper_bound->objsize_min)
+ upper_bound = factor_pool_create(alloc, upper_bound,
+ size);
+ pool = &upper_bound->pool;
+ }
+ assert(size <= pool->objsize);
+ return mempool_alloc_nothrow(pool);
+}
+
+/**
+ * Free a small objects.
+ *
+ * This boils down to finding the object's mempool and delegating
+ * to mempool_free().
+ *
+ * If the pool becomes completely empty, and it's a factored pool,
+ * and the factored pool's cache is empty, put back the empty
+ * factored pool into the factored pool cache.
+ */
+void
+smfree(struct small_alloc *alloc, void *ptr)
+{
+ struct mslab *slab = (struct mslab *)
+ slab_from_ptr(ptr, alloc->slab_order);
+ struct mempool *pool = slab->pool;
+ mempool_free(pool, ptr);
+ /*
+ * Don't keep around empty factored pools
+ * if the allocator is out of them.
+ */
+ if (mempool_used(pool) == 0 &&
+ pool->objsize > alloc->step_pool_objsize_max &&
+ alloc->factor_pool_next == NULL) {
+ struct factor_pool *factor_pool = (struct factor_pool *)
+ ((char *) pool - (intptr_t)
+ &((struct factor_pool *) NULL)->pool);
+ factor_tree_remove(&alloc->factor_pools, factor_pool);
+ alloc->factor_pool_next = factor_pool;
+ }
+}
+
+/** Simplify iteration over small allocator mempools. */
+struct mempool_iterator
+{
+ struct small_alloc *alloc;
+ struct mempool *step_pool;
+ struct factor_pool *factor_pool;
+};
+
+void
+mempool_iterator_create(struct mempool_iterator *it,
+ struct small_alloc *alloc)
+{
+ it->alloc = alloc;
+ it->step_pool = alloc->step_pools;
+ it->factor_pool = factor_tree_first(&alloc->factor_pools);
+}
+
+struct mempool *
+mempool_iterator_next(struct mempool_iterator *it)
+{
+ if (it->step_pool < it->alloc->step_pools + STEP_POOL_MAX)
+ return it->step_pool++;
+
+ if (it->factor_pool) {
+ struct mempool *pool = &it->factor_pool->pool;
+ it->factor_pool = factor_tree_next(&it->alloc->factor_pools,
+ it->factor_pool);
+ return pool;
+ }
+ return NULL;
+}
+
+/** Destroy all pools. */
+void
+small_alloc_destroy(struct small_alloc *alloc)
+{
+ struct mempool_iterator it;
+ mempool_iterator_create(&it, alloc);
+ struct mempool *pool;
+
+ while ((pool = mempool_iterator_next(&it)))
+ mempool_destroy(pool);
+}
+
+/** Calculate allocation statistics. */
+void
+small_stats(struct small_alloc *alloc,
+ struct small_stats *totals,
+ mempool_stats_cb cb, void *cb_ctx)
+{
+ memset(totals, 0, sizeof(*totals));
+
+ struct mempool_iterator it;
+ mempool_iterator_create(&it, alloc);
+ struct mempool *pool;
+
+ while ((pool = mempool_iterator_next(&it))) {
+ struct mempool_stats stats;
+ mempool_stats(pool, &stats);
+ totals->used += stats.totals.used;
+ totals->total += stats.totals.total;
+ cb(cb_ctx, &stats);
+ }
+}
diff --git a/src/log_io.cc b/src/log_io.cc
index fdecb1840de8bde4357ef22c15040ce837ebb72f..6db09b16d9e7cab2ec6a5dcaa62d7e211c795680 100644
--- a/src/log_io.cc
+++ b/src/log_io.cc
@@ -36,7 +36,7 @@
#include "fio.h"
#include "tarantool_eio.h"
-const u32 default_version = 11;
+const uint32_t default_version = 11;
const log_magic_t row_marker_v11 = 0xba0babed;
const log_magic_t eof_marker_v11 = 0x10adab1e;
const char inprogress_suffix[] = ".inprogress";
@@ -53,7 +53,7 @@ header_v11_sign(struct header_v11 *header)
}
void
-row_v11_fill(struct row_v11 *row, u64 lsn, u16 tag, u64 cookie,
+row_v11_fill(struct row_v11 *row, int64_t lsn, uint16_t tag, uint64_t cookie,
const char *metadata, size_t metadata_len, const char
*data, size_t data_len)
{
@@ -87,19 +87,19 @@ struct log_dir wal_dir = {
static int
cmp_i64(const void *_a, const void *_b)
{
- const i64 *a = (const i64 *) _a, *b = (const i64 *) _b;
+ const int64_t *a = (const int64_t *) _a, *b = (const int64_t *) _b;
if (*a == *b)
return 0;
return (*a > *b) ? 1 : -1;
}
static ssize_t
-scan_dir(struct log_dir *dir, i64 **ret_lsn)
+scan_dir(struct log_dir *dir, int64_t **ret_lsn)
{
ssize_t result = -1;
size_t i = 0, size = 1024;
ssize_t ext_len = strlen(dir->filename_ext);
- i64 *lsn = (i64 *) palloc(fiber->gc_pool, sizeof(i64) * size);
+ int64_t *lsn = (int64_t *) palloc(fiber->gc_pool, sizeof(int64_t) * size);
DIR *dh = opendir(dir->dirname);
if (lsn == NULL || dh == NULL)
@@ -143,16 +143,16 @@ scan_dir(struct log_dir *dir, i64 **ret_lsn)
i++;
if (i == size) {
- i64 *n = (i64 *) palloc(fiber->gc_pool, sizeof(i64) * size * 2);
+ int64_t *n = (int64_t *) palloc(fiber->gc_pool, sizeof(int64_t) * size * 2);
if (n == NULL)
goto out;
- memcpy(n, lsn, sizeof(i64) * size);
+ memcpy(n, lsn, sizeof(int64_t) * size);
lsn = n;
size = size * 2;
}
}
- qsort(lsn, i, sizeof(i64), cmp_i64);
+ qsort(lsn, i, sizeof(int64_t), cmp_i64);
*ret_lsn = lsn;
result = i;
@@ -165,10 +165,10 @@ scan_dir(struct log_dir *dir, i64 **ret_lsn)
return result;
}
-i64
+int64_t
greatest_lsn(struct log_dir *dir)
{
- i64 *lsn;
+ int64_t *lsn;
ssize_t count = scan_dir(dir, &lsn);
if (count <= 0)
@@ -177,10 +177,10 @@ greatest_lsn(struct log_dir *dir)
return lsn[count - 1];
}
-i64
-find_including_file(struct log_dir *dir, i64 target_lsn)
+int64_t
+find_including_file(struct log_dir *dir, int64_t target_lsn)
{
- i64 *lsn;
+ int64_t *lsn;
ssize_t count = scan_dir(dir, &lsn);
if (count <= 0)
@@ -206,7 +206,7 @@ find_including_file(struct log_dir *dir, i64 target_lsn)
}
char *
-format_filename(struct log_dir *dir, i64 lsn, enum log_suffix suffix)
+format_filename(struct log_dir *dir, int64_t lsn, enum log_suffix suffix)
{
static __thread char filename[PATH_MAX + 1];
const char *suffix_str = suffix == INPROGRESS ? inprogress_suffix : "";
@@ -219,44 +219,41 @@ format_filename(struct log_dir *dir, i64 lsn, enum log_suffix suffix)
/* {{{ struct log_io_cursor */
-#define ROW_EOF (struct tbuf *) 1
+static const char ROW_EOF[] = "";
-static struct tbuf *
-row_reader_v11(FILE *f, struct palloc_pool *pool)
+const char *
+row_reader_v11(FILE *f, uint32_t *rowlen)
{
- struct tbuf *m = tbuf_new(pool);
+ struct header_v11 m;
- u32 header_crc, data_crc;
+ uint32_t header_crc, data_crc;
- tbuf_ensure(m, sizeof(struct header_v11));
- if (fread(m->data, sizeof(struct header_v11), 1, f) != 1)
+ if (fread(&m, sizeof(m), 1, f) != 1)
return ROW_EOF;
- m->size = sizeof(struct header_v11);
-
/* header crc32c calculated on <lsn, tm, len, data_crc32c> */
- header_crc = crc32_calc(0, (const unsigned char *) m->data + offsetof(struct header_v11, lsn),
- sizeof(struct header_v11) - offsetof(struct header_v11, lsn));
+ header_crc = crc32_calc(0, (unsigned char *) &m + offsetof(struct header_v11, lsn),
+ sizeof(m) - offsetof(struct header_v11, lsn));
- if (header_v11(m)->header_crc32c != header_crc) {
+ if (m.header_crc32c != header_crc) {
say_error("header crc32c mismatch");
return NULL;
}
+ char *row = (char *) palloc(fiber->gc_pool, sizeof(m) + m.len);
+ memcpy(row, &m, sizeof(m));
- tbuf_ensure(m, m->size + header_v11(m)->len);
- if (fread(m->data + sizeof(struct header_v11), header_v11(m)->len, 1, f) != 1)
+ if (fread(row + sizeof(m), m.len, 1, f) != 1)
return ROW_EOF;
- m->size += header_v11(m)->len;
-
- data_crc = crc32_calc(0, (const unsigned char *) m->data + sizeof(struct header_v11), header_v11(m)->len);
- if (header_v11(m)->data_crc32c != data_crc) {
+ data_crc = crc32_calc(0, (unsigned char *) row + sizeof(m), m.len);
+ if (m.data_crc32c != data_crc) {
say_error("data crc32c mismatch");
return NULL;
}
- say_debug("read row v11 success lsn:%lld", (long long)header_v11(m)->lsn);
- return m;
+ say_debug("read row v11 success lsn:%lld", (long long) m.lsn);
+ *rowlen = m.len + sizeof(m);
+ return row;
}
void
@@ -290,11 +287,11 @@ log_io_cursor_close(struct log_io_cursor *i)
* @param i iterator object, encapsulating log specifics.
*
*/
-struct tbuf *
-log_io_cursor_next(struct log_io_cursor *i)
+const char *
+log_io_cursor_next(struct log_io_cursor *i, uint32_t *rowlen)
{
struct log_io *l = i->log;
- struct tbuf *row;
+ const char *row;
log_magic_t magic;
off_t marker_offset = 0;
@@ -333,7 +330,7 @@ log_io_cursor_next(struct log_io_cursor *i)
(uintmax_t)i->good_offset);
say_debug("magic found at 0x%08jx", (uintmax_t)marker_offset);
- row = row_reader_v11(l->f, fiber->gc_pool);
+ row = row_reader_v11(l->f, rowlen);
if (row == ROW_EOF)
goto eof;
@@ -588,12 +585,16 @@ log_io_open(struct log_dir *dir, enum log_mode mode,
l->dir = dir;
l->is_inprogress = suffix == INPROGRESS;
if (mode == LOG_READ) {
- if (log_io_verify_meta(l, &errmsg) != 0)
+ if (log_io_verify_meta(l, &errmsg) != 0) {
+ errmsg = strerror(errno);
goto error;
+ }
} else { /* LOG_WRITE */
setvbuf(l->f, NULL, _IONBF, 0);
- if (log_io_write_header(l) != 0)
+ if (log_io_write_header(l) != 0) {
+ errmsg = strerror(errno);
goto error;
+ }
}
return l;
error:
@@ -608,7 +609,7 @@ log_io_open(struct log_dir *dir, enum log_mode mode,
}
struct log_io *
-log_io_open_for_read(struct log_dir *dir, i64 lsn, enum log_suffix suffix)
+log_io_open_for_read(struct log_dir *dir, int64_t lsn, enum log_suffix suffix)
{
assert(lsn != 0);
@@ -622,7 +623,7 @@ log_io_open_for_read(struct log_dir *dir, i64 lsn, enum log_suffix suffix)
* and sets errno.
*/
struct log_io *
-log_io_open_for_write(struct log_dir *dir, i64 lsn, enum log_suffix suffix)
+log_io_open_for_write(struct log_dir *dir, int64_t lsn, enum log_suffix suffix)
{
char *filename;
FILE *f;
diff --git a/src/lua/init.cc b/src/lua/init.cc
index 3b6265bb7f60fddb893c1e51c0d99a1386656e21..6892af4b491e76bb23c406f38d5b899c100f08b8 100644
--- a/src/lua/init.cc
+++ b/src/lua/init.cc
@@ -191,7 +191,7 @@ lbox_time(struct lua_State *L)
static int
lbox_time64(struct lua_State *L)
{
- luaL_pushnumber64(L, (u64) ( ev_now() * 1000000 + 0.5 ) );
+ luaL_pushnumber64(L, (uint64_t) ( ev_now() * 1000000 + 0.5 ) );
return 1;
}
diff --git a/src/lua/stat.cc b/src/lua/stat.cc
index 5fdfe919d1e0ee0e7b7aa0de02576734340f1397..04078ae58c6aa6525dfd67271917576deef2951b 100644
--- a/src/lua/stat.cc
+++ b/src/lua/stat.cc
@@ -39,7 +39,7 @@ extern "C" {
} /* extern "C" */
static void
-fill_stat_item(struct lua_State *L, int rps, i64 total)
+fill_stat_item(struct lua_State *L, int rps, int64_t total)
{
lua_pushstring(L, "rps");
lua_pushnumber(L, rps);
@@ -51,7 +51,7 @@ fill_stat_item(struct lua_State *L, int rps, i64 total)
}
static int
-set_stat_item(const char *name, int rps, i64 total, void *cb_ctx)
+set_stat_item(const char *name, int rps, int64_t total, void *cb_ctx)
{
struct lua_State *L = (struct lua_State *) cb_ctx;
@@ -70,7 +70,7 @@ set_stat_item(const char *name, int rps, i64 total, void *cb_ctx)
* box.stats.DELETE.
*/
static int
-seek_stat_item(const char *name, int rps, i64 total, void *cb_ctx)
+seek_stat_item(const char *name, int rps, int64_t total, void *cb_ctx)
{
struct lua_State *L = (struct lua_State *) cb_ctx;
if (strcmp(name, lua_tostring(L, -1)) != 0)
diff --git a/src/memcached-grammar.cc b/src/memcached-grammar.cc
index a4f5c6e3065cb6c0f09b5a17dbc42f6d313fd72f..6012b829a50758f6cf0f14aa177b77e0aee954ce 100644
--- a/src/memcached-grammar.cc
+++ b/src/memcached-grammar.cc
@@ -51,8 +51,8 @@ memcached_dispatch(struct ev_io *coio, struct iobuf *iobuf)
const char *key;
bool append, show_cas;
int incr_sign;
- u64 cas, incr;
- u32 flags, exptime, bytes;
+ uint64_t cas, incr;
+ uint32_t flags, exptime, bytes;
bool noreply = false;
char *data = NULL;
bool done = false;
@@ -716,7 +716,7 @@ case 12:
struct tbuf *b;
const char *field;
uint32_t field_len;
- u64 value;
+ uint64_t value;
key = tbuf_read_field(keys);
struct tuple *tuple = memcached_find(key);
@@ -780,7 +780,7 @@ case 12:
struct tbuf *b;
const char *field;
uint32_t field_len;
- u64 value;
+ uint64_t value;
key = tbuf_read_field(keys);
struct tuple *tuple = memcached_find(key);
@@ -846,7 +846,7 @@ case 12:
struct tbuf *b;
const char *field;
uint32_t field_len;
- u64 value;
+ uint64_t value;
key = tbuf_read_field(keys);
struct tuple *tuple = memcached_find(key);
diff --git a/src/memcached-grammar.rl b/src/memcached-grammar.rl
index 25da667cdc5910ff24559b75c0c05052555f2188..d1cd7226fc8f1504097c395020eabb5e3b5ca3a0 100644
--- a/src/memcached-grammar.rl
+++ b/src/memcached-grammar.rl
@@ -42,8 +42,8 @@ memcached_dispatch(struct ev_io *coio, struct iobuf *iobuf)
const char *key;
bool append, show_cas;
int incr_sign;
- u64 cas, incr;
- u32 flags, exptime, bytes;
+ uint64_t cas, incr;
+ uint32_t flags, exptime, bytes;
bool noreply = false;
char *data = NULL;
bool done = false;
@@ -125,7 +125,7 @@ memcached_dispatch(struct ev_io *coio, struct iobuf *iobuf)
struct tbuf *b;
const char *field;
uint32_t field_len;
- u64 value;
+ uint64_t value;
key = tbuf_read_field(keys);
struct tuple *tuple = memcached_find(key);
diff --git a/src/memcached.cc b/src/memcached.cc
index ea9931862ac147ea3cd33e8fdbee87fae5308ecb..5494b5862b87f3790199249b82fada07641c0c6e 100644
--- a/src/memcached.cc
+++ b/src/memcached.cc
@@ -67,17 +67,17 @@ static struct iterator *memcached_it;
<key, meta, data> */
struct meta {
- u32 exptime;
- u32 flags;
- u64 cas;
+ uint32_t exptime;
+ uint32_t flags;
+ uint64_t cas;
} __packed__;
-static u64
+static uint64_t
memcached_natoq(const char *start, const char *end)
{
- u64 num = 0;
+ uint64_t num = 0;
while (start < end) {
- u8 code = *start++;
+ uint8_t code = *start++;
num = num * 10 + (code - '0');
}
return num;
@@ -87,14 +87,14 @@ void
tbuf_append_field(struct tbuf *b, const char *f)
{
const char *begin = f;
- u32 size = load_varint32(&f);
+ uint32_t size = load_varint32(&f);
tbuf_append(b, begin, f - begin + size);
}
void
-tbuf_store_field(struct tbuf *b, const char *field, u32 len)
+tbuf_store_field(struct tbuf *b, const char *field, uint32_t len)
{
- char buf[sizeof(u32)+1];
+ char buf[sizeof(uint32_t)+1];
char *bufend = pack_varint32(buf, len);
tbuf_append(b, buf, bufend - buf);
tbuf_append(b, field, len);
@@ -108,7 +108,7 @@ const char *
tbuf_read_field(struct tbuf *buf)
{
const char *field = buf->data;
- u32 field_len = pick_varint32((const char **) &buf->data,
+ uint32_t field_len = pick_varint32((const char **) &buf->data,
buf->data + buf->size);
if (buf->data + field_len > field + buf->size)
tnt_raise(IllegalParams, "packet too short (expected a field)");
@@ -119,17 +119,17 @@ tbuf_read_field(struct tbuf *buf)
}
static void
-memcached_store(const char *key, u32 exptime, u32 flags, u32 bytes,
+memcached_store(const char *key, uint32_t exptime, uint32_t flags, uint32_t bytes,
const char *data)
{
- u32 box_flags = 0;
- u32 field_count = 4;
- static u64 cas = 42;
+ uint32_t box_flags = 0;
+ uint32_t field_count = 4;
+ static uint64_t cas = 42;
struct meta m;
struct tbuf *req = tbuf_new(fiber->gc_pool);
- tbuf_append(req, &cfg.memcached_space, sizeof(u32));
+ tbuf_append(req, &cfg.memcached_space, sizeof(uint32_t));
tbuf_append(req, &box_flags, sizeof(box_flags));
tbuf_append(req, &field_count, sizeof(field_count));
@@ -153,22 +153,22 @@ memcached_store(const char *key, u32 exptime, u32 flags, u32 bytes,
* Use a box dispatch wrapper which handles correctly
* read-only/read-write modes.
*/
- box_process(&port_null, REPLACE, req->data, req->size);
+ box_process(&null_port, REPLACE, req->data, req->size);
}
static void
memcached_delete(const char *key)
{
- u32 key_len = 1;
- u32 box_flags = 0;
+ uint32_t key_len = 1;
+ uint32_t box_flags = 0;
struct tbuf *req = tbuf_new(fiber->gc_pool);
- tbuf_append(req, &cfg.memcached_space, sizeof(u32));
+ tbuf_append(req, &cfg.memcached_space, sizeof(uint32_t));
tbuf_append(req, &box_flags, sizeof(box_flags));
tbuf_append(req, &key_len, sizeof(key_len));
tbuf_append_field(req, key);
- box_process(&port_null, DELETE, req->data, req->size);
+ box_process(&null_port, DELETE, req->data, req->size);
}
static struct tuple *
@@ -194,7 +194,7 @@ memcached_is_expired(struct tuple *tuple)
}
static bool
-memcached_is_numeric(const char *field, u32 value_len)
+memcached_is_numeric(const char *field, uint32_t value_len)
{
for (int i = 0; i < value_len; i++)
if (*(field + i) < '0' || '9' < *(field + i))
@@ -203,21 +203,21 @@ memcached_is_numeric(const char *field, u32 value_len)
}
static struct stats {
- u64 total_items;
- u32 curr_connections;
- u32 total_connections;
- u64 cmd_get;
- u64 cmd_set;
- u64 get_hits;
- u64 get_misses;
- u64 evictions;
- u64 bytes_read;
- u64 bytes_written;
+ uint64_t total_items;
+ uint32_t curr_connections;
+ uint32_t total_connections;
+ uint64_t cmd_get;
+ uint64_t cmd_set;
+ uint64_t get_hits;
+ uint64_t get_misses;
+ uint64_t evictions;
+ uint64_t bytes_read;
+ uint64_t bytes_written;
} stats;
struct salloc_stat_memcached_cb_ctx {
- i64 bytes_used;
- i64 items;
+ int64_t bytes_used;
+ int64_t items;
};
static int
@@ -239,9 +239,9 @@ memcached_print_stats(struct obuf *out)
memstats.bytes_used = memstats.items = 0;
salloc_stat(salloc_stat_memcached_cb, NULL, &memstats);
- tbuf_printf(buf, "STAT pid %" PRIu32 "\r\n", (u32)getpid());
- tbuf_printf(buf, "STAT uptime %" PRIu32 "\r\n", (u32)tarantool_uptime());
- tbuf_printf(buf, "STAT time %" PRIu32 "\r\n", (u32)ev_now());
+ tbuf_printf(buf, "STAT pid %" PRIu32 "\r\n", (uint32_t)getpid());
+ tbuf_printf(buf, "STAT uptime %" PRIu32 "\r\n", (uint32_t)tarantool_uptime());
+ tbuf_printf(buf, "STAT time %" PRIu32 "\r\n", (uint32_t)ev_now());
tbuf_printf(buf, "STAT version 1.2.5 (tarantool/box)\r\n");
tbuf_printf(buf, "STAT pointer_size %" PRI_SZ "\r\n", sizeof(void *)*8);
tbuf_printf(buf, "STAT curr_items %" PRIu64 "\r\n", memstats.items);
@@ -257,7 +257,7 @@ memcached_print_stats(struct obuf *out)
tbuf_printf(buf, "STAT evictions %" PRIu64 "\r\n", stats.evictions);
tbuf_printf(buf, "STAT bytes_read %" PRIu64 "\r\n", stats.bytes_read);
tbuf_printf(buf, "STAT bytes_written %" PRIu64 "\r\n", stats.bytes_written);
- tbuf_printf(buf, "STAT limit_maxbytes %" PRIu64 "\r\n", (u64)(cfg.slab_alloc_arena * (1 << 30)));
+ tbuf_printf(buf, "STAT limit_maxbytes %" PRIu64 "\r\n", (uint64_t)(cfg.slab_alloc_arena * (1 << 30)));
tbuf_printf(buf, "STAT threads 1\r\n");
tbuf_printf(buf, "END\r\n");
obuf_dup(out, buf->data, buf->size);
@@ -274,9 +274,9 @@ void memcached_get(struct obuf *out, size_t keys_count, struct tbuf *keys,
const struct meta *m;
const char *value;
const char *suffix;
- u32 key_len;
- u32 value_len;
- u32 suffix_len;
+ uint32_t key_len;
+ uint32_t value_len;
+ uint32_t suffix_len;
const char *key = tbuf_read_field(keys);
tuple = memcached_find(key);
@@ -509,7 +509,7 @@ memcached_space_init()
key_def->type = HASH;
key_def->parts = (struct key_part *) malloc(sizeof(struct key_part));
- key_def->cmp_order = (u32 *) malloc(sizeof(u32));
+ key_def->cmp_order = (uint32_t *) malloc(sizeof(uint32_t));
if (key_def->parts == NULL || key_def->cmp_order == NULL)
panic("out of memory when configuring memcached_space");
diff --git a/src/palloc.cc b/src/palloc.cc
index c1b009eca7201dde58b1d5f9541849bb8ae3f9ea..31fb4355d142881671b7e46623904f270641cad1 100644
--- a/src/palloc.cc
+++ b/src/palloc.cc
@@ -57,7 +57,7 @@ SLIST_HEAD(chunk_list_head, chunk);
struct chunk_class {
int i;
- u32 allocated_size;
+ uint32_t allocated_size;
int chunks_count;
struct chunk_list_head chunks;
TAILQ_ENTRY(chunk_class) link;
@@ -455,8 +455,8 @@ palloc_stat(struct tbuf *buf)
", free_chunks: %- 6i, busy_chunks: %- 6i }" CRLF, clazz->allocated_size,
free_chunks, clazz->chunks_count - free_chunks);
}
- u64 palloc_total = 0;
- u64 palloc_used = 0;
+ uint64_t palloc_total = 0;
+ uint64_t palloc_used = 0;
SLIST_FOREACH(pool, &pools, link) {
SLIST_FOREACH(chunk, &pool->chunks, busy_link) {
palloc_total += chunk->size;
diff --git a/src/recovery.cc b/src/recovery.cc
index ae76f960855668fcc66f70d522e7e725a0e26687..4e85b95ddcb696593a88a7c77cbd541bf94150f7 100644
--- a/src/recovery.cc
+++ b/src/recovery.cc
@@ -100,7 +100,7 @@
struct recovery_state *recovery_state;
-static const u64 snapshot_cookie = 0;
+static const uint64_t snapshot_cookie = 0;
const char *wal_mode_STRS[] = { "none", "write", "fsync", "fsync_delay", NULL };
@@ -292,7 +292,7 @@ recover_snap(struct recovery_state *r)
say_info("recovery start");
struct log_io *snap;
- i64 lsn;
+ int64_t lsn;
lsn = greatest_lsn(r->snap_dir);
if (lsn <= 0) {
@@ -309,9 +309,10 @@ recover_snap(struct recovery_state *r)
log_io_cursor_open(&i, snap);
- struct tbuf *row;
- while ((row = log_io_cursor_next(&i))) {
- if (r->row_handler(r->row_handler_param, row) < 0) {
+ const char *row;
+ uint32_t rowlen;
+ while ((row = log_io_cursor_next(&i, &rowlen))) {
+ if (r->row_handler(r->row_handler_param, row, rowlen) < 0) {
say_error("can't apply row");
if (snap->dir->panic_if_error)
break;
@@ -349,9 +350,10 @@ recover_wal(struct recovery_state *r, struct log_io *l)
log_io_cursor_open(&i, l);
- struct tbuf *row = NULL;
- while ((row = log_io_cursor_next(&i))) {
- i64 lsn = header_v11(row)->lsn;
+ const char *row;
+ uint32_t rowlen;
+ while ((row = log_io_cursor_next(&i, &rowlen))) {
+ int64_t lsn = header_v11(row)->lsn;
if (lsn <= r->confirmed_lsn) {
say_debug("skipping too young row");
continue;
@@ -360,7 +362,7 @@ recover_wal(struct recovery_state *r, struct log_io *l)
* After handler(row) returned, row may be
* modified, do not use it.
*/
- if (r->row_handler(r->row_handler_param, row) < 0) {
+ if (r->row_handler(r->row_handler_param, row, rowlen) < 0) {
say_error("can't apply row");
if (l->dir->panic_if_error)
goto end;
@@ -385,7 +387,7 @@ recover_remaining_wals(struct recovery_state *r)
{
int result = 0;
struct log_io *next_wal;
- i64 current_lsn, wal_greatest_lsn;
+ int64_t current_lsn, wal_greatest_lsn;
size_t rows_before;
FILE *f;
char *filename;
@@ -508,8 +510,8 @@ recover_remaining_wals(struct recovery_state *r)
void
recover_existing_wals(struct recovery_state *r)
{
- i64 next_lsn = r->confirmed_lsn + 1;
- i64 wal_lsn = find_including_file(r->wal_dir, next_lsn);
+ int64_t next_lsn = r->confirmed_lsn + 1;
+ int64_t wal_lsn = find_including_file(r->wal_dir, next_lsn);
if (wal_lsn <= 0) {
/* No WALs to recover from. */
goto out;
@@ -941,7 +943,8 @@ wal_writer_pop(struct wal_writer *writer, struct wal_fifo *input)
* @return 0 in case of success, -1 on error.
*/
static int
-wal_opt_rotate(struct log_io **wal, int rows_per_wal, struct log_dir *dir, u64 lsn)
+wal_opt_rotate(struct log_io **wal, int rows_per_wal, struct log_dir *dir,
+ int64_t lsn)
{
struct log_io *l = *wal, *wal_to_close = NULL;
@@ -1103,8 +1106,8 @@ wal_writer_thread(void *worker_args)
* to be written to disk and wait until this task is completed.
*/
int
-wal_write(struct recovery_state *r, i64 lsn, u64 cookie,
- u16 op, const char *row, u32 row_len)
+wal_write(struct recovery_state *r, int64_t lsn, uint64_t cookie,
+ uint16_t op, const char *row, uint32_t row_len)
{
say_debug("wal_write lsn=%" PRIi64, lsn);
ERROR_INJECT_RETURN(ERRINJ_WAL_IO);
@@ -1268,9 +1271,10 @@ read_log(const char *filename,
struct log_io_cursor i;
log_io_cursor_open(&i, l);
- struct tbuf *row;
- while ((row = log_io_cursor_next(&i)))
- h(param, row);
+ const char *row;
+ uint32_t rowlen;
+ while ((row = log_io_cursor_next(&i, &rowlen)))
+ h(param, row, rowlen);
log_io_cursor_close(&i);
log_io_close(&l);
diff --git a/src/replica.cc b/src/replica.cc
index 753c82be2a074855b700156b2511c4d1156610f3..b4acbb7744c372eab532d7efd5e29a35d3005e4b 100644
--- a/src/replica.cc
+++ b/src/replica.cc
@@ -38,10 +38,10 @@
#include "coio_buf.h"
static void
-remote_apply_row(struct recovery_state *r, struct tbuf *row);
+remote_apply_row(struct recovery_state *r, const char *row, uint32_t rowlne);
-static struct tbuf
-remote_read_row(struct ev_io *coio, struct iobuf *iobuf)
+const char *
+remote_read_row(struct ev_io *coio, struct iobuf *iobuf, uint32_t *rowlen)
{
struct ibuf *in = &iobuf->in;
ssize_t to_read = sizeof(struct header_v11) - ibuf_size(in);
@@ -51,26 +51,22 @@ remote_read_row(struct ev_io *coio, struct iobuf *iobuf)
coio_breadn(coio, in, to_read);
}
- ssize_t request_len = ((struct header_v11 *)in->pos)->len
+ ssize_t request_len = header_v11(in->pos)->len
+ sizeof(struct header_v11);
to_read = request_len - ibuf_size(in);
if (to_read > 0)
coio_breadn(coio, in, to_read);
- struct tbuf row;
- row.size = (uint32_t) request_len;
- row.capacity = (uint32_t) request_len;
- row.data = in->pos;
- row.pool = fiber->gc_pool;
-
+ const char *row = in->pos;
+ *rowlen = request_len;
in->pos += request_len;
return row;
}
static void
remote_connect(struct ev_io *coio, struct sockaddr_in *remote_addr,
- i64 initial_lsn, const char **err)
+ int64_t initial_lsn, const char **err)
{
evio_socket(coio, AF_INET, SOCK_STREAM, IPPROTO_TCP);
@@ -80,7 +76,7 @@ remote_connect(struct ev_io *coio, struct sockaddr_in *remote_addr,
*err = "can't write version";
coio_write(coio, &initial_lsn, sizeof(initial_lsn));
- u32 version;
+ uint32_t version;
*err = "can't read version";
coio_readn(coio, &version, sizeof(version));
*err = NULL;
@@ -114,14 +110,15 @@ pull_from_remote(va_list ap)
warning_said = false;
}
err = "can't read row";
- struct tbuf row = remote_read_row(&coio, iobuf);
+ uint32_t rowlen;
+ const char *row = remote_read_row(&coio, iobuf, &rowlen);
fiber_setcancellable(false);
err = NULL;
- r->remote->recovery_lag = ev_now() - header_v11(&row)->tm;
+ r->remote->recovery_lag = ev_now() - header_v11(row)->tm;
r->remote->recovery_last_update_tstamp = ev_now();
- remote_apply_row(r, &row);
+ remote_apply_row(r, row, rowlen);
iobuf_gc(iobuf);
fiber_gc();
@@ -144,13 +141,13 @@ pull_from_remote(va_list ap)
}
static void
-remote_apply_row(struct recovery_state *r, struct tbuf *row)
+remote_apply_row(struct recovery_state *r, const char *row, uint32_t rowlen)
{
- i64 lsn = header_v11(row)->lsn;
+ int64_t lsn = header_v11(row)->lsn;
- assert(*(uint16_t*)(row->data + sizeof(struct header_v11)) == XLOG);
+ assert(*(uint16_t*)(row + sizeof(struct header_v11)) == XLOG);
- if (r->row_handler(r->row_handler_param, row) < 0)
+ if (r->row_handler(r->row_handler_param, row, rowlen) < 0)
panic("replication failure: can't apply row");
set_lsn(r, lsn);
diff --git a/src/replication.cc b/src/replication.cc
index f57a1eb86f6e43d1ddc98c6195439ee8695fa6da..c7173bc5d884ddbbb33f5dbaab7efb85fcf7d95b 100644
--- a/src/replication.cc
+++ b/src/replication.cc
@@ -490,8 +490,8 @@ spawner_shutdown_children()
/* We'll wait for children no longer than 5 sec. */
alarm(5);
- say_info("sending signal %d to %" PRIu32 " children", kill_signo,
- (u32) spawner.child_count);
+ say_info("sending signal %d to %d children", kill_signo,
+ (int) spawner.child_count);
kill(0, kill_signo);
@@ -539,7 +539,7 @@ static void
replication_relay_recv(struct ev_io *w, int __attribute__((unused)) revents)
{
int client_sock = (int) (intptr_t) w->data;
- u8 data;
+ uint8_t data;
int rc = recv(client_sock, &data, sizeof(data), 0);
@@ -556,13 +556,12 @@ replication_relay_recv(struct ev_io *w, int __attribute__((unused)) revents)
/** Send a single row to the client. */
static int
-replication_relay_send_row(void *param, struct tbuf *t)
+replication_relay_send_row(void *param, const char *row, uint32_t rowlen)
{
int client_sock = (int) (intptr_t) param;
- const char *data = t->data;
- ssize_t bytes, len = t->size;
+ ssize_t bytes, len = rowlen;
while (len > 0) {
- bytes = write(client_sock, data, len);
+ bytes = write(client_sock, row, len);
if (bytes < 0) {
if (errno == EPIPE) {
/* socket closed on opposite site */
@@ -571,10 +570,9 @@ replication_relay_send_row(void *param, struct tbuf *t)
panic_syserror("write");
}
len -= bytes;
- data += bytes;
+ row += bytes;
}
- say_debug("send row: %" PRIu32 " bytes %s", t->size, tbuf_to_hex(t));
return 0;
shutdown_handler:
say_info("the client has closed its replication socket, exiting");
@@ -588,8 +586,7 @@ replication_relay_loop(int client_sock)
{
char name[FIBER_NAME_MAXLEN];
struct sigaction sa;
- struct tbuf *ver;
- i64 lsn;
+ int64_t lsn;
ssize_t r;
/* Set process title and fiber name.
@@ -629,9 +626,9 @@ replication_relay_loop(int client_sock)
}
say_info("starting replication from lsn: %" PRIi64, lsn);
- ver = tbuf_new(fiber->gc_pool);
- tbuf_append(ver, &default_version, sizeof(default_version));
- replication_relay_send_row((void *)(intptr_t) client_sock, ver);
+ replication_relay_send_row((void *)(intptr_t) client_sock,
+ (const char *) &default_version,
+ sizeof(default_version));
/* init libev events handlers */
ev_default_loop(0);
diff --git a/src/stat.cc b/src/stat.cc
index ad26f2a6e1b33227a9c1f7975ed9e287be175424..61148743cfd673648aa18bd38710bef5e35800d1 100644
--- a/src/stat.cc
+++ b/src/stat.cc
@@ -40,7 +40,7 @@ static ev_timer timer;
struct stats {
const char *name;
- i64 value[SECS + 1];
+ int64_t value[SECS + 1];
} *stats = NULL;
static int stats_size = 0;
static int stats_max = 0;
@@ -87,7 +87,7 @@ stat_register(const char **name, size_t max_idx)
}
void
-stat_collect(int base, int name, i64 value)
+stat_collect(int base, int name, int64_t value)
{
stats[base + name].value[0] += value;
stats[base + name].value[SECS] += value;
diff --git a/src/tarantool.cc b/src/tarantool.cc
index ed14d00fbee87208eb168a95029eee8eb0ffb1d2..22c8766928cd01244c674fa691ae51b7ded2d1d8 100644
--- a/src/tarantool.cc
+++ b/src/tarantool.cc
@@ -123,11 +123,11 @@ title(const char *fmt, ...)
set_proc_title(buf);
}
-static i32
-load_cfg(struct tarantool_cfg *conf, i32 check_rdonly)
+static int
+load_cfg(struct tarantool_cfg *conf, int32_t check_rdonly)
{
FILE *f;
- i32 n_accepted, n_skipped, n_ignored;
+ int32_t n_accepted, n_skipped, n_ignored;
tbuf_reset(cfg_out);
@@ -210,7 +210,7 @@ core_reload_config(const struct tarantool_cfg *old_conf,
return 0;
}
-i32
+int
reload_cfg(struct tbuf *out)
{
static struct mutex *mutex = NULL;
diff --git a/test/.gitattributes b/test/.gitattributes
new file mode 100644
index 0000000000000000000000000000000000000000..120b07e8db944c0d3dd22357e61acba1622d6666
--- /dev/null
+++ b/test/.gitattributes
@@ -0,0 +1,2 @@
+*.result diff merge=text
+
diff --git a/test/big/bitset.result b/test/big/bitset.result
index e0bf2c192b3253a4ccf3ef604777c443ab1fd476..0ee6d3b8f78be6c6666798997a2e222491b1ec85 100644
--- a/test/big/bitset.result
+++ b/test/big/bitset.result
@@ -380,7 +380,7 @@ sorted output
...
lua dump(box.index.BITS_ALL_SET, 4294967296)
---
-sorted output
+error: 'Supplied key field type does not match index type: expected u32'
...
#-----------------------------------------------------------------------------#
@@ -822,135 +822,7 @@ $ 128$
...
lua dump(box.index.BITS_ALL_NOT_SET, 4294967296)
---
-sorted output
-$ 1$
-$ 2$
-$ 3$
-$ 4$
-$ 5$
-$ 6$
-$ 7$
-$ 8$
-$ 9$
-$ 10$
-$ 11$
-$ 12$
-$ 13$
-$ 14$
-$ 15$
-$ 16$
-$ 17$
-$ 18$
-$ 19$
-$ 20$
-$ 21$
-$ 22$
-$ 23$
-$ 24$
-$ 25$
-$ 26$
-$ 27$
-$ 28$
-$ 29$
-$ 30$
-$ 31$
-$ 32$
-$ 33$
-$ 34$
-$ 35$
-$ 36$
-$ 37$
-$ 38$
-$ 39$
-$ 40$
-$ 41$
-$ 42$
-$ 43$
-$ 44$
-$ 45$
-$ 46$
-$ 47$
-$ 48$
-$ 49$
-$ 50$
-$ 51$
-$ 52$
-$ 53$
-$ 54$
-$ 55$
-$ 56$
-$ 57$
-$ 58$
-$ 59$
-$ 60$
-$ 61$
-$ 62$
-$ 63$
-$ 64$
-$ 65$
-$ 66$
-$ 67$
-$ 68$
-$ 69$
-$ 70$
-$ 71$
-$ 72$
-$ 73$
-$ 74$
-$ 75$
-$ 76$
-$ 77$
-$ 78$
-$ 79$
-$ 80$
-$ 81$
-$ 82$
-$ 83$
-$ 84$
-$ 85$
-$ 86$
-$ 87$
-$ 88$
-$ 89$
-$ 90$
-$ 91$
-$ 92$
-$ 93$
-$ 94$
-$ 95$
-$ 96$
-$ 97$
-$ 98$
-$ 99$
-$ 100$
-$ 101$
-$ 102$
-$ 103$
-$ 104$
-$ 105$
-$ 106$
-$ 107$
-$ 108$
-$ 109$
-$ 110$
-$ 111$
-$ 112$
-$ 113$
-$ 114$
-$ 115$
-$ 116$
-$ 117$
-$ 118$
-$ 119$
-$ 120$
-$ 121$
-$ 122$
-$ 123$
-$ 124$
-$ 125$
-$ 126$
-$ 127$
-$ 128$
+error: 'Supplied key field type does not match index type: expected u32'
...
#-----------------------------------------------------------------------------#
@@ -1161,7 +1033,7 @@ $ 128$
...
lua dump(box.index.BITS_ANY_SET, 4294967296)
---
-sorted output
+error: 'Supplied key field type does not match index type: expected u32'
...
#-----------------------------------------------------------------------------#
diff --git a/test/big/hash.result b/test/big/hash.result
index 6099e94a9c3c51624d3f20c588b009316310a63f..6ed4f4de56e5b290a058e9a90c02ef66e1793578 100644
--- a/test/big/hash.result
+++ b/test/big/hash.result
@@ -32,7 +32,7 @@ lua box.space[10]:insert(3, 'value1 v1.0', 'value2 v1.0')
lua box.space[10]:insert('invalid key', 'value1 v1.0', 'value2 v1.0')
---
-error: 'Supplied key field type does not match index type: expected u32'
+error: 'Supplied key field type does not match index type: expected NUM'
...
#-----------------------------------------------------------------------------#
@@ -59,7 +59,7 @@ lua box.space[10]:replace(2, 'value1 v1.43', 'value2 1.92')
lua box.space[10]:replace('invalid key', 'value1 v1.0', 'value2 v1.0')
---
-error: 'Supplied key field type does not match index type: expected u32'
+error: 'Supplied key field type does not match index type: expected NUM'
...
#-----------------------------------------------------------------------------#
@@ -156,28 +156,44 @@ error: 'Invalid key part count in an exact match (expected 1, got 2)'
# Insert valid fieds
-lua box.space[11]:insert('00000000', 'value1 v1.0', 'value2 v1.0')
+lua box.space[11]:insert(0ULL, 'value1 v1.0', 'value2 v1.0')
---
- - 3472328296227680304: {'value1 v1.0', 'value2 v1.0'}
+ - 0: {'value1 v1.0', 'value2 v1.0'}
...
-lua box.space[11]:insert('00000001', 'value1 v1.0', 'value2 v1.0')
+lua box.space[11]:insert(1ULL, 'value1 v1.0', 'value2 v1.0')
---
- - 3544385890265608240: {'value1 v1.0', 'value2 v1.0'}
+ - 1: {'value1 v1.0', 'value2 v1.0'}
...
-lua box.space[11]:insert('00000002', 'value1 v1.0', 'value2 v1.0')
+lua box.space[11]:insert(2ULL, 'value1 v1.0', 'value2 v1.0')
---
- - 3616443484303536176: {'value1 v1.0', 'value2 v1.0'}
+ - 2: {'value1 v1.0', 'value2 v1.0'}
...
-lua box.space[11]:insert('00000003', 'value1 v1.0', 'value2 v1.0')
+lua box.space[11]:insert(3ULL, 'value1 v1.0', 'value2 v1.0')
---
- - 3688501078341464112: {'value1 v1.0', 'value2 v1.0'}
+ - 3: {'value1 v1.0', 'value2 v1.0'}
...
# Insert invalid fields
+lua box.space[11]:insert(100, 'value1 v1.0', 'value2 v1.0')
+---
+error: 'Supplied key field type does not match index type: expected NUM64'
+...
+lua box.space[11]:insert(101, 'value1 v1.0', 'value2 v1.0')
+---
+error: 'Supplied key field type does not match index type: expected NUM64'
+...
+lua box.space[11]:insert(102, 'value1 v1.0', 'value2 v1.0')
+---
+error: 'Supplied key field type does not match index type: expected NUM64'
+...
+lua box.space[11]:insert(103, 'value1 v1.0', 'value2 v1.0')
+---
+error: 'Supplied key field type does not match index type: expected NUM64'
+...
lua box.space[11]:insert('invalid key', 'value1 v1.0', 'value2 v1.0')
---
-error: 'Supplied key field type does not match index type: expected u64'
+error: 'Supplied key field type does not match index type: expected NUM64'
...
#-----------------------------------------------------------------------------#
@@ -187,24 +203,36 @@ error: 'Supplied key field type does not match index type: expected u64'
# Replace valid fieds
-lua box.space[11]:replace('00000003', 'value1 v1.31', 'value2 1.12')
+lua box.space[11]:replace(3ULL, 'value1 v1.31', 'value2 1.12')
---
- - 3688501078341464112: {'value1 v1.31', 'value2 1.12'}
+ - 3: {'value1 v1.31', 'value2 1.12'}
...
-lua box.space[11]:replace('00000001', 'value1 v1.32', 'value2 1.72')
+lua box.space[11]:replace(1ULL, 'value1 v1.32', 'value2 1.72')
---
- - 3544385890265608240: {'value1 v1.32', 'value2 1.72'}
+ - 1: {'value1 v1.32', 'value2 1.72'}
...
-lua box.space[11]:replace('00000002', 'value1 v1.43', 'value2 1.92')
+lua box.space[11]:replace(2ULL, 'value1 v1.43', 'value2 1.92')
---
- - 3616443484303536176: {'value1 v1.43', 'value2 1.92'}
+ - 2: {'value1 v1.43', 'value2 1.92'}
...
# Replace invalid fields
-lua box.space[10]:replace('invalid key', 'value1 v1.0', 'value2 v1.0')
+lua box.space[11]:replace(3, 'value1 v1.31', 'value2 1.12')
---
-error: 'Supplied key field type does not match index type: expected u32'
+error: 'Supplied key field type does not match index type: expected NUM64'
+...
+lua box.space[11]:replace(1, 'value1 v1.32', 'value2 1.72')
+---
+error: 'Supplied key field type does not match index type: expected NUM64'
+...
+lua box.space[11]:replace(2, 'value1 v1.43', 'value2 1.92')
+---
+error: 'Supplied key field type does not match index type: expected NUM64'
+...
+lua box.space[11]:replace('invalid key', 'value1 v1.0', 'value2 v1.0')
+---
+error: 'Supplied key field type does not match index type: expected NUM64'
...
#-----------------------------------------------------------------------------#
@@ -214,26 +242,51 @@ error: 'Supplied key field type does not match index type: expected u32'
# select by valid keys
-lua box.space[11]:select(0, '00000000')
+lua box.space[11]:select(0, 0ULL)
+---
+ - 0: {'value1 v1.0', 'value2 v1.0'}
+...
+lua box.space[11]:select(0, 1ULL)
+---
+ - 1: {'value1 v1.32', 'value2 1.72'}
+...
+lua box.space[11]:select(0, 2ULL)
+---
+ - 2: {'value1 v1.43', 'value2 1.92'}
+...
+lua box.space[11]:select(0, 3ULL)
+---
+ - 3: {'value1 v1.31', 'value2 1.12'}
+...
+lua box.space[11]:select(0, 4ULL)
+---
+...
+lua box.space[11]:select(0, 5ULL)
+---
+...
+
+# select by valid NUM keys
+
+lua box.space[11]:select(0, 0)
---
- - 3472328296227680304: {'value1 v1.0', 'value2 v1.0'}
+ - 0: {'value1 v1.0', 'value2 v1.0'}
...
-lua box.space[11]:select(0, '00000001')
+lua box.space[11]:select(0, 1)
---
- - 3544385890265608240: {'value1 v1.32', 'value2 1.72'}
+ - 1: {'value1 v1.32', 'value2 1.72'}
...
-lua box.space[11]:select(0, '00000002')
+lua box.space[11]:select(0, 2)
---
- - 3616443484303536176: {'value1 v1.43', 'value2 1.92'}
+ - 2: {'value1 v1.43', 'value2 1.92'}
...
-lua box.space[11]:select(0, '00000003')
+lua box.space[11]:select(0, 3)
---
- - 3688501078341464112: {'value1 v1.31', 'value2 1.12'}
+ - 3: {'value1 v1.31', 'value2 1.12'}
...
-lua box.space[11]:select(0, '00000004')
+lua box.space[11]:select(0, 4)
---
...
-lua box.space[11]:select(0, '00000005')
+lua box.space[11]:select(0, 5)
---
...
@@ -255,26 +308,67 @@ error: 'Invalid key part count (expected [0..1], got 2)'
# delete by valid keys
-lua box.space[11]:delete('00000000')
+lua box.space[11]:delete(0ULL)
---
- - 3472328296227680304: {'value1 v1.0', 'value2 v1.0'}
+ - 0: {'value1 v1.0', 'value2 v1.0'}
...
-lua box.space[11]:delete('00000001')
+lua box.space[11]:delete(1ULL)
---
- - 3544385890265608240: {'value1 v1.32', 'value2 1.72'}
+ - 1: {'value1 v1.32', 'value2 1.72'}
...
-lua box.space[11]:delete('00000002')
+lua box.space[11]:delete(2ULL)
---
- - 3616443484303536176: {'value1 v1.43', 'value2 1.92'}
+ - 2: {'value1 v1.43', 'value2 1.92'}
...
-lua box.space[11]:delete('00000003')
+lua box.space[11]:delete(3ULL)
---
- - 3688501078341464112: {'value1 v1.31', 'value2 1.12'}
+ - 3: {'value1 v1.31', 'value2 1.12'}
+...
+lua box.space[11]:delete(4ULL)
+---
+...
+lua box.space[11]:delete(5ULL)
+---
+...
+lua box.space[11]:insert(0ULL, 'value1 v1.0', 'value2 v1.0')
+---
+ - 0: {'value1 v1.0', 'value2 v1.0'}
+...
+lua box.space[11]:insert(1ULL, 'value1 v1.0', 'value2 v1.0')
+---
+ - 1: {'value1 v1.0', 'value2 v1.0'}
+...
+lua box.space[11]:insert(2ULL, 'value1 v1.0', 'value2 v1.0')
+---
+ - 2: {'value1 v1.0', 'value2 v1.0'}
+...
+lua box.space[11]:insert(3ULL, 'value1 v1.0', 'value2 v1.0')
+---
+ - 3: {'value1 v1.0', 'value2 v1.0'}
+...
+
+# delete by valid NUM keys
+
+lua box.space[11]:delete(0)
+---
+ - 0: {'value1 v1.0', 'value2 v1.0'}
+...
+lua box.space[11]:delete(1)
+---
+ - 1: {'value1 v1.0', 'value2 v1.0'}
+...
+lua box.space[11]:delete(2)
+---
+ - 2: {'value1 v1.0', 'value2 v1.0'}
+...
+lua box.space[11]:delete(3)
+---
+ - 3: {'value1 v1.0', 'value2 v1.0'}
...
-lua box.space[11]:delete('00000004')
+lua box.space[11]:delete(4)
---
...
-lua box.space[11]:delete('00000005')
+lua box.space[11]:delete(5)
---
...
diff --git a/test/big/hash.test b/test/big/hash.test
index 51c46574092d540d1b34acf510427594c2ee57da..79b510266fb3c45aa865205e710497c77712f985 100644
--- a/test/big/hash.test
+++ b/test/big/hash.test
@@ -107,17 +107,20 @@ print """
print """
# Insert valid fieds
"""
-exec admin "lua box.space[11]:insert('00000000', 'value1 v1.0', 'value2 v1.0')"
-exec admin "lua box.space[11]:insert('00000001', 'value1 v1.0', 'value2 v1.0')"
-exec admin "lua box.space[11]:insert('00000002', 'value1 v1.0', 'value2 v1.0')"
-exec admin "lua box.space[11]:insert('00000003', 'value1 v1.0', 'value2 v1.0')"
+exec admin "lua box.space[11]:insert(0ULL, 'value1 v1.0', 'value2 v1.0')"
+exec admin "lua box.space[11]:insert(1ULL, 'value1 v1.0', 'value2 v1.0')"
+exec admin "lua box.space[11]:insert(2ULL, 'value1 v1.0', 'value2 v1.0')"
+exec admin "lua box.space[11]:insert(3ULL, 'value1 v1.0', 'value2 v1.0')"
print """
# Insert invalid fields
"""
+exec admin "lua box.space[11]:insert(100, 'value1 v1.0', 'value2 v1.0')"
+exec admin "lua box.space[11]:insert(101, 'value1 v1.0', 'value2 v1.0')"
+exec admin "lua box.space[11]:insert(102, 'value1 v1.0', 'value2 v1.0')"
+exec admin "lua box.space[11]:insert(103, 'value1 v1.0', 'value2 v1.0')"
exec admin "lua box.space[11]:insert('invalid key', 'value1 v1.0', 'value2 v1.0')"
-
print """
#-----------------------------------------------------------------------------#
# 64-bit hash replace fields tests
@@ -127,15 +130,17 @@ print """
print """
# Replace valid fieds
"""
-exec admin "lua box.space[11]:replace('00000003', 'value1 v1.31', 'value2 1.12')"
-exec admin "lua box.space[11]:replace('00000001', 'value1 v1.32', 'value2 1.72')"
-exec admin "lua box.space[11]:replace('00000002', 'value1 v1.43', 'value2 1.92')"
+exec admin "lua box.space[11]:replace(3ULL, 'value1 v1.31', 'value2 1.12')"
+exec admin "lua box.space[11]:replace(1ULL, 'value1 v1.32', 'value2 1.72')"
+exec admin "lua box.space[11]:replace(2ULL, 'value1 v1.43', 'value2 1.92')"
print """
# Replace invalid fields
"""
-exec admin "lua box.space[10]:replace('invalid key', 'value1 v1.0', 'value2 v1.0')"
-
+exec admin "lua box.space[11]:replace(3, 'value1 v1.31', 'value2 1.12')"
+exec admin "lua box.space[11]:replace(1, 'value1 v1.32', 'value2 1.72')"
+exec admin "lua box.space[11]:replace(2, 'value1 v1.43', 'value2 1.92')"
+exec admin "lua box.space[11]:replace('invalid key', 'value1 v1.0', 'value2 v1.0')"
print """
#-----------------------------------------------------------------------------#
@@ -146,12 +151,22 @@ print """
print """
# select by valid keys
"""
-exec admin "lua box.space[11]:select(0, '00000000')"
-exec admin "lua box.space[11]:select(0, '00000001')"
-exec admin "lua box.space[11]:select(0, '00000002')"
-exec admin "lua box.space[11]:select(0, '00000003')"
-exec admin "lua box.space[11]:select(0, '00000004')"
-exec admin "lua box.space[11]:select(0, '00000005')"
+exec admin "lua box.space[11]:select(0, 0ULL)"
+exec admin "lua box.space[11]:select(0, 1ULL)"
+exec admin "lua box.space[11]:select(0, 2ULL)"
+exec admin "lua box.space[11]:select(0, 3ULL)"
+exec admin "lua box.space[11]:select(0, 4ULL)"
+exec admin "lua box.space[11]:select(0, 5ULL)"
+
+print """
+# select by valid NUM keys
+"""
+exec admin "lua box.space[11]:select(0, 0)"
+exec admin "lua box.space[11]:select(0, 1)"
+exec admin "lua box.space[11]:select(0, 2)"
+exec admin "lua box.space[11]:select(0, 3)"
+exec admin "lua box.space[11]:select(0, 4)"
+exec admin "lua box.space[11]:select(0, 5)"
print """
# select by invalid keys
@@ -159,7 +174,6 @@ print """
exec admin "lua box.space[11]:select(0, 'invalid key')"
exec admin "lua box.space[11]:select(0, '00000001', '00000002')"
-
print """
#-----------------------------------------------------------------------------#
# 64-bit hash delete fields test
@@ -169,12 +183,27 @@ print """
print """
# delete by valid keys
"""
-exec admin "lua box.space[11]:delete('00000000')"
-exec admin "lua box.space[11]:delete('00000001')"
-exec admin "lua box.space[11]:delete('00000002')"
-exec admin "lua box.space[11]:delete('00000003')"
-exec admin "lua box.space[11]:delete('00000004')"
-exec admin "lua box.space[11]:delete('00000005')"
+exec admin "lua box.space[11]:delete(0ULL)"
+exec admin "lua box.space[11]:delete(1ULL)"
+exec admin "lua box.space[11]:delete(2ULL)"
+exec admin "lua box.space[11]:delete(3ULL)"
+exec admin "lua box.space[11]:delete(4ULL)"
+exec admin "lua box.space[11]:delete(5ULL)"
+
+exec admin "lua box.space[11]:insert(0ULL, 'value1 v1.0', 'value2 v1.0')"
+exec admin "lua box.space[11]:insert(1ULL, 'value1 v1.0', 'value2 v1.0')"
+exec admin "lua box.space[11]:insert(2ULL, 'value1 v1.0', 'value2 v1.0')"
+exec admin "lua box.space[11]:insert(3ULL, 'value1 v1.0', 'value2 v1.0')"
+
+print """
+# delete by valid NUM keys
+"""
+exec admin "lua box.space[11]:delete(0)"
+exec admin "lua box.space[11]:delete(1)"
+exec admin "lua box.space[11]:delete(2)"
+exec admin "lua box.space[11]:delete(3)"
+exec admin "lua box.space[11]:delete(4)"
+exec admin "lua box.space[11]:delete(5)"
print """
# delete by invalid keys
diff --git a/test/big/hash_multipart.result b/test/big/hash_multipart.result
new file mode 100644
index 0000000000000000000000000000000000000000..9c2a07d05c84664fa7db991ebaa02cf16bbca93a
--- /dev/null
+++ b/test/big/hash_multipart.result
@@ -0,0 +1,73 @@
+insert into t27 values (0, 'foo', 0, '', 1)
+Insert OK, 1 row affected
+insert into t27 values (0, 'foo', 1, '', 1)
+Insert OK, 1 row affected
+insert into t27 values (1, 'foo', 0, '', 2)
+Insert OK, 1 row affected
+insert into t27 values (1, 'foo', 1, '', 2)
+Insert OK, 1 row affected
+insert into t27 values (0, 'bar', 0, '', 3)
+Insert OK, 1 row affected
+insert into t27 values (0, 'bar', 1, '', 3)
+Insert OK, 1 row affected
+insert into t27 values (1, 'bar', 0, '', 4)
+Insert OK, 1 row affected
+insert into t27 values (1, 'bar', 1, '', 4)
+Insert OK, 1 row affected
+insert into t27 values (1, 'bar', 1, '', 5)
+An error occurred: ER_TUPLE_FOUND, 'Duplicate key exists in unique index 0'
+lua function box.select_all(space) space = tonumber(space) local result = {} for k, v in box.space[space]:pairs() do table.insert(result, v) end return unpack(result) end
+---
+...
+call box.select_all('27')
+Found 8 tuples:
+[0, 'bar', 0, '', 3]
+[0, 'bar', 1, '', 3]
+[0, 'foo', 0, '', 1]
+[0, 'foo', 1, '', 1]
+[1, 'bar', 0, '', 4]
+[1, 'bar', 1, '', 4]
+[1, 'foo', 0, '', 2]
+[1, 'foo', 1, '', 2]
+lua box.select(27, 0, 1, 'foo', 0)
+---
+ - 1: {'foo', 0, '', 2}
+...
+lua box.select(27, 0, 1, 'bar', 0)
+---
+ - 1: {'bar', 0, '', 4}
+...
+lua box.select(27, 0, 1, 'foo')
+---
+error: 'Invalid key part count in an exact match (expected 3, got 2)'
+...
+lua box.select(27, 0, 1, 'foo', 0, 0)
+---
+error: 'Invalid key part count (expected [0..3], got 4)'
+...
+lua box.select(27, 0, 1, 'foo', 'baz')
+---
+error: 'Supplied key field type does not match index type: expected u32'
+...
+lua box.select(27, 1, 1, 4)
+---
+ - 1: {'bar', 1, '', 4}
+...
+lua box.select(27, 1, 1, 5)
+---
+...
+lua box.select(27, 1, 1)
+---
+error: 'Invalid key part count in an exact match (expected 2, got 1)'
+...
+lua box.select(27, 1, 1, 'baz')
+---
+error: 'Supplied key field type does not match index type: expected u32'
+...
+lua box.space[27]:truncate()
+---
+...
+lua box.space[27]:len()
+---
+ - 0
+...
diff --git a/test/big/hash_multipart.test b/test/big/hash_multipart.test
new file mode 100644
index 0000000000000000000000000000000000000000..8d4f7347a588802520bd1e4dc9ccda5cf93f3ed6
--- /dev/null
+++ b/test/big/hash_multipart.test
@@ -0,0 +1,53 @@
+# encoding: tarantool
+#
+
+# insert rows
+exec sql "insert into t27 values (0, 'foo', 0, '', 1)"
+exec sql "insert into t27 values (0, 'foo', 1, '', 1)"
+exec sql "insert into t27 values (1, 'foo', 0, '', 2)"
+exec sql "insert into t27 values (1, 'foo', 1, '', 2)"
+exec sql "insert into t27 values (0, 'bar', 0, '', 3)"
+exec sql "insert into t27 values (0, 'bar', 1, '', 3)"
+exec sql "insert into t27 values (1, 'bar', 0, '', 4)"
+exec sql "insert into t27 values (1, 'bar', 1, '', 4)"
+# try to insert a row with a duplicate key
+exec sql "insert into t27 values (1, 'bar', 1, '', 5)"
+
+# output all rows
+lua_code = """
+function box.select_all(space)
+ space = tonumber(space)
+ local result = {}
+ for k, v in box.space[space]:pairs() do
+ table.insert(result, v)
+ end
+ return unpack(result)
+end
+"""
+exec admin "lua " + lua_code.replace('\n', ' ')
+sql.sort = True
+exec sql "call box.select_all('27')"
+sql.sort = False
+
+# primary index select
+exec admin "lua box.select(27, 0, 1, 'foo', 0)"
+exec admin "lua box.select(27, 0, 1, 'bar', 0)"
+# primary index slect with missing part
+exec admin "lua box.select(27, 0, 1, 'foo')"
+# primary index slect with extra part
+exec admin "lua box.select(27, 0, 1, 'foo', 0, 0)"
+# primary index select with wrong type
+exec admin "lua box.select(27, 0, 1, 'foo', 'baz')"
+
+# secondary index select
+exec admin "lua box.select(27, 1, 1, 4)"
+# secondary index select with no such key
+exec admin "lua box.select(27, 1, 1, 5)"
+# secondary index select with missing part
+exec admin "lua box.select(27, 1, 1)"
+# secondary index select with wrong type
+exec admin "lua box.select(27, 1, 1, 'baz')"
+
+# cleanup
+exec admin "lua box.space[27]:truncate()"
+exec admin "lua box.space[27]:len()"
diff --git a/test/big/iterator.result b/test/big/iterator.result
index 21609efd1f75cbdd77a41fc7e0513989b4c3f294..1c832db3fdf2f25c8526613911879a6a91c76c10 100644
--- a/test/big/iterator.result
+++ b/test/big/iterator.result
@@ -768,7 +768,7 @@ error: 'utils.lua:27: Key part count 4 is greater than index part count 2'
...
#-----------------------------------------------------------------------------#
-# Iterator: hash multi-part non-unique
+# Iterator: hash single-part unique
#-----------------------------------------------------------------------------#
lua iterate(20, 4, 0, 1)
@@ -840,6 +840,68 @@ lua iterate(20, 4, 0, 1, box.index.GE, 'pid_999')
sorted output
...
+#-----------------------------------------------------------------------------#
+# Iterator: hash multi-part unique
+#-----------------------------------------------------------------------------#
+
+lua iterate(20, 5, 1, 3, box.index.ALL)
+---
+sorted output
+$sid_001$tid_997$
+$sid_001$tid_998$
+$sid_002$tid_996$
+$sid_002$tid_997$
+$sid_003$tid_996$
+$sid_004$tid_996$
+$sid_005$tid_994$
+$sid_005$tid_995$
+$sid_005$tid_996$
+$sid_006$tid_996$
+...
+lua iterate(20, 5, 1, 3, box.index.EQ)
+---
+error: 'Invalid key part count in an exact match (expected 2, got 0)'
+...
+lua iterate(20, 5, 1, 3, box.index.EQ, 'sid_005')
+---
+error: 'Invalid key part count in an exact match (expected 2, got 1)'
+...
+lua iterate(20, 5, 1, 3, box.index.GE)
+---
+sorted output
+$sid_001$tid_997$
+$sid_001$tid_998$
+$sid_002$tid_996$
+$sid_002$tid_997$
+$sid_003$tid_996$
+$sid_004$tid_996$
+$sid_005$tid_994$
+$sid_005$tid_995$
+$sid_005$tid_996$
+$sid_006$tid_996$
+...
+lua iterate(20, 2, 1, 3, box.index.EQ, 'sid_005', 'tid_995')
+---
+$sid_005$tid_995$
+...
+lua iterate(20, 2, 1, 3, box.index.EQ, 'sid_005', 'tid_999')
+---
+...
+lua iterate(20, 2, 1, 3, box.index.EQ, 'sid_005', 'tid_995', 'a')
+---
+error: 'utils.lua:27: Key part count 3 is greater than index part count 2'
+...
+lua iterate(20, 2, 1, 3, box.index.GE, 'sid_005', 'tid_995')
+---
+$sid_005$tid_995$
+$sid_005$tid_996$
+$sid_006$tid_996$
+...
+lua iterate(20, 2, 1, 3, box.index.GE, 'sid_005', 'tid_999')
+---
+$sid_006$tid_996$
+...
+
#-----------------------------------------------------------------------------#
# Iterator: various
#-----------------------------------------------------------------------------#
diff --git a/test/big/iterator.test b/test/big/iterator.test
index 53fd5531bce1051cd2e18a455fad100f1f20f723..2a737ee5b490526e48d84efa3574598ff8e0a045 100644
--- a/test/big/iterator.test
+++ b/test/big/iterator.test
@@ -135,7 +135,7 @@ exec admin "lua iterate(20, 3, 2, 4, box.index.LT, 'tid_996', 'to', 'many', 'key
print """
#-----------------------------------------------------------------------------#
-# Iterator: hash multi-part non-unique
+# Iterator: hash single-part unique
#-----------------------------------------------------------------------------#
"""
@@ -148,6 +148,21 @@ exec admin "lua iterate(20, 4, 0, 1, box.index.EQ, 'pid_666')"
exec admin "lua iterate(20, 4, 0, 1, box.index.GE, 'pid_001')"
exec admin "lua iterate(20, 4, 0, 1, box.index.GE, 'pid_999')"
+print """
+#-----------------------------------------------------------------------------#
+# Iterator: hash multi-part unique
+#-----------------------------------------------------------------------------#
+"""
+exec admin "lua iterate(20, 5, 1, 3, box.index.ALL)"
+exec admin "lua iterate(20, 5, 1, 3, box.index.EQ)"
+exec admin "lua iterate(20, 5, 1, 3, box.index.EQ, 'sid_005')"
+exec admin "lua iterate(20, 5, 1, 3, box.index.GE)"
+exec admin "lua iterate(20, 2, 1, 3, box.index.EQ, 'sid_005', 'tid_995')"
+exec admin "lua iterate(20, 2, 1, 3, box.index.EQ, 'sid_005', 'tid_999')"
+exec admin "lua iterate(20, 2, 1, 3, box.index.EQ, 'sid_005', 'tid_995', 'a')"
+exec admin "lua iterate(20, 2, 1, 3, box.index.GE, 'sid_005', 'tid_995')"
+exec admin "lua iterate(20, 2, 1, 3, box.index.GE, 'sid_005', 'tid_999')"
+
print """
#-----------------------------------------------------------------------------#
# Iterator: various
diff --git a/test/big/lua.result b/test/big/lua.result
index 5c680343cd5579a7371a65075d853fdbfbf80200..ae7e2c41a9c75566f0578de938d552a1fa969931 100644
--- a/test/big/lua.result
+++ b/test/big/lua.result
@@ -11,7 +11,7 @@ lua box.space[1].index[1]:max()
---
- 'brave': {'new', 'world'}
...
-call box.select(1, 1, 'new', 'world')
+call box.select('1', '1', 'new', 'world')
Found 1 tuple:
['brave', 'new', 'world']
#
@@ -19,9 +19,9 @@ Found 1 tuple:
# "assert failed, when key cardinality is greater than index cardinality"
# https://bugs.launchpad.net/tarantool/+bug/904208
#
-call box.select(1, 1, 'new', 'world', 'order')
+call box.select('1', '1', 'new', 'world', 'order')
An error occurred: ER_KEY_PART_COUNT, 'Invalid key part count (expected [0..2], got 3)'
-call box.delete(1, 'brave')
+call box.delete('1', 'brave')
Found 1 tuple:
['brave', 'new', 'world']
#
@@ -55,16 +55,16 @@ lua tuple
---
- 'item 3': {'california', 'uber alles'}
...
-call box.delete(1, 'item 1')
+call box.delete('1', 'item 1')
Found 1 tuple:
['item 1', 'alabama', 1735290739]
-call box.delete(1, 'item 2')
+call box.delete('1', 'item 2')
Found 1 tuple:
['item 2', 'california', 'dreaming ']
-call box.delete(1, 'item 3')
+call box.delete('1', 'item 3')
Found 1 tuple:
['item 3', 'california', 'uber alles']
-call box.delete(1, 'item 4')
+call box.delete('1', 'item 4')
Found 1 tuple:
['item 4', 'georgia', 'on my mind']
insert into t5 values ('01234567', 'new', 'world')
@@ -113,6 +113,50 @@ lua num == tonumber64('18446744073709551615')
---
- true
...
+lua box.delete(8, 18446744073709551615ULL)
+---
+ - 18446744073709551615: {'magic'}
+...
+lua box.insert('8', 125ULL, 'magic')
+---
+ - 125: {'magic'}
+...
+lua tu = box.select('8', '0', 125)
+---
+...
+lua tu2 = box.select('8', '0', 125LL)
+---
+...
+lua num = box.unpack('l', tu[0])
+---
+...
+lua num2 = box.unpack('l', tu2[0])
+---
+...
+lua print(num)
+---
+125
+...
+lua print(num2)
+---
+125
+...
+lua type(num) == 'cdata'
+---
+ - true
+...
+lua type(num2) == 'cdata'
+---
+ - true
+...
+lua num == tonumber64('125')
+---
+ - true
+...
+lua num2 == tonumber64('125')
+---
+ - true
+...
lua box.space[8]:truncate()
---
...
diff --git a/test/big/lua.test b/test/big/lua.test
index db6058da97502e97115505962b0d2ab7b7af19c6..476dee6e6bb1fdc5ece12d82855f0e6121d8bdf3 100644
--- a/test/big/lua.test
+++ b/test/big/lua.test
@@ -13,14 +13,14 @@ for file in ("index_random_test.lua",):
exec sql "insert into t1 values ('brave', 'new', 'world')"
exec admin "lua box.space[1].index[1]:min()"
exec admin "lua box.space[1].index[1]:max()"
-exec sql "call box.select(1, 1, 'new', 'world')"
+exec sql "call box.select('1', '1', 'new', 'world')"
print """#
# A test case for Bug #904208
# "assert failed, when key cardinality is greater than index cardinality"
# https://bugs.launchpad.net/tarantool/+bug/904208
#"""
-exec sql "call box.select(1, 1, 'new', 'world', 'order')"
-exec sql "call box.delete(1, 'brave')"
+exec sql "call box.select('1', '1', 'new', 'world', 'order')"
+exec sql "call box.delete('1', 'brave')"
print """#
# A test case for Bug #902091
@@ -36,10 +36,10 @@ exec admin "lua iter, tuple = box.space[1].index[1]:next('california')"
exec admin "lua tuple"
exec admin "lua iter, tuple = box.space[1].index[1]:next(iter)"
exec admin "lua tuple"
-exec sql "call box.delete(1, 'item 1')"
-exec sql "call box.delete(1, 'item 2')"
-exec sql "call box.delete(1, 'item 3')"
-exec sql "call box.delete(1, 'item 4')"
+exec sql "call box.delete('1', 'item 1')"
+exec sql "call box.delete('1', 'item 2')"
+exec sql "call box.delete('1', 'item 3')"
+exec sql "call box.delete('1', 'item 4')"
#
# Check range scan over multipart keys
@@ -62,6 +62,18 @@ exec admin "lua type(num) == 'cdata'"
exec admin "lua num == tonumber64('18446744073709551615')"
exec admin "lua num = box.unpack('l', tu[0])"
exec admin "lua num == tonumber64('18446744073709551615')"
+exec admin "lua box.delete(8, 18446744073709551615ULL)"
+exec admin "lua box.insert('8', 125ULL, 'magic')"
+exec admin "lua tu = box.select('8', '0', 125)"
+exec admin "lua tu2 = box.select('8', '0', 125LL)"
+exec admin "lua num = box.unpack('l', tu[0])"
+exec admin "lua num2 = box.unpack('l', tu2[0])"
+exec admin "lua print(num)"
+exec admin "lua print(num2)"
+exec admin "lua type(num) == 'cdata'"
+exec admin "lua type(num2) == 'cdata'"
+exec admin "lua num == tonumber64('125')"
+exec admin "lua num2 == tonumber64('125')"
exec admin "lua box.space[8]:truncate()"
#
diff --git a/test/big/sql.result b/test/big/sql.result
index 222809b43f52e4786f68133acaa5a56555725067..8cfaf98431963b4ae406e032984dd7de6e55bcb3 100644
--- a/test/big/sql.result
+++ b/test/big/sql.result
@@ -63,10 +63,10 @@ No match
select * from t0 where k1='Britney'
Found 1 tuple:
['Spears', 'Britney']
-call box.select_range(0, 0, 100, 'Spears')
+call box.select_range('0', '0', '100', 'Spears')
Found 1 tuple:
['Spears', 'Britney']
-call box.select_range(0, 1, 100, 'Britney')
+call box.select_range('0', '1', '100', 'Britney')
Found 1 tuple:
['Spears', 'Britney']
delete from t0 where k0='Spears'
@@ -102,17 +102,17 @@ Found 3 tuples:
[830039403, 'part1', 'part2']
[846816619, 'part1', 'part2_a']
[863593835, 'part1', 'part2_b']
-call box.select_range(1, 1, 100, 'part1')
+call box.select_range('1', '1', '100', 'part1')
Found 3 tuples:
[830039403, 'part1', 'part2']
[846816619, 'part1', 'part2_a']
[863593835, 'part1', 'part2_b']
-call box.select_range(1, 0, 100, 'key2')
+call box.select_range('1', '0', '100', 'key2')
Found 3 tuples:
[830039403, 'part1', 'part2']
[846816619, 'part1', 'part2_a']
[863593835, 'part1', 'part2_b']
-call box.select_range(1, 1, 100, 'part1', 'part2_a')
+call box.select_range('1', '1', '100', 'part1', 'part2_a')
Found 2 tuples:
[846816619, 'part1', 'part2_a']
[863593835, 'part1', 'part2_b']
@@ -211,10 +211,6 @@ Found 3 tuples:
['21234567', 'part1', 'part2_a']
select * from t5 where k1='part2'
No match
-delete from t5 where k0=1
-An error occurred: ER_ILLEGAL_PARAMS, 'Illegal parameters, key is not u64'
-delete from t5 where k0=2
-An error occurred: ER_ILLEGAL_PARAMS, 'Illegal parameters, key is not u64'
delete from t5 where k0='01234567'
Delete OK, 1 row affected
delete from t5 where k0='11234567'
diff --git a/test/big/sql.test b/test/big/sql.test
index 1ebf223dfc5f979a1cb9dc1d054aed9e3dfdcccd..51b875591b6a0d40d7702e5ee7ed69339a8be3de 100644
--- a/test/big/sql.test
+++ b/test/big/sql.test
@@ -45,8 +45,8 @@ exec sql "insert into t0 values ('Spears', 'Britney')"
exec sql "select * from t0 where k0='Spears'"
exec sql "select * from t0 where k1='Anything'"
exec sql "select * from t0 where k1='Britney'"
-exec sql "call box.select_range(0, 0, 100, 'Spears')"
-exec sql "call box.select_range(0, 1, 100, 'Britney')"
+exec sql "call box.select_range('0', '0', '100', 'Spears')"
+exec sql "call box.select_range('0', '1', '100', 'Britney')"
exec sql "delete from t0 where k0='Spears'"
print """#
# Test composite keys with trees
@@ -61,9 +61,9 @@ exec sql "select * from t1 where k0='key1'"
exec sql "select * from t1 where k0='key2'"
exec sql "select * from t1 where k0='key3'"
exec sql "select * from t1 where k1='part1'"
-exec sql "call box.select_range(1, 1, 100, 'part1')"
-exec sql "call box.select_range(1, 0, 100, 'key2')"
-exec sql "call box.select_range(1, 1, 100, 'part1', 'part2_a')"
+exec sql "call box.select_range('1', '1', '100', 'part1')"
+exec sql "call box.select_range('1', '0', '100', 'key2')"
+exec sql "call box.select_range('1', '1', '100', 'part1', 'part2_a')"
# check non-unique multipart keys
exec sql "insert into t5 values ('01234567', 'part1', 'part2')"
exec sql "insert into t5 values ('11234567', 'part1', 'part2')"
@@ -102,9 +102,6 @@ exec sql "delete from t1 where k0='key2'"
exec sql "delete from t1 where k0='key3'"
exec sql "select * from t5 where k1='part1'"
exec sql "select * from t5 where k1='part2'"
-# check incomplete keys
-exec sql "delete from t5 where k0=1"
-exec sql "delete from t5 where k0=2"
# cleanup
exec sql "delete from t5 where k0='01234567'"
exec sql "delete from t5 where k0='11234567'"
diff --git a/test/big/tarantool.cfg b/test/big/tarantool.cfg
index 0f9f416055bc0a9060f935ceca19c73b0fdb1141..58def14511efd800f7beeb9f97ac5e19329b1e7d 100644
--- a/test/big/tarantool.cfg
+++ b/test/big/tarantool.cfg
@@ -283,6 +283,14 @@ space[20].index[4].unique = 1
space[20].index[4].key_field[0].fieldno = 0
space[20].index[4].key_field[0].type = "STR"
+# Hash multi-part unique
+space[20].index[5].type = "HASH"
+space[20].index[5].unique = 1
+space[20].index[5].key_field[0].fieldno = 1
+space[20].index[5].key_field[0].type = "STR"
+space[20].index[5].key_field[1].fieldno = 2
+space[20].index[5].key_field[1].type = "STR"
+
# hash::replace
space[21].enabled = true
@@ -367,3 +375,22 @@ space[26].index[1].type = "HASH"
space[26].index[1].unique = true
space[26].index[1].key_field[0].fieldno = 0
space[26].index[1].key_field[0].type = "NUM"
+
+# Multi-part hash
+space[27].enabled = 1
+
+space[27].index[0].type = HASH
+space[27].index[0].unique = 1
+space[27].index[0].key_field[0].fieldno = 0
+space[27].index[0].key_field[0].type = NUM
+space[27].index[0].key_field[1].fieldno = 1
+space[27].index[0].key_field[1].type = STR
+space[27].index[0].key_field[2].fieldno = 2
+space[27].index[0].key_field[2].type = NUM
+
+space[27].index[1].type = HASH
+space[27].index[1].unique = 1
+space[27].index[1].key_field[0].fieldno = 2
+space[27].index[1].key_field[0].type = NUM
+space[27].index[1].key_field[1].fieldno = 4
+space[27].index[1].key_field[1].type = NUM
diff --git a/test/big/tree_pk.result b/test/big/tree_pk.result
index f846c16566b12b55e8fde7dc82bac59eb5c89e5e..d00a981e789f5771562da92dd1962e1ebd02a622 100644
--- a/test/big/tree_pk.result
+++ b/test/big/tree_pk.result
@@ -27,6 +27,12 @@ delete from t2 where k0 = 2
Delete OK, 1 row affected
delete from t2 where k0 = 3
Delete OK, 1 row affected
+insert into t2 VALUES('xxxxxxx')
+An error occurred: ER_KEY_FIELD_TYPE, 'Supplied key field type does not match index type: expected NUM'
+insert into t2 VALUES('')
+An error occurred: ER_KEY_FIELD_TYPE, 'Supplied key field type does not match index type: expected NUM'
+insert into t2 VALUES('12')
+An error occurred: ER_KEY_FIELD_TYPE, 'Supplied key field type does not match index type: expected NUM'
insert into t3 values ('identifier', 'tuple')
Insert OK, 1 row affected
save snapshot
@@ -39,10 +45,10 @@ save snapshot
---
ok
...
-call box.select_range(3, 0, 100, 'second')
+call box.select_range('3', '0', '100', 'second')
Found 1 tuple:
['second', 'tuple 2']
-call box.select_range(3, 0, 100, 'identifier')
+call box.select_range('3', '0', '100', 'identifier')
Found 2 tuples:
['identifier', 'tuple']
['second', 'tuple 2']
@@ -72,21 +78,21 @@ Insert OK, 1 row affected
lua function box.crossjoin(space0, space1, limit) space0 = tonumber(space0) space1 = tonumber(space1) limit = tonumber(limit) local result = {} for k0, v0 in box.space[space0]:pairs() do for k1, v1 in box.space[space1]:pairs() do if limit <= 0 then return unpack(result) end newtuple = {v0:unpack()} for _, v in v1:pairs() do table.insert(newtuple, v) end table.insert(result, newtuple) limit = limit - 1 end end return unpack(result) end
---
...
-call box.crossjoin(3, 3, 0)
+call box.crossjoin('3', '3', '0')
No match
-call box.crossjoin(3, 3, 5)
+call box.crossjoin('3', '3', '5')
Found 4 tuples:
[1, 'tuple', 1, 'tuple']
[1, 'tuple', 2, 'tuple']
[2, 'tuple', 1, 'tuple']
[2, 'tuple', 2, 'tuple']
-call box.crossjoin(3, 3, 10000)
+call box.crossjoin('3', '3', '10000')
Found 4 tuples:
[1, 'tuple', 1, 'tuple']
[1, 'tuple', 2, 'tuple']
[2, 'tuple', 1, 'tuple']
[2, 'tuple', 2, 'tuple']
-call box.crossjoin(3, 2, 10000)
+call box.crossjoin('3', '2', '10000')
Found 2 tuples:
[1, 'tuple', 1, 'tuple']
[2, 'tuple', 1, 'tuple']
diff --git a/test/big/tree_pk.test b/test/big/tree_pk.test
index a1bfb99f81453d1cd4c34c0f9bcbc41f76d41bfa..7ba2387e56ebd990004776de25917c090936d50d 100644
--- a/test/big/tree_pk.test
+++ b/test/big/tree_pk.test
@@ -15,13 +15,20 @@ exec sql "select * from t2 where k0 = 3"
exec sql "delete from t2 where k0 = 1"
exec sql "delete from t2 where k0 = 2"
exec sql "delete from t2 where k0 = 3"
+
+# Test incorrect keys - supplied key field type does not match index type
+# https://bugs.launchpad.net/tarantool/+bug/1072624
+exec sql "insert into t2 VALUES('xxxxxxx')"
+exec sql "insert into t2 VALUES('')"
+exec sql "insert into t2 VALUES('12')"
+
# string keys
exec sql "insert into t3 values ('identifier', 'tuple')"
exec admin "save snapshot"
exec sql "insert into t3 values ('second', 'tuple 2')"
exec admin "save snapshot"
-exec sql "call box.select_range(3, 0, 100, 'second')"
-exec sql "call box.select_range(3, 0, 100, 'identifier')"
+exec sql "call box.select_range('3', '0', '100', 'second')"
+exec sql "call box.select_range('3', '0', '100', 'identifier')"
exec sql "insert into t3 values ('third', 'tuple 3')"
exec sql "select * from t3 where k0 = 'identifier'"
@@ -55,10 +62,10 @@ exec sql "insert into t2 values (1, 'tuple')"
exec sql "insert into t3 values (1, 'tuple')"
exec sql "insert into t3 values (2, 'tuple')"
exec admin "lua " + lua.replace('\n', ' ')
-exec sql "call box.crossjoin(3, 3, 0)"
-exec sql "call box.crossjoin(3, 3, 5)"
-exec sql "call box.crossjoin(3, 3, 10000)"
-exec sql "call box.crossjoin(3, 2, 10000)"
+exec sql "call box.crossjoin('3', '3', '0')"
+exec sql "call box.crossjoin('3', '3', '5')"
+exec sql "call box.crossjoin('3', '3', '10000')"
+exec sql "call box.crossjoin('3', '2', '10000')"
exec admin "lua box.space[3]:truncate()"
# Bug #922520 - select missing keys
diff --git a/test/big/tree_variants.result b/test/big/tree_variants.result
index e01d32f1c37bdbec640e4d351e2dd6ea91762378..1f7b485689b88c1b3fb2d9783f52c2ce381446ea 100644
--- a/test/big/tree_variants.result
+++ b/test/big/tree_variants.result
@@ -68,6 +68,44 @@ delete from t6 where k0 = 8
Delete OK, 1 row affected
delete from t6 where k0 = 9
Delete OK, 1 row affected
+lua box.insert(6, 6, 6ULL, 400ULL, 'John', 'Smoker', 'Hits', 'A Pipe', 'foo', 2006 )
+---
+ - 6: {6, 400, 1852337994, 'Smoker', 1937008968, 'A Pipe', 'foo', 2006}
+...
+lua box.insert(6, 7, 7ULL, 400ULL, 'John', 'Smoker', 'Hits', 'A Bong', 'foo', 2007 )
+---
+ - 7: {7, 400, 1852337994, 'Smoker', 1937008968, 'A Bong', 'foo', 2007}
+...
+lua box.insert(6, 8, 8ULL, 400ULL, 'John', 'Smoker', 'Rolls', 'A Joint', 'foo', 2008 )
+---
+ - 8: {8, 400, 1852337994, 'Smoker', 'Rolls', 'A Joint', 'foo', 2008}
+...
+lua box.insert(6, 9, 9ULL, 400ULL, 'John', 'Smoker', 'Rolls', 'A Blunt', 'foo', 2009 )
+---
+ - 9: {9, 400, 1852337994, 'Smoker', 'Rolls', 'A Blunt', 'foo', 2009}
+...
+lua box.select(6, 1, 6ULL)
+---
+ - 6: {6, 400, 1852337994, 'Smoker', 1937008968, 'A Pipe', 'foo', 2006}
+...
+lua box.select(6, 1, 6)
+---
+ - 6: {6, 400, 1852337994, 'Smoker', 1937008968, 'A Pipe', 'foo', 2006}
+...
+lua box.select(6, 2, 400ULL)
+---
+ - 6: {6, 400, 1852337994, 'Smoker', 1937008968, 'A Pipe', 'foo', 2006}
+ - 7: {7, 400, 1852337994, 'Smoker', 1937008968, 'A Bong', 'foo', 2007}
+ - 8: {8, 400, 1852337994, 'Smoker', 'Rolls', 'A Joint', 'foo', 2008}
+ - 9: {9, 400, 1852337994, 'Smoker', 'Rolls', 'A Blunt', 'foo', 2009}
+...
+lua box.select(6, 2, 400)
+---
+ - 6: {6, 400, 1852337994, 'Smoker', 1937008968, 'A Pipe', 'foo', 2006}
+ - 7: {7, 400, 1852337994, 'Smoker', 1937008968, 'A Bong', 'foo', 2007}
+ - 8: {8, 400, 1852337994, 'Smoker', 'Rolls', 'A Joint', 'foo', 2008}
+ - 9: {9, 400, 1852337994, 'Smoker', 'Rolls', 'A Blunt', 'foo', 2009}
+...
lua for k,v in box.space[6]:pairs() do print(v) end
---
0: {3472328296227680304, 3472329395739308080, 'Joe', 'Sixpack', 'Drinks', 'Amstel', 'bar', 2000}
@@ -76,4 +114,16 @@ lua for k,v in box.space[6]:pairs() do print(v) end
3: {3688501078341464112, 3472331594762563632, 'Joe', 'Sixpack', 'Drinks', 'Corona Extra', 'bar', 2003}
4: {3760558672379392048, 3472331594762563632, 'Joe', 'Sixpack', 'Drinks', 'Stella Artois', 'bar', 2004}
5: {3832616266417319984, 3472331594762563632, 'Joe', 'Sixpack', 'Drinks', 'Miller Genuine Draft', 'bar', 2005}
+6: {6, 400, 1852337994, 'Smoker', 1937008968, 'A Pipe', 'foo', 2006}
+7: {7, 400, 1852337994, 'Smoker', 1937008968, 'A Bong', 'foo', 2007}
+8: {8, 400, 1852337994, 'Smoker', 'Rolls', 'A Joint', 'foo', 2008}
+9: {9, 400, 1852337994, 'Smoker', 'Rolls', 'A Blunt', 'foo', 2009}
...
+insert into t6 VALUES('', '00000001', '00000002', '', '', '', '', '', 0)
+An error occurred: ER_KEY_FIELD_TYPE, 'Supplied key field type does not match index type: expected NUM'
+insert into t6 VALUES('xxxxxxxx', '00000001', '00000002', '', '', '', '', '', 0)
+An error occurred: ER_KEY_FIELD_TYPE, 'Supplied key field type does not match index type: expected NUM'
+insert into t6 VALUES(1, '', '00000002', '', '', '', '', '', 0)
+An error occurred: ER_KEY_FIELD_TYPE, 'Supplied key field type does not match index type: expected NUM64'
+insert into t6 VALUES(1, 'xxxxxxxxxxx', '00000002', '', '', '', '', '', 0)
+An error occurred: ER_KEY_FIELD_TYPE, 'Supplied key field type does not match index type: expected NUM64'
diff --git a/test/big/tree_variants.test b/test/big/tree_variants.test
index 9c26aa3ac1aecb26e1195e401f188d4fa9327115..8053cf4d6f5860da12d209df3ecec38ac906d8d7 100644
--- a/test/big/tree_variants.test
+++ b/test/big/tree_variants.test
@@ -27,5 +27,21 @@ exec sql "delete from t6 where k0 = 7"
exec sql "delete from t6 where k0 = 8"
exec sql "delete from t6 where k0 = 9"
+exec admin "lua box.insert(6, 6, 6ULL, 400ULL, 'John', 'Smoker', 'Hits', 'A Pipe', 'foo', 2006 )"
+exec admin "lua box.insert(6, 7, 7ULL, 400ULL, 'John', 'Smoker', 'Hits', 'A Bong', 'foo', 2007 )"
+exec admin "lua box.insert(6, 8, 8ULL, 400ULL, 'John', 'Smoker', 'Rolls', 'A Joint', 'foo', 2008 )"
+exec admin "lua box.insert(6, 9, 9ULL, 400ULL, 'John', 'Smoker', 'Rolls', 'A Blunt', 'foo', 2009 )"
+
+exec admin "lua box.select(6, 1, 6ULL)"
+exec admin "lua box.select(6, 1, 6)"
+exec admin "lua box.select(6, 2, 400ULL)"
+exec admin "lua box.select(6, 2, 400)"
+
exec admin "lua for k,v in box.space[6]:pairs() do print(v) end"
+# Test incorrect keys - supplied key field type does not match index type
+# https://bugs.launchpad.net/tarantool/+bug/1072624
+exec sql "insert into t6 VALUES('', '00000001', '00000002', '', '', '', '', '', 0)"
+exec sql "insert into t6 VALUES('xxxxxxxx', '00000001', '00000002', '', '', '', '', '', 0)"
+exec sql "insert into t6 VALUES(1, '', '00000002', '', '', '', '', '', 0)"
+exec sql "insert into t6 VALUES(1, 'xxxxxxxxxxx', '00000002', '', '', '', '', '', 0)"
diff --git a/test/box/fiber.result b/test/box/fiber.result
index 8a333e0aa16bd8b5b34177ded344b9267241affe..3b49764ee772ca8a9d636ddf2e41055d94050283 100644
--- a/test/box/fiber.result
+++ b/test/box/fiber.result
@@ -19,7 +19,7 @@ error: 'box.process(CALL, ...) is not allowed'
...
insert into t0 values (1, 'test box delete')
Insert OK, 1 row affected
-call box.delete(0, '���')
+call box.delete('0', '���')
Found 1 tuple:
[1, 'test box delete']
insert into t0 values (1, 'test box delete')
@@ -30,7 +30,7 @@ lua box.delete(0, 1)
...
insert into t0 values ('abcd', 'test box delete')
Insert OK, 1 row affected
-call box.delete(0, 'abcd')
+call box.delete('0', 'abcd')
Found 1 tuple:
[1684234849, 'test box delete']
insert into t0 values ('abcd', 'test box delete')
@@ -41,78 +41,78 @@ lua box.delete(0, 'abcd')
...
insert into t0 values ('abcd', 'test box.select()')
Insert OK, 1 row affected
-call box.replace(0, 'abcd', 'hello', 'world')
+call box.replace('0', 'abcd', 'hello', 'world')
Found 1 tuple:
[1684234849, 'hello', 'world']
-call box.replace(0, 'defc', 'goodbye', 'universe')
+call box.replace('0', 'defc', 'goodbye', 'universe')
Found 1 tuple:
[1667655012, 'goodbye', 'universe']
-call box.replace(0, 'defc', 'goodbye', 'universe')
+call box.replace('0', 'defc', 'goodbye', 'universe')
Found 1 tuple:
[1667655012, 'goodbye', 'universe']
-call box.replace(0, 'defc', 'goodbye', 'universe')
+call box.replace('0', 'defc', 'goodbye', 'universe')
Found 1 tuple:
[1667655012, 'goodbye', 'universe']
-call box.replace(0, 'defc', 'goodbye', 'universe')
+call box.replace('0', 'defc', 'goodbye', 'universe')
Found 1 tuple:
[1667655012, 'goodbye', 'universe']
-call box.replace(0, 'defc', 'goodbye', 'universe')
+call box.replace('0', 'defc', 'goodbye', 'universe')
Found 1 tuple:
[1667655012, 'goodbye', 'universe']
-call box.replace(0, 'defc', 'goodbye', 'universe')
+call box.replace('0', 'defc', 'goodbye', 'universe')
Found 1 tuple:
[1667655012, 'goodbye', 'universe']
-call box.replace(0, 'defc', 'goodbye', 'universe')
+call box.replace('0', 'defc', 'goodbye', 'universe')
Found 1 tuple:
[1667655012, 'goodbye', 'universe']
-call box.replace(0, 'defc', 'goodbye', 'universe')
+call box.replace('0', 'defc', 'goodbye', 'universe')
Found 1 tuple:
[1667655012, 'goodbye', 'universe']
-call box.replace(0, 'defc', 'goodbye', 'universe')
+call box.replace('0', 'defc', 'goodbye', 'universe')
Found 1 tuple:
[1667655012, 'goodbye', 'universe']
-call box.replace(0, 'defc', 'goodbye', 'universe')
+call box.replace('0', 'defc', 'goodbye', 'universe')
Found 1 tuple:
[1667655012, 'goodbye', 'universe']
-call box.replace(0, 'defc', 'goodbye', 'universe')
+call box.replace('0', 'defc', 'goodbye', 'universe')
Found 1 tuple:
[1667655012, 'goodbye', 'universe']
-call box.replace(0, 'defc', 'goodbye', 'universe')
+call box.replace('0', 'defc', 'goodbye', 'universe')
Found 1 tuple:
[1667655012, 'goodbye', 'universe']
-call box.replace(0, 'abcd')
+call box.replace('0', 'abcd')
Found 1 tuple:
[1684234849]
-call box.delete(0, 'abcd')
+call box.delete('0', 'abcd')
Found 1 tuple:
[1684234849]
-call box.delete(0, 'defc')
+call box.delete('0', 'defc')
Found 1 tuple:
[1667655012, 'goodbye', 'universe']
-call box.insert(0, 'test', 'old', 'abcd')
+call box.insert('0', 'test', 'old', 'abcd')
Found 1 tuple:
[1953719668, 'old', 1684234849]
-call box.insert(0, 'test', 'old', 'abcd')
+call box.insert('0', 'test', 'old', 'abcd')
An error occurred: ER_TUPLE_FOUND, 'Duplicate key exists in unique index 0'
-call box.update(0, 'test', '=p=p', 0, 'pass', 1, 'new')
+call box.update('0', 'test', '=p=p', 0, 'pass', 1, 'new')
Found 1 tuple:
[1936941424, 'new', 1684234849]
-call box.update(0, 'miss', '+p', 2, '���')
+call box.update('0', 'miss', '+p', 2, '���')
No match
-call box.update(0, 'pass', '+p', 2, '���')
+call box.update('0', 'pass', '+p', 2, '���')
Found 1 tuple:
[1936941424, 'new', 1684234850]
-call box.update(0, 'pass', '-p', 2, '���')
+call box.update('0', 'pass', '-p', 2, '���')
Found 1 tuple:
[1936941424, 'new', 1684234849]
-call box.update(0, 'pass', '-p', 2, '���')
+call box.update('0', 'pass', '-p', 2, '���')
Found 1 tuple:
[1936941424, 'new', 1684234848]
lua box.update(0, 'pass', '+p', 2, 1)
---
- 1936941424: {'new', 1684234849}
...
-call box.delete(0, 'pass')
+call box.delete('0', 'pass')
Found 1 tuple:
[1936941424, 'new', 1684234849]
reload configuration
diff --git a/test/box/fiber.test b/test/box/fiber.test
index 09d8b3d90a8f6f3e36873cc183e5c92ab7065628..ec15bf044dda3dd49322401f28470cd64732aeef 100644
--- a/test/box/fiber.test
+++ b/test/box/fiber.test
@@ -17,40 +17,40 @@ exec admin "lua box.process(17, box.pack('iiiiiip', 0, 0, 0, 2^31, 1, 1, 1))"
exec admin "lua box.process(22, box.pack('iii', 0, 0, 0))"
exec sql "insert into t0 values (1, 'test box delete')"
-exec sql "call box.delete(0, '\1\0\0\0')"
+exec sql "call box.delete('0', '\1\0\0\0')"
exec sql "insert into t0 values (1, 'test box delete')"
exec admin "lua box.delete(0, 1)"
exec sql "insert into t0 values ('abcd', 'test box delete')"
-exec sql "call box.delete(0, 'abcd')"
+exec sql "call box.delete('0', 'abcd')"
exec sql "insert into t0 values ('abcd', 'test box delete')"
exec admin "lua box.delete(0, 'abcd')"
exec sql "insert into t0 values ('abcd', 'test box.select()')"
-exec sql "call box.replace(0, 'abcd', 'hello', 'world')"
-exec sql "call box.replace(0, 'defc', 'goodbye', 'universe')"
-exec sql "call box.replace(0, 'defc', 'goodbye', 'universe')"
-exec sql "call box.replace(0, 'defc', 'goodbye', 'universe')"
-exec sql "call box.replace(0, 'defc', 'goodbye', 'universe')"
-exec sql "call box.replace(0, 'defc', 'goodbye', 'universe')"
-exec sql "call box.replace(0, 'defc', 'goodbye', 'universe')"
-exec sql "call box.replace(0, 'defc', 'goodbye', 'universe')"
-exec sql "call box.replace(0, 'defc', 'goodbye', 'universe')"
-exec sql "call box.replace(0, 'defc', 'goodbye', 'universe')"
-exec sql "call box.replace(0, 'defc', 'goodbye', 'universe')"
-exec sql "call box.replace(0, 'defc', 'goodbye', 'universe')"
-exec sql "call box.replace(0, 'defc', 'goodbye', 'universe')"
-exec sql "call box.replace(0, 'abcd')"
-exec sql "call box.delete(0, 'abcd')"
-exec sql "call box.delete(0, 'defc')"
-exec sql "call box.insert(0, 'test', 'old', 'abcd')"
+exec sql "call box.replace('0', 'abcd', 'hello', 'world')"
+exec sql "call box.replace('0', 'defc', 'goodbye', 'universe')"
+exec sql "call box.replace('0', 'defc', 'goodbye', 'universe')"
+exec sql "call box.replace('0', 'defc', 'goodbye', 'universe')"
+exec sql "call box.replace('0', 'defc', 'goodbye', 'universe')"
+exec sql "call box.replace('0', 'defc', 'goodbye', 'universe')"
+exec sql "call box.replace('0', 'defc', 'goodbye', 'universe')"
+exec sql "call box.replace('0', 'defc', 'goodbye', 'universe')"
+exec sql "call box.replace('0', 'defc', 'goodbye', 'universe')"
+exec sql "call box.replace('0', 'defc', 'goodbye', 'universe')"
+exec sql "call box.replace('0', 'defc', 'goodbye', 'universe')"
+exec sql "call box.replace('0', 'defc', 'goodbye', 'universe')"
+exec sql "call box.replace('0', 'defc', 'goodbye', 'universe')"
+exec sql "call box.replace('0', 'abcd')"
+exec sql "call box.delete('0', 'abcd')"
+exec sql "call box.delete('0', 'defc')"
+exec sql "call box.insert('0', 'test', 'old', 'abcd')"
# test that insert produces a duplicate key error
-exec sql "call box.insert(0, 'test', 'old', 'abcd')"
-exec sql "call box.update(0, 'test', '=p=p', 0, 'pass', 1, 'new')"
-exec sql "call box.update(0, 'miss', '+p', 2, '\1\0\0\0')"
-exec sql "call box.update(0, 'pass', '+p', 2, '\1\0\0\0')"
-exec sql "call box.update(0, 'pass', '-p', 2, '\1\0\0\0')"
-exec sql "call box.update(0, 'pass', '-p', 2, '\1\0\0\0')"
+exec sql "call box.insert('0', 'test', 'old', 'abcd')"
+exec sql "call box.update('0', 'test', '=p=p', 0, 'pass', 1, 'new')"
+exec sql "call box.update('0', 'miss', '+p', 2, '\1\0\0\0')"
+exec sql "call box.update('0', 'pass', '+p', 2, '\1\0\0\0')"
+exec sql "call box.update('0', 'pass', '-p', 2, '\1\0\0\0')"
+exec sql "call box.update('0', 'pass', '-p', 2, '\1\0\0\0')"
exec admin "lua box.update(0, 'pass', '+p', 2, 1)"
-exec sql "call box.delete(0, 'pass')"
+exec sql "call box.delete('0', 'pass')"
exec admin "reload configuration"
# must be read-only
diff --git a/test/box/lua.result b/test/box/lua.result
index 0e33e52533f10507a6c19466f165b38847cea148..1edd02d6038a19b7bd820f617403bc0d6a921e39 100644
--- a/test/box/lua.result
+++ b/test/box/lua.result
@@ -225,7 +225,7 @@ Found 7 tuples:
['false']
[4294967295]
[1]
-[0]
+['��������']
['nil']
lua f1=nil
---
@@ -239,10 +239,10 @@ call f1()
An error occurred: ER_PROC_RET, 'Return type 'function' is not supported in the binary protocol'
insert into t0 values (1, 'test box delete')
Insert OK, 1 row affected
-call box.delete(0, '���')
+call box.delete('0', '���')
Found 1 tuple:
[1, 'test box delete']
-call box.delete(0, '���')
+call box.delete('0', '���')
No match
insert into t0 values (1, 'test box delete')
Insert OK, 1 row affected
@@ -255,12 +255,12 @@ lua box.delete(0, 1)
...
insert into t0 values ('abcd', 'test box delete')
Insert OK, 1 row affected
-call box.delete(0, '���')
+call box.delete('0', '���')
No match
-call box.delete(0, 'abcd')
+call box.delete('0', 'abcd')
Found 1 tuple:
[1684234849, 'test box delete']
-call box.delete(0, 'abcd')
+call box.delete('0', 'abcd')
No match
insert into t0 values ('abcd', 'test box delete')
Insert OK, 1 row affected
@@ -271,11 +271,11 @@ lua box.delete(0, 'abcd')
lua box.delete(0, 'abcd')
---
...
-call box.select(0, 0, 'abcd')
+call box.select('0', '0', 'abcd')
No match
insert into t0 values ('abcd', 'test box.select()')
Insert OK, 1 row affected
-call box.select(0, 0, 'abcd')
+call box.select('0', '0', 'abcd')
Found 1 tuple:
[1684234849, 'test box.select()']
lua box.select(0, 0, 'abcd')
@@ -292,74 +292,74 @@ error: 'No index #1 is defined in space 0'
...
lua box.select(0)
---
-error: 'Invalid key part count in an exact match (expected 1, got 0)'
+error: '[string "-- box_net.lua (internal file)..."]:68: box.pack: expected 32-bit int'
...
-call box.replace(0, 'abcd', 'hello', 'world')
+call box.replace('0', 'abcd', 'hello', 'world')
Found 1 tuple:
[1684234849, 'hello', 'world']
-call box.replace(0, 'defc', 'goodbye', 'universe')
+call box.replace('0', 'defc', 'goodbye', 'universe')
Found 1 tuple:
[1667655012, 'goodbye', 'universe']
-call box.select(0, 0, 'abcd')
+call box.select('0', '0', 'abcd')
Found 1 tuple:
[1684234849, 'hello', 'world']
-call box.select(0, 0, 'defc')
+call box.select('0', '0', 'defc')
Found 1 tuple:
[1667655012, 'goodbye', 'universe']
-call box.replace(0, 'abcd')
+call box.replace('0', 'abcd')
Found 1 tuple:
[1684234849]
-call box.select(0, 0, 'abcd')
+call box.select('0', '0', 'abcd')
Found 1 tuple:
[1684234849]
-call box.delete(0, 'abcd')
+call box.delete('0', 'abcd')
Found 1 tuple:
[1684234849]
-call box.delete(0, 'defc')
+call box.delete('0', 'defc')
Found 1 tuple:
[1667655012, 'goodbye', 'universe']
-call box.insert(0, 'test', 'old', 'abcd')
+call box.insert('0', 'test', 'old', 'abcd')
Found 1 tuple:
[1953719668, 'old', 1684234849]
-call box.insert(0, 'test', 'old', 'abcd')
+call box.insert('0', 'test', 'old', 'abcd')
An error occurred: ER_TUPLE_FOUND, 'Duplicate key exists in unique index 0'
-call box.update(0, 'test', '=p=p', 0, 'pass', 1, 'new')
+call box.update('0', 'test', '=p=p', '����', 'pass', 1, 'new')
Found 1 tuple:
[1936941424, 'new', 1684234849]
-call box.select(0, 0, 'pass')
+call box.select('0', '0', 'pass')
Found 1 tuple:
[1936941424, 'new', 1684234849]
call box.select_range(0, 0, 1, 'pass')
Found 1 tuple:
[1936941424, 'new', 1684234849]
-call box.update(0, 'miss', '+p', 2, '���')
+call box.update('0', 'miss', '+p', 2, '���')
No match
-call box.update(0, 'pass', '+p', 2, '���')
+call box.update('0', 'pass', '+p', 2, '���')
Found 1 tuple:
[1936941424, 'new', 1684234850]
-call box.update(0, 'pass', '-p', 2, '���')
+call box.update('0', 'pass', '-p', 2, '���')
Found 1 tuple:
[1936941424, 'new', 1684234849]
-call box.update(0, 'pass', '-p', 2, '���')
+call box.update('0', 'pass', '-p', 2, '���')
Found 1 tuple:
[1936941424, 'new', 1684234848]
lua box.update(0, 'pass', '+p', 2, 1)
---
- 1936941424: {'new', 1684234849}
...
-call box.select(0, 0, 'pass')
+call box.select('0', '0', 'pass')
Found 1 tuple:
[1936941424, 'new', 1684234849]
-lua function field_x(space, key, field_index) return (box.select(space, 0, key))[field_index] end
+lua function field_x(space, key, field_index) return (box.select(space, 0, key))[tonumber(field_index)] end
---
...
-call field_x(0, 'pass', 0)
+call field_x('0', 'pass', '0')
Found 1 tuple:
[1936941424]
-call field_x(0, 'pass', 1)
+call field_x('0', 'pass', '1')
Found 1 tuple:
['new']
-call box.delete(0, 'pass')
+call box.delete('0', 'pass')
Found 1 tuple:
[1936941424, 'new', 1684234849]
lua dofile(...)
@@ -597,11 +597,11 @@ error: 'tuple.next(): bad arguments'
...
lua t:next(1)
---
- - nil
+error: 'tuple.next(): bad arguments'
...
lua t:next(t)
---
-error: 'tuple.next(): bad arguments'
+error: 'bad argument #2 to ''?'' (box.tuple.iterator expected, got userdata)'
...
lua t:next(t:next())
---
@@ -628,6 +628,23 @@ test
another field
one more
...
+lua t=box.tuple.new({'a', 'b', 'c', 'd'})
+---
+...
+lua for it,field in t:pairs() do print(field); end
+---
+a
+b
+c
+d
+...
+lua it, field = t:next()
+---
+...
+lua getmetatable(it)
+---
+ - box.tuple.iterator
+...
lua box.space[0]:truncate()
---
...
@@ -882,7 +899,7 @@ lua box.space[0]:update('test', ':p', 1, box.pack('ppp', 100, 2, 'every'))
...
lua box.space[0]:update('test', ':p', 1, box.pack('ppp', -100, 2, 'every'))
---
-error: 'Illegal parameters, incorrect packet format (expected a 32-bit int)'
+error: 'Field SPLICE error: offset is out of bound'
...
lua box.space[0]:truncate()
---
@@ -1169,19 +1186,19 @@ lua string.byte(box.pack('p', tonumber64(123)))
lua box.space[0]:truncate()
---
...
-call box.insert(0, 'tes1', 'tes2', 'tes3', 'tes4', 'tes5')
+call box.insert('0', 'tes1', 'tes2', 'tes3', 'tes4', 'tes5')
Found 1 tuple:
[829646196, 846423412, 863200628, 879977844, 896755060]
-call box.update(0, 'tes1', '#p', 0, '')
+call box.update('0', 'tes1', '#p', 0, '')
Found 1 tuple:
[846423412, 863200628, 879977844, 896755060]
-call box.update(0, 'tes2', '#p', 0, '')
+call box.update('0', 'tes2', '#p', 0, '')
Found 1 tuple:
[863200628, 879977844, 896755060]
-call box.update(0, 'tes3', '#p', 0, '')
+call box.update('0', 'tes3', '#p', 0, '')
Found 1 tuple:
[879977844, 896755060]
-call box.update(0, 'tes4', '#p', 0, '')
+call box.update('0', 'tes4', '#p', 0, '')
Found 1 tuple:
[896755060]
lua box.update(0, 'tes5', '#p', 0, '')
@@ -1402,12 +1419,12 @@ lua floor(1.1)
# Test box.tuple:slice()
-lua t=box.space[0]:insert(0, '1', '2', '3', '4', '5', '6', '7')
+lua t=box.tuple.new({'0', '1', '2', '3', '4', '5', '6', '7'})
---
...
lua t:slice(0)
---
- -
+ - 0
- 1
- 2
- 3
@@ -1456,26 +1473,75 @@ lua t:slice(7)
---
- 7
...
+lua t:slice(8)
+---
+error: 'tuple.slice(): start >= field count'
+...
lua t:slice(9)
---
-error: 'tuple.slice(): start must be less than end'
+error: 'tuple.slice(): start >= field count'
+...
+lua t:slice(100500)
+---
+error: 'tuple.slice(): start >= field count'
...
lua t:slice(9, -1)
---
-error: 'tuple.slice(): start must be less than end'
+error: 'tuple.slice(): start >= field count'
...
lua t:slice(6, -1)
---
- 6
...
-lua t:slice(9, 10)
+lua t:slice(4, 4)
---
error: 'tuple.slice(): start must be less than end'
...
-lua t:slice(500, 700)
+lua t:slice(6, 4)
---
error: 'tuple.slice(): start must be less than end'
...
+lua t:slice(0, 0)
+---
+error: 'tuple.slice(): end > field count'
+...
+lua t:slice(9, 10)
+---
+error: 'tuple.slice(): start >= field count'
+...
+lua t:slice(-7)
+---
+ - 1
+ - 2
+ - 3
+ - 4
+ - 5
+ - 6
+ - 7
+...
+lua t:slice(-8)
+---
+ - 0
+ - 1
+ - 2
+ - 3
+ - 4
+ - 5
+ - 6
+ - 7
+...
+lua t:slice(-9)
+---
+error: 'tuple.slice(): start >= field count'
+...
+lua t:slice(-100500)
+---
+error: 'tuple.slice(): start >= field count'
+...
+lua t:slice(500, 700)
+---
+error: 'tuple.slice(): start >= field count'
+...
lua box.space[0]:truncate()
---
...
diff --git a/test/box/lua.test b/test/box/lua.test
index a257d8e23281ba53c855432ff43db4b331eeb829..b9640c198fea573ec2afc7076361c5886bb94cb8 100644
--- a/test/box/lua.test
+++ b/test/box/lua.test
@@ -64,49 +64,49 @@ exec admin "lua function f1() return f1 end"
exec sql "call f1()"
exec sql "insert into t0 values (1, 'test box delete')"
-exec sql "call box.delete(0, '\1\0\0\0')"
-exec sql "call box.delete(0, '\1\0\0\0')"
+exec sql "call box.delete('0', '\1\0\0\0')"
+exec sql "call box.delete('0', '\1\0\0\0')"
exec sql "insert into t0 values (1, 'test box delete')"
exec admin "lua box.delete(0, 1)"
exec admin "lua box.delete(0, 1)"
exec sql "insert into t0 values ('abcd', 'test box delete')"
-exec sql "call box.delete(0, '\1\0\0\0')"
-exec sql "call box.delete(0, 'abcd')"
-exec sql "call box.delete(0, 'abcd')"
+exec sql "call box.delete('0', '\1\0\0\0')"
+exec sql "call box.delete('0', 'abcd')"
+exec sql "call box.delete('0', 'abcd')"
exec sql "insert into t0 values ('abcd', 'test box delete')"
exec admin "lua box.delete(0, 'abcd')"
exec admin "lua box.delete(0, 'abcd')"
-exec sql "call box.select(0, 0, 'abcd')"
+exec sql "call box.select('0', '0', 'abcd')"
exec sql "insert into t0 values ('abcd', 'test box.select()')"
-exec sql "call box.select(0, 0, 'abcd')"
+exec sql "call box.select('0', '0', 'abcd')"
exec admin "lua box.select(0, 0, 'abcd')"
exec admin "lua box.select(0, 0)"
exec admin "lua box.select(0, 1)"
exec admin "lua box.select(0)"
-exec sql "call box.replace(0, 'abcd', 'hello', 'world')"
-exec sql "call box.replace(0, 'defc', 'goodbye', 'universe')"
-exec sql "call box.select(0, 0, 'abcd')"
-exec sql "call box.select(0, 0, 'defc')"
-exec sql "call box.replace(0, 'abcd')"
-exec sql "call box.select(0, 0, 'abcd')"
-exec sql "call box.delete(0, 'abcd')"
-exec sql "call box.delete(0, 'defc')"
-exec sql "call box.insert(0, 'test', 'old', 'abcd')"
+exec sql "call box.replace('0', 'abcd', 'hello', 'world')"
+exec sql "call box.replace('0', 'defc', 'goodbye', 'universe')"
+exec sql "call box.select('0', '0', 'abcd')"
+exec sql "call box.select('0', '0', 'defc')"
+exec sql "call box.replace('0', 'abcd')"
+exec sql "call box.select('0', '0', 'abcd')"
+exec sql "call box.delete('0', 'abcd')"
+exec sql "call box.delete('0', 'defc')"
+exec sql "call box.insert('0', 'test', 'old', 'abcd')"
# test that insert produces a duplicate key error
-exec sql "call box.insert(0, 'test', 'old', 'abcd')"
-exec sql "call box.update(0, 'test', '=p=p', 0, 'pass', 1, 'new')"
-exec sql "call box.select(0, 0, 'pass')"
+exec sql "call box.insert('0', 'test', 'old', 'abcd')"
+exec sql "call box.update('0', 'test', '=p=p', '\0\0\0\0', 'pass', 1, 'new')"
+exec sql "call box.select('0', '0', 'pass')"
exec sql "call box.select_range(0, 0, 1, 'pass')"
-exec sql "call box.update(0, 'miss', '+p', 2, '\1\0\0\0')"
-exec sql "call box.update(0, 'pass', '+p', 2, '\1\0\0\0')"
-exec sql "call box.update(0, 'pass', '-p', 2, '\1\0\0\0')"
-exec sql "call box.update(0, 'pass', '-p', 2, '\1\0\0\0')"
+exec sql "call box.update('0', 'miss', '+p', 2, '\1\0\0\0')"
+exec sql "call box.update('0', 'pass', '+p', 2, '\1\0\0\0')"
+exec sql "call box.update('0', 'pass', '-p', 2, '\1\0\0\0')"
+exec sql "call box.update('0', 'pass', '-p', 2, '\1\0\0\0')"
exec admin "lua box.update(0, 'pass', '+p', 2, 1)"
-exec sql "call box.select(0, 0, 'pass')"
-exec admin "lua function field_x(space, key, field_index) return (box.select(space, 0, key))[field_index] end"
-exec sql "call field_x(0, 'pass', 0)"
-exec sql "call field_x(0, 'pass', 1)"
-exec sql "call box.delete(0, 'pass')"
+exec sql "call box.select('0', '0', 'pass')"
+exec admin "lua function field_x(space, key, field_index) return (box.select(space, 0, key))[tonumber(field_index)] end"
+exec sql "call field_x('0', 'pass', '0')"
+exec sql "call field_x('0', 'pass', '1')"
+exec sql "call box.delete('0', 'pass')"
fifo_lua = os.path.abspath("box/fifo.lua")
# don't log the path name
sys.stdout.push_filter("lua dofile(.*)", "lua dofile(...)")
@@ -163,6 +163,10 @@ exec admin "lua t=box.space[0]:replace('test', 'another field')"
exec admin "lua for k, v in t:pairs() do print(v) end"
exec admin "lua t=box.space[0]:replace('test', 'another field', 'one more')"
exec admin "lua for k, v in t:pairs() do print(v) end"
+exec admin "lua t=box.tuple.new({'a', 'b', 'c', 'd'})"
+exec admin "lua for it,field in t:pairs() do print(field); end"
+exec admin "lua it, field = t:next()"
+exec admin "lua getmetatable(it)"
exec admin "lua box.space[0]:truncate()"
exec admin "lua box.fiber.sleep(0)"
exec admin "lua box.fiber.sleep(0.01)"
@@ -369,11 +373,11 @@ exec admin "lua tonumber64('184467440737095516155')"
exec admin "lua string.byte(box.pack('p', tonumber64(123)))"
# test delete field
exec admin "lua box.space[0]:truncate()"
-exec sql "call box.insert(0, 'tes1', 'tes2', 'tes3', 'tes4', 'tes5')"
-exec sql "call box.update(0, 'tes1', '#p', 0, '')"
-exec sql "call box.update(0, 'tes2', '#p', 0, '')"
-exec sql "call box.update(0, 'tes3', '#p', 0, '')"
-exec sql "call box.update(0, 'tes4', '#p', 0, '')"
+exec sql "call box.insert('0', 'tes1', 'tes2', 'tes3', 'tes4', 'tes5')"
+exec sql "call box.update('0', 'tes1', '#p', 0, '')"
+exec sql "call box.update('0', 'tes2', '#p', 0, '')"
+exec sql "call box.update('0', 'tes3', '#p', 0, '')"
+exec sql "call box.update('0', 'tes4', '#p', 0, '')"
exec admin "lua box.update(0, 'tes5', '#p', 0, '')"
exec admin "lua box.space[0]:truncate()"
@@ -486,7 +490,7 @@ server.deploy(init_lua=None)
print """
# Test box.tuple:slice()
"""
-exec admin "lua t=box.space[0]:insert(0, '1', '2', '3', '4', '5', '6', '7')"
+exec admin "lua t=box.tuple.new({'0', '1', '2', '3', '4', '5', '6', '7'})"
exec admin "lua t:slice(0)"
exec admin "lua t:slice(-1)"
exec admin "lua t:slice(1)"
@@ -495,10 +499,19 @@ exec admin "lua t:slice(-1, 1)"
exec admin "lua t:slice(1, -1)"
exec admin "lua t:slice(1, 3)"
exec admin "lua t:slice(7)"
+exec admin "lua t:slice(8)"
exec admin "lua t:slice(9)"
+exec admin "lua t:slice(100500)"
exec admin "lua t:slice(9, -1)"
exec admin "lua t:slice(6, -1)"
+exec admin "lua t:slice(4, 4)"
+exec admin "lua t:slice(6, 4)"
+exec admin "lua t:slice(0, 0)"
exec admin "lua t:slice(9, 10)"
+exec admin "lua t:slice(-7)"
+exec admin "lua t:slice(-8)"
+exec admin "lua t:slice(-9)"
+exec admin "lua t:slice(-100500)"
exec admin "lua t:slice(500, 700)"
exec admin "lua box.space[0]:truncate()"
@@ -668,3 +681,4 @@ exec admin "lua box.tuple.new({false})"
exec admin "lua t = box.tuple.new('abc')"
exec admin "lua t"
exec admin "lua t:bsize()"
+exec admin silent "lua box.delete(0, 8989)"
diff --git a/test/box/net.box.result b/test/box/net.box.result
index 3465f79ece5ac8feed3efc4a8608c5487b37ce4c..0efdaa77f1fe22fdf0c54d876067c847a3b47bda 100644
--- a/test/box/net.box.result
+++ b/test/box/net.box.result
@@ -68,7 +68,7 @@ lua remote:select(0, 0, 345)
---
- 345: {'test1', 'test2'}
...
-lua remote:call('box.select', 0, 0, 345)
+lua remote:call('box.select', '0', '0', 345)
---
- 345: {'test1', 'test2'}
...
diff --git a/test/box/net.box.test b/test/box/net.box.test
index fca3756eb908b0217ef6b3f13231c3215d15b6c7..711d3cbc06b19079526aab3599f0cd8b1b3b721b 100644
--- a/test/box/net.box.test
+++ b/test/box/net.box.test
@@ -30,7 +30,7 @@ exec admin "lua remote:insert(0, 123, 'test1', 'test2')"
exec admin "lua remote:insert(0, 345, 'test1', 'test2')"
exec admin "lua remote:select(0, 0, 345)"
-exec admin "lua remote:call('box.select', 0, 0, 345)"
+exec admin "lua remote:call('box.select', '0', '0', 345)"
exec admin "lua box.select(0, 0, 345)"
diff --git a/test/box/socket.result b/test/box/socket.result
index c99e5ee6f02d2ea3786fbd62202131d6c0ac9965..8dd632cc452656af4d84bbbd2d6d99882d98cdab 100644
--- a/test/box/socket.result
+++ b/test/box/socket.result
@@ -133,7 +133,7 @@ lua s:error()
- 0
- Success
...
-lua n, status, error_code, error_str = s:send(string.rep('=', 200000), 0.0000001)
+lua n, status, error_code, error_str = s:send(string.rep('=', 8388608), 0.0000001)
---
...
lua type(n)
diff --git a/test/box/socket.test b/test/box/socket.test
index 1eaf57de9c26ec65313f556bbd94c627ccfc5fa6..eda462da2e556944b59b481b487c997599384c4b 100644
--- a/test/box/socket.test
+++ b/test/box/socket.test
@@ -82,8 +82,8 @@ exec admin "lua type(s:connect('127.0.0.1', '30303'))"
exec admin "lua s:send('ping')"
exec admin "lua s:error()"
-# timedout
-exec admin "lua n, status, error_code, error_str = s:send(string.rep('=', 200000), 0.0000001)"
+# timedout - try to send 64MB (8388608 * 8 bytes) in 0.0000001 sec
+exec admin "lua n, status, error_code, error_str = s:send(string.rep('=', 8388608), 0.0000001)"
exec admin "lua type(n)"
exec admin "lua type(status)"
exec admin "lua type(error_code)"
diff --git a/test/connector_c/tt.c b/test/connector_c/tt.c
index 0f4b495eb7fe452631ecb18ca3b84f7a21ed017a..db3b8d6c210707ba26c8657ca41444b41205d728 100644
--- a/test/connector_c/tt.c
+++ b/test/connector_c/tt.c
@@ -674,7 +674,7 @@ static void tt_tnt_net_delete(struct tt_test *test) {
static void tt_tnt_net_call(struct tt_test *test) {
struct tnt_tuple args;
tnt_tuple_init(&args);
- tnt_tuple(&args, "%d%d%s%s", 0, 333, "B", "C");
+ tnt_tuple(&args, "%s%d%s%s", "0", 333, "B", "C");
TT_ASSERT(tnt_call(&net, 0, "box.insert", &args) > 0);
TT_ASSERT(tnt_flush(&net) > 0);
tnt_tuple_free(&args);
@@ -701,7 +701,7 @@ static void tt_tnt_net_call_na(struct tt_test *test) {
while (tnt_next(&i)) {
struct tnt_reply *r = TNT_IREPLY_PTR(&i);
TT_ASSERT(r->code != 0);
- TT_ASSERT(strcmp(r->error, "Illegal parameters, tuple must have all indexed fields") == 0);
+ TT_ASSERT(strstr(r->error, "box.pack") != NULL);
}
tnt_iter_free(&i);
}
@@ -810,7 +810,7 @@ static void tt_tnt_lex_ws(struct tt_test *test) {
/* lex integer */
static void tt_tnt_lex_int(struct tt_test *test) {
unsigned char sz[] = "\f\r\n 123 34\n\t\r56 888L56 2147483646 2147483647 "
- "-2147483648 -2147483649 72057594037927935";
+ "-2147483648 -2147483649 72057594037927935";
struct tnt_lex l;
tnt_lex_init(&l, tnt_sql_keywords, sz, sizeof(sz) - 1);
struct tnt_tk *tk;
@@ -1119,7 +1119,7 @@ static void tt_tnt_sql_delete(struct tt_test *test) {
/* sql call */
static void tt_tnt_sql_call(struct tt_test *test) {
char *e = NULL;
- char q[] = "call box.insert(0, 454, 'abc', 'cba')";
+ char q[] = "call box.insert('0', 454, 'abc', 'cba')";
TT_ASSERT(tnt_query(&net, q, sizeof(q) - 1, &e) == 0);
TT_ASSERT(tnt_flush(&net) > 0);
struct tnt_iter i;
diff --git a/test/connector_c/update.c b/test/connector_c/update.c
index 4aa27709700fd77300016df9d119c0f278414149..4f357d7c1fee396770c7f2467058340816a88c7f 100644
--- a/test/connector_c/update.c
+++ b/test/connector_c/update.c
@@ -75,36 +75,36 @@ insert_tuple(struct tnt_tuple *tuple);
/** select tuple by key */
void
-select_tuple(i32 key);
+select_tuple(int32_t key);
/** update fields */
void
-update(i32 key, struct tnt_stream *stream);
+update(int32_t key, struct tnt_stream *stream);
/** add update fields operation: set int32 */
void
-update_set_i32(struct tnt_stream *stream, i32 field, i32 value);
+update_set_i32(struct tnt_stream *stream, int32_t field, int32_t value);
/** add update fields operation: set string */
void
-update_set_str(struct tnt_stream *stream, i32 field, char *str);
+update_set_str(struct tnt_stream *stream, int32_t field, char *str);
/** add update fields operation: splice string */
void
-update_splice_str(struct tnt_stream *stream, i32 field, i32 offset, i32 length,
+update_splice_str(struct tnt_stream *stream, int32_t field, int32_t offset, int32_t length,
char *list);
/** add update fields operation: delete field */
void
-update_delete_field(struct tnt_stream *stream, i32 field);
+update_delete_field(struct tnt_stream *stream, int32_t field);
/** add update fields operation: insert before int32 */
void
-update_insert_i32(struct tnt_stream *stream, i32 field, i32 value);
+update_insert_i32(struct tnt_stream *stream, int32_t field, int32_t value);
/** add update fields operation: insert before string */
void
-update_insert_str(struct tnt_stream *stream, i32 field, char *str);
+update_insert_str(struct tnt_stream *stream, int32_t field, char *str);
/** receive reply from server */
void
@@ -226,7 +226,7 @@ insert_tuple(struct tnt_tuple *tuple)
}
void
-select_tuple(i32 key)
+select_tuple(int32_t key)
{
struct tnt_list tuple_list;
tnt_list_init(&tuple_list);
@@ -241,7 +241,7 @@ select_tuple(i32 key)
}
void
-update(i32 key, struct tnt_stream *stream)
+update(int32_t key, struct tnt_stream *stream)
{
struct tnt_tuple *k = tnt_tuple(NULL, "%d", key);
if (tnt_update(tnt, 0, TNT_FLAG_RETURN, k, stream) < 0)
@@ -253,7 +253,7 @@ update(i32 key, struct tnt_stream *stream)
}
void
-update_set_i32(struct tnt_stream *stream, i32 field, i32 value)
+update_set_i32(struct tnt_stream *stream, int32_t field, int32_t value)
{
int result = tnt_update_assign(stream, field, (char *)&value, sizeof(value));
if (result < 0)
@@ -261,7 +261,7 @@ update_set_i32(struct tnt_stream *stream, i32 field, i32 value)
}
void
-update_set_str(struct tnt_stream *stream, i32 field, char *str)
+update_set_str(struct tnt_stream *stream, int32_t field, char *str)
{
int result = tnt_update_assign(stream, field, str, strlen(str));
if (result < 0)
@@ -269,7 +269,7 @@ update_set_str(struct tnt_stream *stream, i32 field, char *str)
}
void
-update_splice_str(struct tnt_stream *stream, i32 field, i32 offset, i32 length,
+update_splice_str(struct tnt_stream *stream, int32_t field, int32_t offset, int32_t length,
char *list)
{
int result = tnt_update_splice(stream, field, offset, length, list,
@@ -279,7 +279,7 @@ update_splice_str(struct tnt_stream *stream, i32 field, i32 offset, i32 length,
}
void
-update_delete_field(struct tnt_stream *stream, i32 field)
+update_delete_field(struct tnt_stream *stream, int32_t field)
{
int result = tnt_update_delete(stream, field);
if (result < 0)
@@ -287,7 +287,7 @@ update_delete_field(struct tnt_stream *stream, i32 field)
}
void
-update_insert_i32(struct tnt_stream *stream, i32 field, i32 value)
+update_insert_i32(struct tnt_stream *stream, int32_t field, int32_t value)
{
int result = tnt_update_insert(stream, field, (char *)&value,
sizeof(value));
@@ -296,7 +296,7 @@ update_insert_i32(struct tnt_stream *stream, i32 field, i32 value)
}
void
-update_insert_str(struct tnt_stream *stream, i32 field, char *str)
+update_insert_str(struct tnt_stream *stream, int32_t field, char *str)
{
int result = tnt_update_insert(stream, field, str, strlen(str));
if (result < 0)
@@ -347,16 +347,16 @@ print_tuple(struct tnt_tuple *tuple)
switch(size) {
case 1:
- printf("%"PRIi8" (0x%02"PRIx8")", *(i8 *)data, *(i8 *)data);
+ printf("%"PRIi8" (0x%02"PRIx8")", *(int8_t *)data, *(int8_t *)data);
break;
case 2:
- printf("%"PRIi16" (0x%04"PRIx16")", *(i16 *)data, *(i16 *)data);
+ printf("%"PRIi16" (0x%04"PRIx16")", *(int16_t *)data, *(int16_t *)data);
break;
case 4:
- printf("%"PRIi32" (0x%08"PRIx32")", *(i32 *)data, *(i32 *)data);
+ printf("%"PRIi32" (0x%08"PRIx32")", *(int32_t *)data, *(int32_t *)data);
break;
case 8:
- printf("%"PRIi64" (0x%016"PRIx64")", *(i64 *)data, *(i64 *)data);
+ printf("%"PRIi64" (0x%016"PRIx64")", *(int64_t *)data, *(int64_t *)data);
break;
default:
printf("'%.*s'", size, data);
diff --git a/test/connector_c/xlog_rpl.test b/test/connector_c/xlog_rpl.test
index f53063e350344442202df0b32f00c40e1cc2b1a9..5f774f785bc7ec7e841b009056badff89581d3d4 100644
--- a/test/connector_c/xlog_rpl.test
+++ b/test/connector_c/xlog_rpl.test
@@ -2,7 +2,7 @@ import subprocess
import sys
import os
-from lib.tarantool_box_server import TarantoolBoxServer
+from lib.tarantool_server import TarantoolServer
p = subprocess.Popen([os.path.join(builddir, "test/connector_c/xlog"),
os.path.abspath("connector_c/connector.xlog")],
diff --git a/test/lib/server.py b/test/lib/server.py
index 5730ffe979aa4a1a138528f5ee11b3b85420e8c9..8f292b14cb33b00a38aadc3ae36d96b467f1d8ca 100644
--- a/test/lib/server.py
+++ b/test/lib/server.py
@@ -57,17 +57,16 @@ class Server(object):
replication slaves. The server is started once at the beginning
of each suite, and stopped at the end."""
- def __new__(cls, core=None, module=None):
+ def __new__(cls, core=None):
if core == None:
return super(Server, cls).__new__(cls)
mdlname = "lib.{0}_server".format(core)
clsname = "{0}Server".format(core.title())
corecls = __import__(mdlname, fromlist=clsname).__dict__[clsname]
- return corecls.__new__(corecls, core, module)
+ return corecls.__new__(corecls, core)
- def __init__(self, core, module):
+ def __init__(self, core):
self.core = core
- self.module = module
self.re_vardir_cleanup = ['*.core.*', 'core']
self.process = None
self.default_config_name = None
@@ -75,7 +74,7 @@ class Server(object):
self.config = None
self.vardir = None
self.valgrind_log = "valgrind.log"
- self.valgrind_sup = os.path.join("share/", "%s_%s.sup" % (core, module))
+ self.valgrind_sup = os.path.join("share/", "%s.sup" % (core))
self.init_lua = None
self.default_suppression_name = "valgrind.sup"
self.pidfile = None
@@ -89,14 +88,13 @@ class Server(object):
def find_exe(self, builddir, silent=True):
"Locate server executable in the build dir or in the PATH."
- exe_name = self.default_bin_name()
path = builddir + os.pathsep + os.environ["PATH"]
if not silent:
print " Looking for server binary in {0} ...".format(path)
for dir in path.split(os.pathsep):
- exe = os.path.join(dir, exe_name)
+ exe = os.path.join(dir, self.default_bin_name)
if os.access(exe, os.X_OK):
return exe
diff --git a/test/lib/tarantool_box_server.py b/test/lib/tarantool_box_server.py
deleted file mode 100644
index 1e68c5a6e953aa9179fb46af928ef80d66327485..0000000000000000000000000000000000000000
--- a/test/lib/tarantool_box_server.py
+++ /dev/null
@@ -1,62 +0,0 @@
-import time
-import shutil
-import subprocess
-import yaml
-import ConfigParser
-from tarantool_server import TarantoolServer, TarantoolConfigFile
-from admin_connection import AdminConnection
-from box_connection import BoxConnection
-from memcached_connection import MemcachedConnection
-import time
-
-class TarantoolBoxServer(TarantoolServer):
- def __new__(cls, core="tarantool", module="box"):
- return TarantoolServer.__new__(cls)
-
- def __init__(self, core="tarantool", module="box"):
- TarantoolServer.__init__(self, core, module)
-
- def configure(self, config):
- TarantoolServer.configure(self, config)
- with open(self.config) as fp:
- dummy_section_name = "tarantool"
- config = ConfigParser.ConfigParser()
- config.readfp(TarantoolConfigFile(fp, dummy_section_name))
-
- self.primary_port = self.get_option_int(config, dummy_section_name, "primary_port")
- self.admin_port = self.get_option_int(config, dummy_section_name, "admin_port")
- self.memcached_port = self.get_option_int(config, dummy_section_name, "memcached_port")
-
- self.port = self.admin_port
- self.admin = AdminConnection("localhost", self.admin_port)
- self.sql = BoxConnection("localhost", self.primary_port)
- if self.memcached_port != 0:
- # Run memcached client
- self.memcached = MemcachedConnection('localhost', self.memcached_port)
-
- def get_option_int(self, config, section, option):
- if config.has_option(section, option):
- return config.getint(section, option)
- else:
- return 0
-
- def init(self):
- # init storage
- subprocess.check_call([self.binary, "--init-storage"],
- cwd = self.vardir,
- # catch stdout/stderr to not clutter output
- stdout = subprocess.PIPE,
- stderr = subprocess.PIPE)
-
- def get_param(self, param):
- data = self.admin.execute("show info", silent = True)
- info = yaml.load(data)["info"]
- return info[param]
-
- def wait_lsn(self, lsn):
- while True:
- curr_lsn = int(self.get_param("lsn"))
- if (curr_lsn >= lsn):
- break
- time.sleep(0.01)
-
diff --git a/test/lib/tarantool_server.py b/test/lib/tarantool_server.py
index ec9c3b527a3962adb303f3564cf08ab5617fab85..5ae0eb9f10dce8c85e29b92a932ae85352aed928 100644
--- a/test/lib/tarantool_server.py
+++ b/test/lib/tarantool_server.py
@@ -1,9 +1,67 @@
import os
+import sys
+import glob
+import time
+import yaml
import shutil
-import subprocess
import pexpect
+import traceback
+import subprocess
import ConfigParser
+import pprint
+
+import tarantool_preprocessor
+
from server import Server
+from box_connection import BoxConnection
+from test_suite import FilteredStream, Test
+from admin_connection import AdminConnection
+from memcached_connection import MemcachedConnection
+
+
+class FuncTest(Test):
+ def __init__(self, name, args, suite_ini):
+ Test.__init__(self, name, args, suite_ini)
+ self.name = name
+ self.result = name.replace(".test", ".result")
+ self.skip_cond = name.replace(".test", ".skipcond")
+ self.tmp_result = os.path.join(self.args.vardir,
+ os.path.basename(self.result))
+ self.reject = "{0}/test/{1}".format(self.args.builddir,
+ name.replace(".test", ".reject"))
+
+ def execute(self, server):
+ diagnostics = "unknown"
+ builddir = self.args.builddir
+ save_stdout = sys.stdout
+ try:
+ self.skip = 0
+ if os.path.exists(self.skip_cond):
+ sys.stdout = FilteredStream(self.tmp_result)
+ stdout_fileno = sys.stdout.stream.fileno()
+ execfile(self.skip_cond, dict(locals(), **server.__dict__))
+ sys.stdout.close()
+ sys.stdout = save_stdout
+ if not self.skip:
+ sys.stdout = FilteredStream(self.tmp_result)
+ stdout_fileno = sys.stdout.stream.fileno()
+ execfile(self.name, dict(locals(), **server.__dict__))
+ self.is_executed_ok = True
+ except Exception as e:
+ traceback.print_exc(e)
+ diagnostics = str(e)
+ finally:
+ if sys.stdout and sys.stdout != save_stdout:
+ sys.stdout.close()
+ sys.stdout = save_stdout;
+ self.is_executed = True
+
+ def __repr__(self):
+ return str([self.name, self.result, self.skip_cond, self.tmp_result,
+ self.reject])
+
+ __str__ = __repr__
+
class TarantoolConfigFile:
"""ConfigParser can't read files without sections, work it around"""
@@ -19,19 +77,13 @@ class TarantoolConfigFile:
# tarantool.cfg puts string values in quote
return self.fp.readline().replace("\"", '')
-
class TarantoolServer(Server):
- def __new__(cls, core=None, module=None):
- if module == None:
- return super(Server, cls).__new__(cls)
- mdlname = "lib.{0}_{1}_server".format(core, module)
- clsname = "{0}{1}Server".format(core.title(), module.title())
- modulecls = __import__(mdlname, fromlist=clsname).__dict__[clsname]
+ def __new__(cls, core="tarantool"):
+ return super(Server, cls).__new__(cls)
- return modulecls.__new__(modulecls, core, module)
-
- def __init__(self, core, module):
- Server.__init__(self, core, module)
+ def __init__(self, core="tarantool"):
+ Server.__init__(self, core)
+ self.default_bin_name = "tarantool_box"
self.default_config_name = "tarantool.cfg"
self.default_init_lua_name = "init.lua"
# append additional cleanup patterns
@@ -43,7 +95,7 @@ class TarantoolServer(Server):
'*.lua']
def find_exe(self, builddir, silent=True):
- return Server.find_exe(self, "{0}/src/{1}".format(builddir, self.module), silent)
+ return Server.find_exe(self, "{0}/src/box/".format(builddir), silent)
def configure(self, config):
Server.configure(self, config)
@@ -52,7 +104,24 @@ class TarantoolServer(Server):
dummy_section_name = "tarantool"
config = ConfigParser.ConfigParser()
config.readfp(TarantoolConfigFile(fp, dummy_section_name))
+
self.pidfile = config.get(dummy_section_name, "pid_file")
+ self.primary_port = self.get_option_int(config, dummy_section_name, "primary_port")
+ self.admin_port = self.get_option_int(config, dummy_section_name, "admin_port")
+ self.memcached_port = self.get_option_int(config, dummy_section_name, "memcached_port")
+
+ self.port = self.admin_port
+ self.admin = AdminConnection("localhost", self.admin_port)
+ self.sql = BoxConnection("localhost", self.primary_port)
+ if self.memcached_port != 0:
+ # Run memcached client
+ self.memcached = MemcachedConnection('localhost', self.memcached_port)
+
+ def find_tests(self, test_suite, suite_path):
+ for test_name in sorted(glob.glob(os.path.join(suite_path, "*.test"))):
+ for test_pattern in test_suite.args.tests:
+ if test_name.find(test_pattern) != -1:
+ test_suite.tests.append(FuncTest(test_name, test_suite.args, test_suite.ini))
def reconfigure(self, config, silent=False):
if config == None:
@@ -62,6 +131,32 @@ class TarantoolServer(Server):
shutil.copy(self.config, os.path.join(self.vardir, self.default_config_name))
self.admin.execute("reload configuration", silent=silent)
+ def get_option_int(self, config, section, option):
+ if config.has_option(section, option):
+ return config.getint(section, option)
+ else:
+ return 0
+
+ def init(self):
+ # init storage
+ subprocess.check_call([self.binary, "--init-storage"],
+ cwd = self.vardir,
+ # catch stdout/stderr to not clutter output
+ stdout = subprocess.PIPE,
+ stderr = subprocess.PIPE)
+
+ def get_param(self, param):
+ data = self.admin.execute("show info", silent = True)
+ info = yaml.load(data)["info"]
+ return info[param]
+
+ def wait_lsn(self, lsn):
+ while True:
+ curr_lsn = int(self.get_param("lsn"))
+ if (curr_lsn >= lsn):
+ break
+ time.sleep(0.01)
+
def version(self):
p = subprocess.Popen([self.binary, "--version"],
cwd = self.vardir,
@@ -83,7 +178,3 @@ class TarantoolServer(Server):
raise RuntimeError("'--gdb' and '--start-and-exit' can't be defined together")
self.server = pexpect.spawn(args[0], args[1:], cwd = self.vardir)
self.server.wait()
-
- def default_bin_name(self):
- return "{0}_{1}".format(self.core, self.module)
-
diff --git a/test/lib/test_suite.py b/test/lib/test_suite.py
index f3dfceb55d665b356eed08884dc716bddb547fa4..768086630dfa318925523a38cdc215647789633b 100644
--- a/test/lib/test_suite.py
+++ b/test/lib/test_suite.py
@@ -10,6 +10,7 @@ import difflib
import filecmp
import shlex
import time
+
from server import Server
import tarantool_preprocessor
import re
@@ -35,7 +36,7 @@ class FilteredStream:
for pattern, replacement in self.filters:
line = re.sub(pattern, replacement, line)
# don't write lines that are completely filtered out:
- skipped = original_len and len(line.strip()) == 0
+ skipped = original_len and not line.strip()
if skipped:
break
if not skipped:
@@ -87,8 +88,8 @@ class Test:
self.skip_cond = name.replace(".test", ".skipcond")
self.tmp_result = os.path.join(self.args.vardir,
os.path.basename(self.result))
- self.reject = "{0}/test/{1}".format(self.args.builddir,
- name.replace(".test", ".reject"))
+ self.reject = "{0}/test/{1}".format(self.args.builddir,
+ name.replace(".test", ".reject"))
self.is_executed = False
self.is_executed_ok = None
self.is_equal_result = None
@@ -109,31 +110,8 @@ class Test:
diagnostics = "unknown"
- save_stdout = sys.stdout
builddir = self.args.builddir
- try:
- self.skip = 0
- if os.path.exists(self.skip_cond):
- sys.stdout = FilteredStream(self.tmp_result)
- stdout_fileno = sys.stdout.stream.fileno()
- execfile(self.skip_cond, dict(locals(), **server.__dict__))
- sys.stdout.close()
- sys.stdout = save_stdout
-
-
- if not self.skip:
- sys.stdout = FilteredStream(self.tmp_result)
- stdout_fileno = sys.stdout.stream.fileno()
- execfile(self.name, dict(locals(), **server.__dict__))
- self.is_executed_ok = True
- except Exception as e:
- traceback.print_exc(e)
- diagnostics = str(e)
- finally:
- if sys.stdout and sys.stdout != save_stdout:
- sys.stdout.close()
- sys.stdout = save_stdout;
-
+ self.execute(server)
self.is_executed = True
if not self.skip:
@@ -148,7 +126,8 @@ class Test:
if self.skip:
print "[ skip ]"
-
+ if os.path.exists(self.tmp_result):
+ os.remove(self.tmp_result)
elif self.is_executed_ok and self.is_equal_result and self.is_valgrind_clean:
print "[ pass ]"
if os.path.exists(self.tmp_result):
@@ -223,7 +202,6 @@ class TestSuite:
self.ini = {}
self.ini["core"] = "tarantool"
- self.ini["module"] = "box"
if os.access(suite_path, os.F_OK) == False:
raise RuntimeError("Suite \"" + suite_path + \
@@ -233,68 +211,49 @@ class TestSuite:
config = ConfigParser.ConfigParser()
config.read(os.path.join(suite_path, "suite.ini"))
self.ini.update(dict(config.items("default")))
- self.ini["config"] = os.path.join(suite_path, self.ini["config"])
-
- if self.ini.has_key("init_lua"):
- self.ini["init_lua"] = os.path.join(suite_path,
- self.ini["init_lua"])
- else:
- self.ini["init_lua"] = None
- if self.ini.has_key("disabled"):
- self.ini["disabled"] = dict.fromkeys(self.ini["disabled"].split(" "))
- else:
- self.ini["disabled"] = dict()
-
- if self.ini.has_key("valgrind_disabled"):
- self.ini["valgrind_disabled"] = dict.fromkeys(self.ini["valgrind_disabled"].split(" "))
- else:
- self.ini["valgrind_disabled"] = dict()
+ for i in ["config", "init_lua"]:
+ self.ini[i] = os.path.join(suite_path, self.ini[i]) if i in self.ini else None
+ for i in ["disabled", "valgrind_disabled", "release_disabled"]:
+ self.ini[i] = dict.fromkeys(self.ini[i].split()) if i in self.ini else dict()
- if self.ini.has_key("release_disabled"):
- self.ini["release_disabled"] = dict.fromkeys(self.ini["release_disabled"].split(" "))
- else:
- self.ini["release_disabled"] = dict()
+ try:
+ self.server = Server(self.ini["core"])
+ self.ini["server"] = self.server
+ except Exception as e:
+ print e
+ raise RuntimeError("Unknown server: core = {0}".format(
+ self.ini["core"]))
print "Collecting tests in \"" + suite_path + "\": " +\
self.ini["description"] + "."
-
- for test_name in glob.glob(os.path.join(suite_path, "*.test")):
- for test_pattern in self.args.tests:
- if test_name.find(test_pattern) != -1:
- self.tests.append(Test(test_name, self.args, self.ini))
+ self.server.find_tests(self, suite_path);
print "Found " + str(len(self.tests)) + " tests."
def run_all(self):
"""For each file in the test suite, run client program
assuming each file represents an individual test."""
- try:
- server = Server(self.ini["core"], self.ini["module"])
- except Exception as e:
- print e
- raise RuntimeError("Unknown server: core = {0}, module = {1}".format(
- self.ini["core"], self.ini["module"]))
- if len(self.tests) == 0:
+ if not self.tests:
# noting to test, exit
return 0
- server.deploy(self.ini["config"],
- server.find_exe(self.args.builddir, silent=False),
+ self.server.deploy(self.ini["config"],
+ self.server.find_exe(self.args.builddir, silent=False),
self.args.vardir, self.args.mem, self.args.start_and_exit,
self.args.gdb, self.args.valgrind,
init_lua=self.ini["init_lua"], silent=False)
+
if self.args.start_and_exit:
print " Start and exit requested, exiting..."
exit(0)
- longsep = "=============================================================================="
- shortsep = "------------------------------------------------------------"
+ longsep = '='*70
+ shortsep = '-'*60
print longsep
print string.ljust("TEST", 48), "RESULT"
print shortsep
failed_tests = []
- self.ini["server"] = server
for test in self.tests:
sys.stdout.write(string.ljust(test.name, 48))
@@ -302,27 +261,26 @@ class TestSuite:
sys.stdout.flush()
test_name = os.path.basename(test.name)
- if test_name in self.ini["disabled"]:
- print "[ disabled ]"
- elif not server.debug and test_name in self.ini["release_disabled"]:
- print "[ disabled ]"
- elif self.args.valgrind and test_name in self.ini["valgrind_disabled"]:
+
+ if (test_name in self.ini["disabled"]
+ or not self.server.debug and test_name in self.ini["release_disabled"]
+ or self.args.valgrind and test_name in self.ini["valgrind_disabled"]):
print "[ disabled ]"
else:
- test.run(server)
+ test.run(self.server)
if not test.passed():
failed_tests.append(test.name)
print shortsep
- if len(failed_tests):
+ if failed_tests:
print "Failed {0} tests: {1}.".format(len(failed_tests),
", ".join(failed_tests))
- server.stop(silent=False)
- server.cleanup()
+ self.server.stop(silent=False)
+ self.server.cleanup()
- if self.args.valgrind and check_valgrind_log(server.valgrind_log):
+ if self.args.valgrind and check_valgrind_log(self.server.valgrind_log):
print " Error! There were warnings/errors in valgrind log file:"
- print_tail_n(server.valgrind_log, 20)
+ print_tail_n(self.server.valgrind_log, 20)
return 1
return len(failed_tests)
diff --git a/test/lib/unittest_server.py b/test/lib/unittest_server.py
index f63b33be1f44b6b54eebf0e3972e94cdef4e40a6..24ec2597d193e81acdb8254068c5e86d48c15818 100644
--- a/test/lib/unittest_server.py
+++ b/test/lib/unittest_server.py
@@ -1,16 +1,70 @@
-from server import Server
-import subprocess
-import sys
import os
+import re
+import sys
+import traceback
+import subprocess
+
+from subprocess import Popen, PIPE
+
+import tarantool_preprocessor
+
+from server import Server
+from test_suite import FilteredStream, Test
+
+
+class UnitTest(Test):
+ def __init__(self, name, args, suite_ini):
+ Test.__init__(self, name, args, suite_ini)
+ self.name = name + ".test"
+ self.result = name + ".result"
+ self.skip_cond = name + ".skipcond"
+ self.tmp_result = os.path.join(self.args.vardir,
+ os.path.basename(self.result))
+ self.reject = "{0}/test/{1}".format(self.args.builddir, name + ".reject")
+
+ def execute(self, server):
+ diagnostics = "unknown"
+ builddir = self.args.builddir
+ save_stdout = sys.stdout
+ try:
+ self.skip = 0
+ if os.path.exists(self.skip_cond):
+ sys.stdout = FilteredStream(self.tmp_result)
+ stdout_fileno = sys.stdout.stream.fileno()
+ execfile(self.skip_cond, dict(locals(), **server.__dict__))
+ sys.stdout.close()
+ sys.stdout = save_stdout
+ if not self.skip:
+ sys.stdout = FilteredStream(self.tmp_result)
+ stdout_fileno = sys.stdout.stream.fileno()
+ execs = [os.path.join(server.builddir, "test", self.name)]
+ proc = Popen(execs, stdout=PIPE)
+ sys.stdout.write(proc.communicate()[0])
+ self.is_executed_ok = True
+ except Exception as e:
+ traceback.print_exc(e)
+ diagnostics = str(e)
+ finally:
+ if sys.stdout and sys.stdout != save_stdout:
+ sys.stdout.close()
+ sys.stdout = save_stdout;
+ self.is_executed = True
+
+ def __repr__(self):
+ return str([self.name, self.result, self.skip_cond, self.tmp_result,
+ self.reject])
+
+ __str__ = __repr__
+
class UnittestServer(Server):
"""A dummy server implementation for unit test suite"""
- def __new__(cls, core="unittest", module="dummy"):
+ def __new__(cls, core="unittest"):
return Server.__new__(cls)
- def __init__(self, core="unittest", module="dummy"):
- Server.__init__(self, core, module)
+ def __init__(self, core="unittest"):
+ Server.__init__(self, core)
self.debug = False
def configure(self, config):
@@ -18,14 +72,8 @@ class UnittestServer(Server):
def deploy(self, config=None, binary=None, vardir=None,
mem=None, start_and_exit=None, gdb=None, valgrind=None,
valgrind_sup=None, init_lua=None, silent=True, need_init=True):
- self.vardir = vardir
- def run_test(name):
- p = subprocess.Popen([os.path.join(self.builddir, "test/unit", name)], stdout=subprocess.PIPE)
- p.wait()
- for line in p.stdout.readlines():
- sys.stdout.write(line)
- self.run_test = run_test
+ self.vardir = vardir
if not os.access(self.vardir, os.F_OK):
if (self.mem == True and check_tmpfs_exists() and
os.path.basename(self.vardir) == self.vardir):
@@ -39,5 +87,21 @@ class UnittestServer(Server):
def find_exe(self, builddir, silent=False):
self.builddir = builddir
+ def find_tests(self, test_suite, suite_path):
+ def patterned(name):
+ for i in test_suite.args.tests:
+ if name.find(i) != -1:
+ return True
+ return False
+
+ regexp = re.compile('([a-zA-Z0-9_]*).test')
+ for f in sorted(os.listdir(suite_path)):
+ if regexp.match(f):
+ f = os.path.join(suite_path, regexp.match(f).groups()[0]) + '.test'
+ if os.access(f, os.X_OK) and os.path.isfile(f) and patterned(f):
+ test_suite.tests.append(UnitTest(f[:-5], test_suite.args,
+ test_suite.ini));
+
+
def init(self):
pass
diff --git a/test/memcached/tarantool.cfg b/test/memcached/cfg/master.cfg
similarity index 79%
rename from test/memcached/tarantool.cfg
rename to test/memcached/cfg/master.cfg
index b3c09590bda0ac3e1ee14513a9863ebd7514adb5..0f83dcb1823bc095c9669de5274e848d81c8d448 100644
--- a/test/memcached/tarantool.cfg
+++ b/test/memcached/cfg/master.cfg
@@ -1,15 +1,18 @@
slab_alloc_arena = 0.1
pid_file = "box.pid"
-
logger="cat - >> tarantool.log"
+bind_ipaddr="INADDR_ANY"
+custom_proc_title="master"
primary_port = 33013
secondary_port = 33014
admin_port = 33015
memcached_port = 33016
-rows_per_wal = 50
+replication_port = 33017
+
+rows_per_wal = 200
space[0].enabled = 1
space[0].index[0].type = "HASH"
diff --git a/test/memcached/tarantool_memcached_bad.cfg b/test/memcached/cfg/tarantool_memcached_bad.cfg
similarity index 100%
rename from test/memcached/tarantool_memcached_bad.cfg
rename to test/memcached/cfg/tarantool_memcached_bad.cfg
diff --git a/test/memcached/tarantool_memcached_off.cfg b/test/memcached/cfg/tarantool_memcached_off.cfg
similarity index 100%
rename from test/memcached/tarantool_memcached_off.cfg
rename to test/memcached/cfg/tarantool_memcached_off.cfg
diff --git a/test/memcached/expirations.test b/test/memcached/expirations.test
index c941333f8fa1a538ef4ce59603fb7c236c419f39..5197d08aa7756a9c7209aa1aeaade2964911db3a 100644
--- a/test/memcached/expirations.test
+++ b/test/memcached/expirations.test
@@ -1,5 +1,24 @@
# encoding: tarantool
import time
+import yaml
+
+###################################
+def wait_for_next_lsn(lsn, serv):
+ serv_admin = serv.admin
+ while True:
+ if get_lsn(serv) != lsn:
+ return lsn
+ time.sleep(0.01)
+
+def get_lsn(serv):
+ serv_admin = serv.admin
+ resp = exec serv_admin silent "lua box.info.lsn"
+ return yaml.load(resp)[0]
+
+def wait(serv = server):
+ lsn = get_lsn(serv)
+ return wait_for_next_lsn(lsn, serv)
+###################################
print """# expire: after 1 second"""
@@ -9,7 +28,7 @@ exec memcached "set foo 0 1 6\r\nfooval\r\n"
print """# foo shoud be exists"""
exec memcached "get foo\r\n"
-time.sleep(1.5)
+wait()
print """# foo shoud expired"""
exec memcached "get foo\r\n"
@@ -33,11 +52,10 @@ exec memcached silent "set foo 0 %d 6\r\nfooval\r\n" % expire
print """# foo shoud be exists"""
exec memcached "get foo\r\n"
-time.sleep(2.2)
+wait()
print """# foo shoud expired"""
exec memcached "get foo\r\n"
-
print """# expire: time - 20 second"""
expire = time.time() - 20
@@ -47,7 +65,6 @@ exec memcached silent "set boo 0 %d 6\r\nbooval\r\n" % expire
print """# foo shoud expired"""
exec memcached "get boo\r\n"
-
print """# expire: after 2 second"""
print """# add add"""
@@ -56,7 +73,7 @@ exec memcached "add add 0 1 6\r\naddval\r\n"
print """# readd add - shoud be fail"""
exec memcached "add add 0 1 7\r\naddval1\r\n"
-time.sleep(2.2)
+wait()
print """# readd add - shoud be success"""
exec memcached "add add 0 1 7\r\naddval2\r\n"
diff --git a/test/memcached/flush-all.result b/test/memcached/flush-all.result
index 6722b889b4bca9cdbb3583ef7ea9bc1277ad468f..245d0f0f7421ceaef53c819f28dc51c2f9dd1bc0 100644
--- a/test/memcached/flush-all.result
+++ b/test/memcached/flush-all.result
@@ -19,7 +19,7 @@ VALUE foo 0 3
new
END
# and the other form, specifying a flush_all time...
-flush_all time + 2
+flush_all time + 1
OK
get foo
diff --git a/test/memcached/flush-all.test b/test/memcached/flush-all.test
index d7957749b7e09376e59b68c8558c1002d8a95ac2..41693ed020500708599c612e9e19197ad75a935e 100644
--- a/test/memcached/flush-all.test
+++ b/test/memcached/flush-all.test
@@ -1,5 +1,20 @@
# encoding: tarantool
import time
+import yaml
+
+###################################
+def get_memcached_len(serv):
+ serv_admin = serv.admin
+ resp = exec serv_admin silent "lua box.space[box.cfg.memcached_space]:len()"
+ return yaml.load(resp)[0]
+
+def wait_for_empty_space(serv = server):
+ serv_admin = serv.admin
+ while True:
+ if get_memcached_len(serv) == 0:
+ return
+ time.sleep(0.01)
+###################################
print """# Test flush_all with zero delay. """
exec memcached "set foo 0 0 6\r\nfooval\r\n"
@@ -12,14 +27,14 @@ exec memcached "set foo 0 0 3\r\nnew\r\n"
exec memcached "get foo\r\n"
print """# and the other form, specifying a flush_all time... """
-expire = time.time() + 2
-print "flush_all time + 2"
+expire = time.time() + 1
+print "flush_all time + 1"
print exec memcached silent "flush_all %d\r\n" % expire
exec memcached "get foo\r\n"
exec memcached "set foo 0 0 3\r\n123\r\n"
exec memcached "get foo\r\n"
-time.sleep(2.2)
+wait_for_empty_space()
exec memcached "get foo\r\n"
# resore default suite config
diff --git a/test/memcached/off.test b/test/memcached/off.test
index c886dede1c5f479b6cd859cf64dd8fc2fd7676d8..d7859dabc14f667bddaf664e91d5e9c5cf70fe73 100644
--- a/test/memcached/off.test
+++ b/test/memcached/off.test
@@ -15,7 +15,7 @@ print """
# stop current server
server.stop()
# start server with memcached off
-server.deploy("memcached/tarantool_memcached_off.cfg")
+server.deploy("memcached/cfg/tarantool_memcached_off.cfg")
# check values
exec admin "show configuration"
@@ -23,7 +23,7 @@ exec admin "show configuration"
server.stop()
# start server with memcached space conflict
sys.stdout.push_filter("(/\S+)+/tarantool", "tarantool")
-server.test_option("-c " + os.path.join(os.getcwd(), "memcached/tarantool_memcached_bad.cfg"))
+server.test_option("-c " + os.path.join(os.getcwd(), "memcached/cfg/tarantool_memcached_bad.cfg"))
sys.stdout.pop_filter()
# restore default server
diff --git a/test/memcached/suite.ini b/test/memcached/suite.ini
index abd820de1872dcd76f93f0274895e73ac37a76fa..3c8a675998a5d0f4ceb239807d7756b892380f4d 100644
--- a/test/memcached/suite.ini
+++ b/test/memcached/suite.ini
@@ -1,6 +1,6 @@
[default]
description = tarantool/box memcached tests
-config = tarantool.cfg
+config = cfg/master.cfg
disabled = cas.test
# put disabled in valgrind test here
-valgrind_disabled = expirations.test
+valgrind_disabled = expirations.test, repl.test
diff --git a/test/replication/cfg/hot_standby.cfg b/test/replication/cfg/hot_standby.cfg
index fc74b3539f9fe30a6b173f2f691567e6ad56d7ce..580e073cfecfae5cab5e873d8f398feda38e884b 100644
--- a/test/replication/cfg/hot_standby.cfg
+++ b/test/replication/cfg/hot_standby.cfg
@@ -2,8 +2,8 @@ slab_alloc_arena = 0.1
pid_file = "tarantool.pid"
logger="cat - >> tarantool.log"
-
bind_ipaddr="INADDR_ANY"
+custom_proc_title="hot_standby"
wal_dir="../"
snap_dir="../"
@@ -11,12 +11,15 @@ snap_dir="../"
primary_port = 33013
secondary_port = 33024
admin_port = 33025
+memcached_port = 33026
+replication_port=33017
-replication_port=33016
-custom_proc_title="hot_standby"
space[0].enabled = 1
space[0].index[0].type = "HASH"
space[0].index[0].unique = 1
space[0].index[0].key_field[0].fieldno = 0
space[0].index[0].key_field[0].type = "NUM"
+
+memcached_space = 2
+memcached_expire=true
diff --git a/test/replication/cfg/master.cfg b/test/replication/cfg/master.cfg
index 9118e6d22ee79571a91fe71a07062b6d105ad913..8069ab062c50ed765d90a02df4351c134716113d 100644
--- a/test/replication/cfg/master.cfg
+++ b/test/replication/cfg/master.cfg
@@ -2,15 +2,14 @@ slab_alloc_arena = 0.1
pid_file = "tarantool.pid"
logger="cat - >> tarantool.log"
-
bind_ipaddr="INADDR_ANY"
+custom_proc_title="master"
primary_port = 33013
secondary_port = 33014
admin_port = 33015
-
-replication_port=33016
-custom_proc_title="master"
+memcached_port = 33016
+replication_port = 33017
space[0].enabled = 1
space[0].index[0].type = "HASH"
@@ -18,3 +17,5 @@ space[0].index[0].unique = 1
space[0].index[0].key_field[0].fieldno = 0
space[0].index[0].key_field[0].type = "NUM"
+memcached_space = 2
+memcached_expire=true
diff --git a/test/replication/cfg/master_to_replica.cfg b/test/replication/cfg/master_to_replica.cfg
index 5d2ae2420cc0ee1f3924074f48c8335dfa60f3e2..2428d2c393bd01bbbb12e610287351b62664d6b5 100644
--- a/test/replication/cfg/master_to_replica.cfg
+++ b/test/replication/cfg/master_to_replica.cfg
@@ -2,15 +2,17 @@ slab_alloc_arena = 0.1
pid_file = "tarantool.pid"
logger="cat - >> tarantool.log"
-
bind_ipaddr="INADDR_ANY"
+custom_proc_title="master"
primary_port = 33013
secondary_port = 33014
admin_port = 33015
+memcached_port = 33016
+
+replication_port=33017
+replication_source = "127.0.0.1:33117"
-replication_port=33016
-custom_proc_title="master"
space[0].enabled = 1
space[0].index[0].type = "HASH"
@@ -18,4 +20,5 @@ space[0].index[0].unique = 1
space[0].index[0].key_field[0].fieldno = 0
space[0].index[0].key_field[0].type = "NUM"
-replication_source = "127.0.0.1:33116"
+memcached_space = 2
+memcached_expire=true
diff --git a/test/replication/cfg/replica.cfg b/test/replication/cfg/replica.cfg
index 271da4823e6615b384911e577df6dfffd1a34766..c214a3aef4f29c1cc19426c17a2a40d7982f14d7 100644
--- a/test/replication/cfg/replica.cfg
+++ b/test/replication/cfg/replica.cfg
@@ -2,15 +2,16 @@ slab_alloc_arena = 0.1
pid_file = "tarantool.pid"
logger="cat - >> tarantool.log"
-
bind_ipaddr="INADDR_ANY"
+custom_proc_title="replica"
primary_port = 33113
secondary_port = 33114
admin_port = 33115
+memcached_port = 33116
-replication_port=33116
-custom_proc_title="replica"
+replication_port=33117
+replication_source = 127.0.0.1:33017
space[0].enabled = 1
space[0].index[0].type = "HASH"
@@ -18,4 +19,5 @@ space[0].index[0].unique = 1
space[0].index[0].key_field[0].fieldno = 0
space[0].index[0].key_field[0].type = "NUM"
-replication_source = 127.0.0.1:33016
+memcached_space = 2
+memcached_expire=true
diff --git a/test/replication/cfg/replica_to_master.cfg b/test/replication/cfg/replica_to_master.cfg
index df97d6e341536dd90078f7c98ffa4daa4c0b03b0..1f7c10c31ea5ebb90cb2d2a92a3546520ac2969a 100644
--- a/test/replication/cfg/replica_to_master.cfg
+++ b/test/replication/cfg/replica_to_master.cfg
@@ -2,18 +2,20 @@ slab_alloc_arena = 0.1
pid_file = "tarantool.pid"
logger="cat - >> tarantool.log"
-
bind_ipaddr="INADDR_ANY"
+custom_proc_title="replica"
primary_port = 33113
secondary_port = 33114
admin_port = 33115
-
-replication_port=33116
-custom_proc_title="replica"
+memcached_port = 33116
+replication_port = 33117
space[0].enabled = 1
space[0].index[0].type = "HASH"
space[0].index[0].unique = 1
space[0].index[0].key_field[0].fieldno = 0
space[0].index[0].key_field[0].type = "NUM"
+
+memcached_space = 2
+memcached_expire=true
diff --git a/test/replication/consistent.result b/test/replication/consistent.result
index 24538e947d46da37728521d8564f4b7140df283c..d254e5c90726e1c8ca41df47d1e884c837232f3d 100644
--- a/test/replication/consistent.result
+++ b/test/replication/consistent.result
@@ -684,4 +684,4 @@ Found 1 tuple:
master lsn = 61
replica lsn = 61
insert into t0 values (0, 'replica is read only')
-An error occurred: ER_NONMASTER, 'Can't modify data on a replication slave. My master is: 127.0.0.1:33016'
+An error occurred: ER_NONMASTER, 'Can't modify data on a replication slave. My master is: 127.0.0.1:33017'
diff --git a/test/replication/consistent.test b/test/replication/consistent.test
index e978c417326c3edcc6b9937e957d04027e6514d7..b537f7baf9e215e443addb6ce09c033c6248b35c 100644
--- a/test/replication/consistent.test
+++ b/test/replication/consistent.test
@@ -1,7 +1,7 @@
# encoding: tarantool
import os
import time
-from lib.tarantool_box_server import TarantoolBoxServer
+from lib.tarantool_server import TarantoolServer
ID_BEGIN = 0
ID_STEP = 10
@@ -22,7 +22,7 @@ def select_tuples(server, begin, end):
master = server
# replica server
-replica = TarantoolBoxServer()
+replica = TarantoolServer()
replica.deploy("replication/cfg/replica.cfg",
replica.find_exe(self.args.builddir),
os.path.join(self.args.vardir, "replica"))
diff --git a/test/replication/hot_standby.test b/test/replication/hot_standby.test
index 4689c4bca79301f13d156dda12531624443690aa..8f8e68cf62147f5561d544e8b3a9c083512950cb 100644
--- a/test/replication/hot_standby.test
+++ b/test/replication/hot_standby.test
@@ -1,21 +1,21 @@
# encoding: tarantool
import os
import time
-from lib.tarantool_box_server import TarantoolBoxServer
+from lib.tarantool_server import TarantoolServer
# master server
master = server
master_sql = master.sql
# hot standby server
-hot_standby = TarantoolBoxServer()
+hot_standby = TarantoolServer()
hot_standby.deploy("replication/cfg/hot_standby.cfg",
hot_standby.find_exe(self.args.builddir),
os.path.join(self.args.vardir, "hot_standby"), need_init=False)
hot_standby_sql = hot_standby.sql
# replica server
-replica = TarantoolBoxServer()
+replica = TarantoolServer()
replica.deploy("replication/cfg/replica.cfg",
replica.find_exe(self.args.builddir),
os.path.join(self.args.vardir, "replica"))
diff --git a/test/replication/memcached.result b/test/replication/memcached.result
new file mode 100644
index 0000000000000000000000000000000000000000..fb1629897d9356a340f447a1c8b9563aac0da59c
--- /dev/null
+++ b/test/replication/memcached.result
@@ -0,0 +1,52 @@
+# set initial k-v pairs
+# wait and get last k-v pair from replica
+get 9
+VALUE 9 0 5
+good9
+END
+# make multiple cnanges with master
+# wait and get k-v's from replicas
+get 1 2 3 4 5 7 8 9 10
+VALUE 1 0 8
+good1afk
+VALUE 2 0 8
+kfagood2
+VALUE 3 0 2
+95
+VALUE 4 0 2
+45
+VALUE 5 0 5
+good5
+VALUE 7 0 21
+The expense of spirit
+VALUE 8 0 19
+in a waste of shame
+VALUE 9 0 18
+Is lust in action;
+VALUE 10 0 21
+and till action, lust
+END
+# get deleted value
+get 6
+END
+# flush all k-v on master and try to get them from replica
+get 10
+END
+# check that expiration is working properly on replica
+get 1
+VALUE 1 0 21
+The expense of spirit
+END
+get 1
+END
+# check that expiration is working properly, when replica becomes master
+reload configuration
+---
+ok
+...
+get 1
+VALUE 1 0 21
+The expense of spirit
+END
+get 1
+END
diff --git a/test/replication/memcached.test b/test/replication/memcached.test
new file mode 100644
index 0000000000000000000000000000000000000000..0152df2e3cd20200b7f89813956dfe3cd8c5e15f
--- /dev/null
+++ b/test/replication/memcached.test
@@ -0,0 +1,123 @@
+# encoding: tarantool
+import os
+import sys
+import time
+import yaml
+
+from lib.memcached_connection import MemcachedConnection
+from lib.tarantool_server import TarantoolServer
+
+sonet = """The expense of spirit
+in a waste of shame
+Is lust in action;
+and till action, lust""".split('\n')
+
+master = server
+master_memcached = master.memcached
+
+replica = TarantoolServer()
+replica.deploy("replication/cfg/replica.cfg",
+ replica.find_exe(self.args.builddir),
+ os.path.join(self.args.vardir, "replica"))
+replica_memcached = replica.memcached
+
+###################################
+def wait_for_lsn(lsn, serv):
+ serv_admin = serv.admin
+ while True:
+ if get_lsn(serv) == lsn:
+ return lsn
+ time.sleep(0.01)
+
+def wait_for_next_lsn(lsn, serv):
+ serv_admin = serv.admin
+ while True:
+ if get_lsn(serv) != lsn:
+ return lsn
+ time.sleep(0.01)
+
+def get_lsn(serv):
+ serv_admin = serv.admin
+ resp = exec serv_admin silent "lua box.info.lsn"
+ return yaml.load(resp)[0]
+
+def wait(next = False, serv_master = master, serv_replica = replica):
+ if next:
+ lsn = get_lsn(serv_replica)
+ return wait_for_next_lsn(lsn, serv_replica)
+ else:
+ lsn = get_lsn(serv_master)
+ return wait_for_lsn(lsn, serv_replica)
+
+def get_memcached_len(serv):
+ serv_admin = serv.admin
+ resp = exec serv_admin silent "lua box.space[box.cfg.memcached_space]:len()"
+ return yaml.load(resp)[0]
+
+
+def wait_for_empty_space(serv):
+ serv_admin = serv.admin
+ while True:
+ if get_memcached_len(serv) == 0:
+ return
+ time.sleep(0.01)
+
+###################################
+
+print """# set initial k-v pairs"""
+for i in xrange(10):
+ exec master_memcached silent "set %d 0 0 5\r\ngood%d\r\n" % (i, i)
+
+print """# wait and get last k-v pair from replica"""
+wait()
+exec replica_memcached "get 9\r\n"
+
+print """# make multiple cnanges with master"""
+answer = exec master_memcached silent "gets 9\r\n"
+cas = int(answer.split()[4])
+exec master_memcached silent "append 1 0 0 3\r\nafk\r\n"
+exec master_memcached silent "prepend 2 0 0 3\r\nkfa\r\n"
+exec master_memcached silent "set 3 0 0 2\r\n80\r\n"
+exec master_memcached silent "set 4 0 0 2\r\n60\r\n"
+exec master_memcached silent "delete 6\r\n"
+exec master_memcached silent "replace 7 0 0 %d\r\n%s\r\n" % (len(sonet[0]), sonet[0])
+exec master_memcached silent "replace 8 0 0 %d\r\n%s\r\n" % (len(sonet[1]), sonet[1])
+exec master_memcached silent "cas 9 0 0 %d %d\r\n%s\r\n" % (len(sonet[2]), cas, sonet[2])
+exec master_memcached silent "add 10 0 0 %d\r\n%s\r\n" % (len(sonet[3]), sonet[3])
+exec master_memcached silent "incr 3 15\r\n"
+exec master_memcached silent "decr 4 15\r\n"
+
+print """# wait and get k-v's from replicas"""
+wait()
+exec replica_memcached "get 1 2 3 4 5 7 8 9 10\r\n"
+
+print """# get deleted value"""
+exec replica_memcached "get 6\r\n"
+
+print """# flush all k-v on master and try to get them from replica"""
+exec master_memcached silent "flush_all\r\n"
+wait_for_empty_space(replica)
+exec replica_memcached "get 10\r\n"
+
+
+print """# check that expiration is working properly on replica"""
+exec master_memcached silent "set 1 0 1 %d\r\n%s\r\n" % (len(sonet[0]), sonet[0])
+wait()
+exec replica_memcached "get 1\r\n"
+wait(True)
+exec replica_memcached "get 1\r\n"
+
+print """# check that expiration is working properly, when replica becomes master"""
+exec master_memcached silent "set 1 0 1 %d\r\n%s\r\n" % (len(sonet[0]), sonet[0])
+replica.reconfigure("replication/cfg/replica_to_master.cfg")
+exec replica_memcached "get 1\r\n"
+wait(True)
+exec replica_memcached "get 1\r\n"
+
+
+# resore default suite config
+replica.stop()
+replica.cleanup(True)
+master.stop()
+master.deploy(self.suite_ini["config"])
+# vim: syntax=python
diff --git a/test/replication/swap.test b/test/replication/swap.test
index 7f47bbe5007aec017a3bf94d1f243a040a0663fd..82afc13cc29f06f27e8c4da79e66adc3c0940785 100644
--- a/test/replication/swap.test
+++ b/test/replication/swap.test
@@ -1,7 +1,7 @@
# encoding: tarantool
import os
import time
-from lib.tarantool_box_server import TarantoolBoxServer
+from lib.tarantool_server import TarantoolServer
REPEAT = 20
ID_BEGIN = 0
@@ -23,7 +23,7 @@ def select_tuples(server, begin, end):
master = server
# replica server
-replica = TarantoolBoxServer()
+replica = TarantoolServer()
replica.deploy("replication/cfg/replica.cfg",
replica.find_exe(self.args.builddir),
os.path.join(self.args.vardir, "replica"))
diff --git a/test/share/tarantool_box.sup b/test/share/tarantool.sup
similarity index 100%
rename from test/share/tarantool_box.sup
rename to test/share/tarantool.sup
diff --git a/test/test-run.py b/test/test-run.py
index 2d8428376befa4cabf27529fe7c58d074639fc27..392ac2273d8834eba8228132a74e26f8c6f0ee8f 100755
--- a/test/test-run.py
+++ b/test/test-run.py
@@ -24,12 +24,14 @@ __author__ = "Konstantin Osipov <kostja.osipov@gmail.com>"
# OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
# SUCH DAMAGE.
-import argparse
-import os.path
import os
-import time
import sys
+import time
import string
+import shutil
+import os.path
+import argparse
+
from lib.test_suite import TestSuite
#
@@ -58,14 +60,6 @@ class Options:
suites, "box/show" will only enable tests starting with "show" in
"box" suite. Default: run all tests in all specified suites.""")
- parser.add_argument(
- "--module",
- dest = 'modules',
- metavar = "module",
- nargs="*",
- default = ["box"],
- help = "List of modules to test. Default: \"box\"")
-
parser.add_argument(
"--suite",
dest = 'suites',
@@ -162,8 +156,14 @@ def main():
options = Options()
oldcwd = os.getcwd()
# Change the current working directory to where all test
- # collections are supposed to reside.
- os.chdir(os.path.dirname(sys.argv[0]))
+ # collections are supposed to reside
+ # If script executed with (python test-run.py) dirname is ''
+ # so we need to make it .
+ path = os.path.dirname(sys.argv[0])
+ if not path:
+ path = '.'
+ os.chdir(path)
+
failed_tests = 0
try:
@@ -175,13 +175,9 @@ def main():
for root, dirs, names in os.walk(os.getcwd()):
if "suite.ini" in names:
suite_names.append(os.path.basename(root))
- suites = []
- for suite_name in suite_names:
- suite = TestSuite(suite_name, options.args)
- if suite.ini["module"] not in options.args.modules:
- continue
- suites.append(suite)
+ suites = [TestSuite(suite_name, options.args) for suite_name in sorted(suite_names)]
+
for suite in suites:
failed_tests += suite.run_all()
except RuntimeError as e:
diff --git a/test/unit/CMakeLists.txt b/test/unit/CMakeLists.txt
index 934e68d42dae60701eb64d45b6349016d578f32d..87e0a68347d29abd3ba061d70cd131d6159a9ce4 100644
--- a/test/unit/CMakeLists.txt
+++ b/test/unit/CMakeLists.txt
@@ -1,19 +1,27 @@
file(GLOB all_sources *.c *.m *.mm)
set_source_files_compile_flags(${all_sources})
-add_executable(rlist rlist.c test.c)
-add_executable(queue queue.c)
-add_executable(mhash mhash.c)
-add_executable(rope_basic rope_basic.c ${CMAKE_SOURCE_DIR}/src/rope.c)
-add_executable(rope_avl rope_avl.c ${CMAKE_SOURCE_DIR}/src/rope.c)
-add_executable(rope_stress rope_stress.c ${CMAKE_SOURCE_DIR}/src/rope.c)
-add_executable(rope rope.c ${CMAKE_SOURCE_DIR}/src/rope.c)
-add_executable(bit_test bit.c bit.c)
-target_link_libraries(bit_test bit)
-add_executable(bitset_basic_test bitset_basic.c)
-target_link_libraries(bitset_basic_test bitset)
-add_executable(bitset_iterator_test bitset_iterator.c)
-target_link_libraries(bitset_iterator_test bitset)
-add_executable(bitset_index_test bitset_index.c)
-target_link_libraries(bitset_index_test bitset)
-add_executable(base64 base64.c ${CMAKE_SOURCE_DIR}/third_party/base64.c)
+add_executable(rlist.test rlist.c test.c)
+add_executable(queue.test queue.c)
+add_executable(mhash.test mhash.c)
+add_executable(rope_basic.test rope_basic.c ${CMAKE_SOURCE_DIR}/src/rope.c)
+add_executable(rope_avl.test rope_avl.c ${CMAKE_SOURCE_DIR}/src/rope.c)
+add_executable(rope_stress.test rope_stress.c ${CMAKE_SOURCE_DIR}/src/rope.c)
+add_executable(rope.test rope.c ${CMAKE_SOURCE_DIR}/src/rope.c)
+add_executable(bit.test bit.c bit.c)
+target_link_libraries(bit.test bit)
+add_executable(bitset_basic.test bitset_basic.c)
+target_link_libraries(bitset_basic.test bitset)
+add_executable(bitset_iterator.test bitset_iterator.c)
+target_link_libraries(bitset_iterator.test bitset)
+add_executable(bitset_index.test bitset_index.c)
+target_link_libraries(bitset_index.test bitset)
+add_executable(base64.test base64.c ${CMAKE_SOURCE_DIR}/third_party/base64.c)
+add_executable(slab_cache.test slab_cache.c)
+target_link_libraries(slab_cache.test small)
+add_executable(region.test region.c)
+target_link_libraries(region.test small)
+add_executable(mempool.test mempool.c)
+target_link_libraries(mempool.test small)
+add_executable(small_alloc.test small_alloc.c)
+target_link_libraries(small_alloc.test small)
diff --git a/test/unit/base64.test b/test/unit/base64.test
deleted file mode 100644
index 0ed8d1b67d7103560b29ab48c9c8becec98619b8..0000000000000000000000000000000000000000
--- a/test/unit/base64.test
+++ /dev/null
@@ -1 +0,0 @@
-run_test("base64")
diff --git a/test/unit/bit.test b/test/unit/bit.test
deleted file mode 100644
index bd42398b072ea067924ad5ff0977c8109be9636c..0000000000000000000000000000000000000000
--- a/test/unit/bit.test
+++ /dev/null
@@ -1 +0,0 @@
-run_test("bit_test")
diff --git a/test/unit/bitset_basic.test b/test/unit/bitset_basic.test
deleted file mode 100644
index 080353944e138e8ed1fd5bb5d855c87de892c30a..0000000000000000000000000000000000000000
--- a/test/unit/bitset_basic.test
+++ /dev/null
@@ -1 +0,0 @@
-run_test("bitset_basic_test")
diff --git a/test/unit/bitset_index.test b/test/unit/bitset_index.test
deleted file mode 100644
index a7d9a5ec934971c94e78e1968aa7014b3111d0ce..0000000000000000000000000000000000000000
--- a/test/unit/bitset_index.test
+++ /dev/null
@@ -1 +0,0 @@
-run_test("bitset_index_test")
diff --git a/test/unit/bitset_iterator.test b/test/unit/bitset_iterator.test
deleted file mode 100644
index eb272521cb9be9cba2cf0389725ecafe2fc7e4b2..0000000000000000000000000000000000000000
--- a/test/unit/bitset_iterator.test
+++ /dev/null
@@ -1 +0,0 @@
-run_test("bitset_iterator_test")
diff --git a/test/unit/mempool.c b/test/unit/mempool.c
new file mode 100644
index 0000000000000000000000000000000000000000..426e0ecf2342ef47ee596c7071ad040bdffede09
--- /dev/null
+++ b/test/unit/mempool.c
@@ -0,0 +1,107 @@
+#include "lib/small/mempool.h"
+#include "unit.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+
+enum {
+ OBJSIZE_MIN = 2 * sizeof(int),
+ OBJSIZE_MAX = 4096,
+ OBJECTS_MAX = 10000,
+ OSCILLATION_MAX = 1024,
+ ITERATIONS_MAX = 500,
+};
+
+struct slab_cache cache;
+struct mempool pool;
+int objsize;
+size_t used;
+/* Streak type - allocating or freeing */
+bool allocating = true;
+/** Keep global to easily inspect the core. */
+long seed;
+
+static int *ptrs[OBJECTS_MAX];
+
+static inline void
+free_checked(int *ptr)
+{
+ fail_unless(ptr[0] < OBJECTS_MAX &&
+ ptr[objsize/sizeof(int)-1] == ptr[0]);
+ int pos = ptr[0];
+ fail_unless(ptrs[pos] == ptr);
+ fail_unless(mempool_used(&pool) == used);
+ ptrs[pos][0] = ptrs[pos][objsize/sizeof(int)-1] = INT_MAX;
+ mempool_free(&pool, ptrs[pos]);
+ ptrs[pos] = NULL;
+ used -= objsize;
+}
+
+static inline void *
+alloc_checked()
+{
+ int pos = rand() % OBJECTS_MAX;
+ if (ptrs[pos]) {
+ assert(ptrs[pos][0] == pos);
+ free_checked(ptrs[pos]);
+ }
+ if (! allocating)
+ return NULL;
+ fail_unless(mempool_used(&pool) == used);
+ used += objsize;
+ ptrs[pos] = mempool_alloc_nothrow(&pool);
+ ptrs[pos][0] = pos;
+ ptrs[pos][objsize/sizeof(int)-1] = pos;
+ return ptrs[pos];
+}
+
+
+static void
+basic_alloc_streak()
+{
+ int oscillation = rand() % OSCILLATION_MAX;
+ int i;
+
+ for (i = 0; i < oscillation; ++i) {
+ alloc_checked();
+ }
+}
+
+void
+mempool_basic()
+{
+ int i;
+ header();
+
+ mempool_create(&pool, &cache, objsize);
+
+ for (i = 0; i < ITERATIONS_MAX; i++) {
+ basic_alloc_streak();
+ allocating = ! allocating;
+#if 0
+ printf("%zu %zu\n", mempool_used(&pool),
+ mempool_total(&pool));
+#endif
+ }
+
+ mempool_destroy(&pool);
+
+ footer();
+}
+
+int main()
+{
+ seed = time(0);
+
+ srand(seed);
+
+ objsize = rand() % OBJSIZE_MAX;
+ if (objsize < OBJSIZE_MIN)
+ objsize = OBJSIZE_MIN;
+
+ slab_cache_create(&cache);
+
+ mempool_basic();
+
+ slab_cache_destroy(&cache);
+}
diff --git a/test/unit/mempool.result b/test/unit/mempool.result
new file mode 100644
index 0000000000000000000000000000000000000000..54b455e7f18e24afe25528b83b211b52c4f2bb6c
--- /dev/null
+++ b/test/unit/mempool.result
@@ -0,0 +1,3 @@
+ *** mempool_basic ***
+ *** mempool_basic: done ***
+
\ No newline at end of file
diff --git a/test/unit/mhash.test b/test/unit/mhash.test
deleted file mode 100644
index a537d0bcbbeb6938ea3f119d7401096c81d194f3..0000000000000000000000000000000000000000
--- a/test/unit/mhash.test
+++ /dev/null
@@ -1 +0,0 @@
-run_test("mhash")
diff --git a/test/unit/queue.test b/test/unit/queue.test
deleted file mode 100644
index 78ef0b17533ec9c2d5085770247fc97a6f609193..0000000000000000000000000000000000000000
--- a/test/unit/queue.test
+++ /dev/null
@@ -1 +0,0 @@
-run_test("queue")
diff --git a/test/unit/region.c b/test/unit/region.c
new file mode 100644
index 0000000000000000000000000000000000000000..59faf4a88179098951798410e2f16ef92bc52a7c
--- /dev/null
+++ b/test/unit/region.c
@@ -0,0 +1,84 @@
+#include "lib/small/region.h"
+#include "unit.h"
+#include <stdio.h>
+
+struct slab_cache cache;
+
+void
+region_basic()
+{
+ header();
+
+ struct region region;
+
+ region_create(®ion, &cache);
+
+ fail_unless(region_used(®ion) == 0);
+
+ void *ptr = region_alloc_nothrow(®ion, 10);
+
+ fail_unless(ptr);
+
+ fail_unless(region_used(®ion) == 10);
+
+ ptr = region_alloc_nothrow(®ion, 10000000);
+ fail_unless(ptr);
+
+ fail_unless(region_used(®ion) == 10000010);
+
+ region_free(®ion);
+
+ fail_unless(region_used(®ion) == 0);
+
+ printf("name of a new region: %s.\n", region_name(®ion));
+
+ region_set_name(®ion, "region");
+
+ printf("set new region name: %s.\n", region_name(®ion));
+
+ region_set_name(®ion, "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
+ "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
+ "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa");
+
+ printf("region name is truncated: %s.\n", region_name(®ion));
+
+ footer();
+}
+
+void
+region_test_truncate()
+{
+ header();
+
+ struct region region;
+
+ region_create(®ion, &cache);
+
+ void *ptr = region_alloc_nothrow(®ion, 10);
+
+ fail_unless(ptr);
+
+ size_t size = region_used(®ion);
+
+ region_alloc_nothrow(®ion, 10000);
+ region_alloc_nothrow(®ion, 10000000);
+
+ region_truncate(®ion, size);
+
+ fail_unless(region_used(®ion) == size);
+
+ region_free(®ion);
+
+ footer();
+}
+
+int main()
+{
+
+ slab_cache_create(&cache);
+
+ region_basic();
+ region_test_truncate();
+
+ slab_cache_destroy(&cache);
+}
diff --git a/test/unit/region.result b/test/unit/region.result
new file mode 100644
index 0000000000000000000000000000000000000000..d4b895ffff3e07d181d84b9e428b8d7c0e01a34a
--- /dev/null
+++ b/test/unit/region.result
@@ -0,0 +1,8 @@
+ *** region_basic ***
+name of a new region: .
+set new region name: region.
+region name is truncated: aaaaaaaaaaaaaaaaaaaaaaaaaaaaa.
+ *** region_basic: done ***
+ *** region_test_truncate ***
+ *** region_test_truncate: done ***
+
\ No newline at end of file
diff --git a/test/unit/rlist.test b/test/unit/rlist.test
deleted file mode 100644
index 5c8699160c2e47c699d67a94854f57394554b6d5..0000000000000000000000000000000000000000
--- a/test/unit/rlist.test
+++ /dev/null
@@ -1 +0,0 @@
-run_test("rlist")
diff --git a/test/unit/rope.test b/test/unit/rope.test
deleted file mode 100644
index 69d20903c14769eaf16b11fcfa5ee42027e8d2e1..0000000000000000000000000000000000000000
--- a/test/unit/rope.test
+++ /dev/null
@@ -1 +0,0 @@
-run_test("rope")
diff --git a/test/unit/rope_avl.test b/test/unit/rope_avl.test
deleted file mode 100644
index 416fc384267bd0b10d321702514f93cc2aa1905d..0000000000000000000000000000000000000000
--- a/test/unit/rope_avl.test
+++ /dev/null
@@ -1 +0,0 @@
-run_test("rope_avl")
diff --git a/test/unit/rope_basic.test b/test/unit/rope_basic.test
deleted file mode 100644
index ff8723e8a0cbdc70299965f88f8f8356c14faf71..0000000000000000000000000000000000000000
--- a/test/unit/rope_basic.test
+++ /dev/null
@@ -1 +0,0 @@
-run_test("rope_basic")
diff --git a/test/unit/rope_stress.test b/test/unit/rope_stress.test
deleted file mode 100644
index 6c3a3e7fc6ebeb21eaeb4d3f049c867695fac7ff..0000000000000000000000000000000000000000
--- a/test/unit/rope_stress.test
+++ /dev/null
@@ -1 +0,0 @@
-run_test("rope_stress")
diff --git a/test/unit/slab_cache.c b/test/unit/slab_cache.c
new file mode 100644
index 0000000000000000000000000000000000000000..aafd4e8529caa677d8714040f66ac46b77a4afee
--- /dev/null
+++ b/test/unit/slab_cache.c
@@ -0,0 +1,34 @@
+#include "lib/small/slab_cache.h"
+#include <stdio.h>
+#include <limits.h>
+#include <stdlib.h>
+#include <time.h>
+#include "unit.h"
+
+
+enum { NRUNS = 25, ITERATIONS = 1000, MAX_ALLOC = SLAB_MAX_SIZE + 9999 };
+static struct slab *runs[NRUNS];
+
+int main()
+{
+ srand(time(0));
+
+ struct slab_cache cache;
+ slab_cache_create(&cache);
+
+ int i = 0;
+
+ while (i < ITERATIONS) {
+ int run = random() % NRUNS;
+ int size = random() % MAX_ALLOC;
+ if (runs[run]) {
+ slab_put(&cache, runs[run]);
+ }
+ runs[run] = slab_get(&cache, size);
+ fail_unless(runs[run]);
+ slab_cache_check(&cache);
+ i++;
+ }
+
+ slab_cache_destroy(&cache);
+}
diff --git a/test/unit/slab_cache.result b/test/unit/slab_cache.result
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/test/unit/small_alloc.c b/test/unit/small_alloc.c
new file mode 100644
index 0000000000000000000000000000000000000000..6c7cdb51bd1a033abed9dc0b5fc97b642847cb31
--- /dev/null
+++ b/test/unit/small_alloc.c
@@ -0,0 +1,100 @@
+#include "lib/small/small.h"
+#include "unit.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+
+enum {
+ OBJSIZE_MIN = 3 * sizeof(int),
+ OBJSIZE_MAX = 5000,
+ OBJECTS_MAX = 1000,
+ OSCILLATION_MAX = 1024,
+ ITERATIONS_MAX = 5000,
+};
+
+struct slab_cache cache;
+struct small_alloc alloc;
+/* Streak type - allocating or freeing */
+bool allocating = true;
+/** Keep global to easily inspect the core. */
+long seed;
+
+static int *ptrs[OBJECTS_MAX];
+
+static inline void
+free_checked(int *ptr)
+{
+ fail_unless(ptr[0] < OBJECTS_MAX &&
+ ptr[ptr[1]/sizeof(int)-1] == ptr[0]);
+ int pos = ptr[0];
+ fail_unless(ptrs[pos] == ptr);
+ ptrs[pos][0] = ptrs[pos][ptr[1]/sizeof(int)-1] = INT_MAX;
+ smfree(&alloc, ptrs[pos]);
+ ptrs[pos] = NULL;
+}
+
+static inline void *
+alloc_checked()
+{
+ int pos = rand() % OBJECTS_MAX;
+ int size = rand() % OBJSIZE_MAX;
+ if (size < OBJSIZE_MIN || size > OBJSIZE_MAX)
+ size = OBJSIZE_MIN;
+
+ if (ptrs[pos]) {
+ assert(ptrs[pos][0] == pos);
+ free_checked(ptrs[pos]);
+ }
+ if (! allocating)
+ return NULL;
+ ptrs[pos] = smalloc_nothrow(&alloc, size);
+ ptrs[pos][0] = pos;
+ ptrs[pos][1] = size;
+ ptrs[pos][size/sizeof(int)-1] = pos;
+// printf("size: %d\n", size);
+ return ptrs[pos];
+}
+
+
+static void
+basic_alloc_streak()
+{
+ int oscillation = rand() % OSCILLATION_MAX;
+ int i;
+
+ for (i = 0; i < oscillation; ++i) {
+ alloc_checked();
+ }
+}
+
+void
+small_alloc_basic()
+{
+ int i;
+ header();
+
+ small_alloc_create(&alloc, &cache, OBJSIZE_MIN, OBJSIZE_MAX,
+ 1.3);
+
+ for (i = 0; i < ITERATIONS_MAX; i++) {
+ basic_alloc_streak();
+ allocating = ! allocating;
+ }
+
+ small_alloc_destroy(&alloc);
+
+ footer();
+}
+
+int main()
+{
+ seed = time(0);
+
+ srand(seed);
+
+ slab_cache_create(&cache);
+
+ small_alloc_basic();
+
+ slab_cache_destroy(&cache);
+}
diff --git a/test/unit/small_alloc.result b/test/unit/small_alloc.result
new file mode 100644
index 0000000000000000000000000000000000000000..24449606fe8cb6158e9e2d9c6708243c2a021e8c
--- /dev/null
+++ b/test/unit/small_alloc.result
@@ -0,0 +1,3 @@
+ *** small_alloc_basic ***
+ *** small_alloc_basic: done ***
+
\ No newline at end of file
diff --git a/test/unit/suite.ini b/test/unit/suite.ini
index 47106bc06f6f84d1cf4e8cae77974fae77fc076c..4d69f51aa5f459f513515612149f647ea337d22c 100644
--- a/test/unit/suite.ini
+++ b/test/unit/suite.ini
@@ -1,10 +1,4 @@
[default]
core = unittest
-module = box
-description = unit tests
-config = tarantool.cfg
-# put disabled tests here
-#disabled = xlog.test
-# put disabled in valgrind test here
-#valgrind_disabled = admin_coredump.test
-#release_disabled = errinj.test
+description = unit tests
+