From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from smtp40.i.mail.ru (smtp40.i.mail.ru [94.100.177.100]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by dev.tarantool.org (Postfix) with ESMTPS id C54AC446443 for ; Sun, 11 Oct 2020 15:57:44 +0300 (MSK) From: Alexander Turenko Date: Sun, 11 Oct 2020 15:57:44 +0300 Message-Id: In-Reply-To: References: MIME-Version: 1.0 Content-Transfer-Encoding: 8bit Subject: [Tarantool-patches] [PATCH v2 11/15] module api: add box_key_def_dump_parts() List-Id: Tarantool development patches List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , To: Vladislav Shpilevoy Cc: tarantool-patches@dev.tarantool.org, Alexander Turenko The function dumps an opaque structure into a non-opaque array of structures in order to allow an external module to obtain information about the key definition. Part of #5273 --- src/box/key_def.c | 78 +++++++++++++++++++++ src/box/key_def.h | 13 ++++ src/exports.h | 1 + test/app-tap/module_api.c | 116 +++++++++++++++++++++++++++++++ test/app-tap/module_api.test.lua | 2 +- 5 files changed, 209 insertions(+), 1 deletion(-) diff --git a/src/box/key_def.c b/src/box/key_def.c index e2bcfe321..27fdbfbf6 100644 --- a/src/box/key_def.c +++ b/src/box/key_def.c @@ -513,6 +513,84 @@ box_key_def_delete(box_key_def_t *key_def) key_def_delete(key_def); } +box_key_part_def_t * +box_key_def_dump_parts(const box_key_def_t *key_def, uint32_t *part_count_ptr) +{ + struct region *region = &fiber()->gc; + size_t region_svp = region_used(region); + size_t size; + box_key_part_def_t *parts = region_alloc_array( + region, typeof(parts[0]), key_def->part_count, &size); + if (parts == NULL) { + diag_set(OutOfMemory, size, "region_alloc_array", "parts"); + return NULL; + } + + for (uint32_t i = 0; i < key_def->part_count; i++) { + const struct key_part *part = &key_def->parts[i]; + box_key_part_def_t *part_def = &parts[i]; + box_key_part_def_create(part_def); + + /* Set part->{fieldno,flags,field_type}. */ + part_def->fieldno = part->fieldno; + part_def->flags = 0; + if (key_part_is_nullable(part)) + part_def->flags |= BOX_KEY_PART_DEF_IS_NULLABLE; + assert(part->type >= 0 && part->type < field_type_MAX); + part_def->field_type = field_type_strs[part->type]; + + /* Set part->collation. */ + if (part->coll_id != COLL_NONE) { + struct coll_id *coll_id = coll_by_id(part->coll_id); + /* + * A collation may be removed after + * key_def creation. + */ + if (coll_id == NULL) { + diag_set(CollationError, + "key_def holds dead collation id %d", + part->coll_id); + region_truncate(region, region_svp); + return NULL; + } + /* + * A collation may be removed while the + * resulting key parts array is in use. + */ + char *collation = region_alloc(region, + coll_id->name_len + 1); + if (collation == NULL) { + diag_set(OutOfMemory, coll_id->name_len + 1, + "region_alloc", "part_def->collation"); + region_truncate(region, region_svp); + return NULL; + } + memcpy(collation, coll_id->name, coll_id->name_len); + collation[coll_id->name_len] = '\0'; + part_def->collation = collation; + } + + /* Set part->path. */ + if (part->path != NULL) { + char *path = region_alloc(region, part->path_len + 1); + if (path == NULL) { + diag_set(OutOfMemory, part->path_len + 1, + "region", "part_def->path"); + region_truncate(region, region_svp); + return NULL; + } + memcpy(path, part->path, part->path_len); + path[part->path_len] = '\0'; + part_def->path = path; + } + } + + if (part_count_ptr != NULL) + *part_count_ptr = key_def->part_count; + + return parts; +} + int box_tuple_compare(box_tuple_t *tuple_a, box_tuple_t *tuple_b, box_key_def_t *key_def) diff --git a/src/box/key_def.h b/src/box/key_def.h index 9d7785c59..a61b6e7e9 100644 --- a/src/box/key_def.h +++ b/src/box/key_def.h @@ -445,6 +445,19 @@ box_key_def_new_v2(box_key_part_def_t *parts, uint32_t part_count); API_EXPORT void box_key_def_delete(box_key_def_t *key_def); +/** + * Dump key part definitions of given key_def. + * + * The function allocates key parts and storage for pointer fields + * (e.g. collation names) on the box region. + * @sa (). + * + * fields that are unknown at given tarantool + * version are set to zero. The same for unknown bits. + */ +API_EXPORT box_key_part_def_t * +box_key_def_dump_parts(const box_key_def_t *key_def, uint32_t *part_count_ptr); + /** * Compare tuples using the key definition. * @param tuple_a first tuple diff --git a/src/exports.h b/src/exports.h index 604c1dfaa..8ffc4d887 100644 --- a/src/exports.h +++ b/src/exports.h @@ -30,6 +30,7 @@ EXPORT(box_insert) EXPORT(box_iterator_free) EXPORT(box_iterator_next) EXPORT(box_key_def_delete) +EXPORT(box_key_def_dump_parts) EXPORT(box_key_def_new) EXPORT(box_key_def_new_v2) EXPORT(box_key_part_def_create) diff --git a/test/app-tap/module_api.c b/test/app-tap/module_api.c index 26853dd9b..25c98ef63 100644 --- a/test/app-tap/module_api.c +++ b/test/app-tap/module_api.c @@ -378,6 +378,22 @@ test_key_def_api(lua_State *L) * modules (gh-5273, gh-5384). */ +/** + * Verify that two zero terminated strings are either both NULL + * or have equal values. + */ +static void +string_check_equal(const char *a, const char *b) +{ + if (a == NULL) { + assert(b == NULL); + } else { + assert(b != NULL); + assert(strlen(a) == strlen(b)); + assert(!strcmp(a, b)); + } +} + /** * Verify type and message of an error in the diagnostics area. * @@ -505,6 +521,25 @@ key_part_def_check_zeros(const box_key_part_def_t *part) assert((part->flags & unknown_flags) == 0); } +/** + * Check that two key part definitions are equal. + * + * It compares only known fields and flags, but ignores padding + * bytes and unknown flags. + */ +static void +key_part_def_check_equal(const box_key_part_def_t *a, + const box_key_part_def_t *b) +{ + uint32_t known_flags = key_part_def_known_flags(); + + assert(a->fieldno == b->fieldno); + assert((a->flags & known_flags) == (b->flags & known_flags)); + string_check_equal(a->field_type, b->field_type); + string_check_equal(a->collation, b->collation); + string_check_equal(a->path, b->path); +} + /** * Basic () and () * test. @@ -602,6 +637,86 @@ test_key_def_new_v2(struct lua_State *L) return 1; } +/** + * Basic () test. + */ +static int +test_key_def_dump_parts(struct lua_State *L) +{ + size_t region_svp = box_region_used(); + box_key_def_t *key_def = NULL; + box_key_part_def_t *dump = NULL; + uint32_t dump_part_count = 0; + + /* + * Create a key_def with a single key part with all fields + * and flags set to non-default values. + */ + box_key_part_def_t part; + key_part_def_set_nondefault(&part); + key_def = box_key_def_new_v2(&part, 1); + assert(key_def != NULL); + + /* + * Verify that the same values are dumped, but unknown + * fields and flags are set to zeros. + */ + dump = box_key_def_dump_parts(key_def, &dump_part_count); + assert(dump != NULL); + assert(dump_part_count == 1); + key_part_def_check_equal(&part, &dump[0]); + key_part_def_check_zeros(&dump[0]); + + /* We can pass NULL as . */ + dump = box_key_def_dump_parts(key_def, NULL); + assert(dump != NULL); + + /* Clean up. */ + box_key_def_delete(key_def); + + /* Create a key_def from two key part definitions. */ + box_key_part_def_t parts[2]; + box_key_part_def_create(&parts[0]); + box_key_part_def_create(&parts[1]); + parts[0].fieldno = 19; + parts[0].field_type = "unsigned"; + parts[0].path = "foo"; + parts[1].fieldno = 7; + parts[1].field_type = "string"; + parts[1].collation = "unicode"; + parts[1].flags |= BOX_KEY_PART_DEF_IS_NULLABLE; + key_def = box_key_def_new_v2(parts, 2); + assert(key_def != NULL); + + /* Verify how it'll be dumped. */ + dump = box_key_def_dump_parts(key_def, &dump_part_count); + assert(dump != NULL); + assert(dump_part_count == 2); + key_part_def_check_equal(&parts[0], &dump[0]); + key_part_def_check_equal(&parts[1], &dump[1]); + + /* Clean up. */ + box_key_def_delete(key_def); + + /* Can we again create a key_def from the dumped parts? */ + key_def = box_key_def_new_v2(dump, dump_part_count); + assert(key_def != NULL); + + /* Verify this dump based key_def. */ + dump = box_key_def_dump_parts(key_def, &dump_part_count); + assert(dump != NULL); + assert(dump_part_count == 2); + key_part_def_check_equal(&parts[0], &dump[0]); + key_part_def_check_equal(&parts[1], &dump[1]); + + /* Clean up. */ + box_key_def_delete(key_def); + box_region_truncate(region_svp); + + lua_pushboolean(L, 1); + return 1; +} + /* }}} key_def api v2 */ static int @@ -980,6 +1095,7 @@ luaopen_module_api(lua_State *L) {"test_tuple_encode", test_tuple_encode}, {"test_tuple_new", test_tuple_new}, {"test_key_def_new_v2", test_key_def_new_v2}, + {"test_key_def_dump_parts", test_key_def_dump_parts}, {NULL, NULL} }; luaL_register(L, "module_api", lib); diff --git a/test/app-tap/module_api.test.lua b/test/app-tap/module_api.test.lua index 03cfec2ff..b751d5b98 100755 --- a/test/app-tap/module_api.test.lua +++ b/test/app-tap/module_api.test.lua @@ -172,7 +172,7 @@ local function test_iscdata(test, module) end local test = require('tap').test("module_api", function(test) - test:plan(29) + test:plan(30) local status, module = pcall(require, 'module_api') test:is(status, true, "module") test:ok(status, "module is loaded") -- 2.25.0