21351592259

Committed 26 Jan 2026 08:50AM UTC coverage: 73.717% (-14.7%) from 88.463%

Build # 21351592259

Build Type

Pull #477

github

Committed by

ita-sammann

Commit Message

test: dump xlogs and snaps for debug

Pull Request Pull Request #477: test: attempt to mitigate replication bug on cluster start

Run Details

1 of 2 new or added lines in 1 file covered. (50.0%)

846 existing lines in 47 files now uncovered.

4266 of 5787 relevant lines covered (73.72%)

55.9 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

81.16

/crud/select.lua

local errors = require('errors')

local stash = require('crud.common.stash')
local utils = require('crud.common.utils')
local sharding = require('crud.common.sharding')
local select_executor = require('crud.select.executor')
local select_filters = require('crud.compare.filters')
local dev_checks = require('crud.common.dev_checks')
local schema = require('crud.common.schema')

local SelectError = errors.new_class('SelectError')

local select_module

local SELECT_FUNC_NAME = 'select_on_storage'

local select_module_compat_info = stash.get(stash.name.select_module_compat_info)
local has_merger = (utils.tarantool_supports_external_merger() and
    package.search('tuple.merger')) or utils.tarantool_has_builtin_merger()
if has_merger then
    select_module = require('crud.select.compat.select')
    select_module_compat_info.has_merger = true
else
    select_module = require('crud.select.compat.select_old')
    select_module_compat_info.has_merger = false
end

function checkers.vshard_call_mode(p)
    return p == 'write' or p == 'read'
end

local function select_on_storage(space_name, index_id, conditions, opts)
    dev_checks('string', 'number', '?table', {
        scan_value = 'table|cdata',
        after_tuple = '?table|cdata',
        tarantool_iter = 'number',
        limit = 'number',
        scan_condition_num = '?number',
        field_names = '?table',
        sharding_key_hash = '?number',
        sharding_func_hash = '?number',
        skip_sharding_hash_check = '?boolean',
        yield_every = '?number',
        fetch_latest_metadata = '?boolean',
    })

    local cursor = {}
    if opts.fetch_latest_metadata then
        local replica_schema_version
        if box.info.schema_version ~= nil then
            replica_schema_version = box.info.schema_version
        else
            replica_schema_version = box.internal.schema_version()
        end
        cursor.storage_info = {
            replica_uuid = box.info().uuid, -- Backward compatibility.
            replica_id = utils.get_self_vshard_replica_id(), -- Replacement for replica_uuid.
            replica_schema_version = replica_schema_version,
        }
    end

    local space = box.space[space_name]
    if space == nil then
        SelectError:assert(false, "Space %q doesn't exist", space_name)
    end

    local index = space.index[index_id]
    if index == nil then
        SelectError:assert(false, "Index with ID %s doesn't exist", index_id)
    end

    local _, err = sharding.check_sharding_hash(space_name,
                                                opts.sharding_func_hash,
                                                opts.sharding_key_hash,
                                                opts.skip_sharding_hash_check)

    if err ~= nil then
        return nil, err
    end

    local filter_func, err = select_filters.gen_func(space, index, conditions, {
        tarantool_iter = opts.tarantool_iter,
        scan_condition_num = opts.scan_condition_num,
    })
    if err ~= nil then
        return SelectError:assert(false, "Failed to generate tuples filter: %s", err)
    end

    -- execute select
    local resp, err = select_executor.execute(space, index, filter_func, {
        scan_value = opts.scan_value,
        after_tuple = opts.after_tuple,
        tarantool_iter = opts.tarantool_iter,
        limit = opts.limit,
        yield_every = opts.yield_every,
    })
    if err ~= nil then
        return SelectError:assert(false, "Failed to execute select: %s", err)
    end

    if resp.tuples_fetched < opts.limit or opts.limit == 0 then
        cursor.is_end = true
    else
        local last_tuple = resp.tuples[#resp.tuples]
        cursor.after_tuple = last_tuple:totable()
    end

    cursor.stats = {
        tuples_lookup = resp.tuples_lookup,
        tuples_fetched = resp.tuples_fetched,
    }

    -- getting tuples with user defined fields (if `fields` option is specified)
    -- and fields that are needed for comparison on router (primary key + scan key)
    local filtered_tuples = schema.filter_tuples_fields(resp.tuples, opts.field_names)

    local result = {cursor, filtered_tuples}

    local select_module_compat_info = stash.get(stash.name.select_module_compat_info)
    if not select_module_compat_info.has_merger then
        if opts.fetch_latest_metadata then
            result[3] = cursor.storage_info.replica_schema_version
        end
    end

    return unpack(result)
end

select_module.storage_api = {[SELECT_FUNC_NAME] = select_on_storage}

return select_module

1	local errors = require('errors')	19✔
2
3	local stash = require('crud.common.stash')	19✔
4	local utils = require('crud.common.utils')	19✔
5	local sharding = require('crud.common.sharding')	19✔
6	local select_executor = require('crud.select.executor')	19✔
7	local select_filters = require('crud.compare.filters')	19✔
8	local dev_checks = require('crud.common.dev_checks')	19✔
9	local schema = require('crud.common.schema')	19✔
10
11	local SelectError = errors.new_class('SelectError')	19✔
12
13	local select_module
14
15	local SELECT_FUNC_NAME = 'select_on_storage'	19✔
16
17	local select_module_compat_info = stash.get(stash.name.select_module_compat_info)	19✔
18	local has_merger = (utils.tarantool_supports_external_merger() and	38✔
19	package.search('tuple.merger')) or utils.tarantool_has_builtin_merger()	38✔
20	if has_merger then	19✔
21	select_module = require('crud.select.compat.select')	38✔
22	select_module_compat_info.has_merger = true	19✔
23	else
24	select_module = require('crud.select.compat.select_old')	×
25	select_module_compat_info.has_merger = false	×
26	end
27
28	function checkers.vshard_call_mode(p)	38✔
29	return p == 'write' or p == 'read'	12✔
30	end
31
32	local function select_on_storage(space_name, index_id, conditions, opts)
33	dev_checks('string', 'number', '?table', {	14✔
34	scan_value = 'table\|cdata',
35	after_tuple = '?table\|cdata',
36	tarantool_iter = 'number',
37	limit = 'number',
38	scan_condition_num = '?number',
39	field_names = '?table',
40	sharding_key_hash = '?number',
41	sharding_func_hash = '?number',
42	skip_sharding_hash_check = '?boolean',
43	yield_every = '?number',
44	fetch_latest_metadata = '?boolean',
45	})
46
47	local cursor = {}	14✔
48	if opts.fetch_latest_metadata then	14✔
49	local replica_schema_version
UNCOV 50	if box.info.schema_version ~= nil then	×
UNCOV 51	replica_schema_version = box.info.schema_version	×
52	else
53	replica_schema_version = box.internal.schema_version()	×
54	end
UNCOV 55	cursor.storage_info = {	×
56	replica_uuid = box.info().uuid, -- Backward compatibility.
57	replica_id = utils.get_self_vshard_replica_id(), -- Replacement for replica_uuid.
58	replica_schema_version = replica_schema_version,
59	}
60	end
61
62	local space = box.space[space_name]	14✔
63	if space == nil then	14✔
UNCOV 64	SelectError:assert(false, "Space %q doesn't exist", space_name)	×
65	end
66
67	local index = space.index[index_id]	14✔
68	if index == nil then	14✔
69	SelectError:assert(false, "Index with ID %s doesn't exist", index_id)	×
70	end
71
72	local _, err = sharding.check_sharding_hash(space_name,	28✔
73	opts.sharding_func_hash,	14✔
74	opts.sharding_key_hash,	14✔
75	opts.skip_sharding_hash_check)	14✔
76
77	if err ~= nil then	14✔
UNCOV 78	return nil, err	×
79	end
80
81	local filter_func, err = select_filters.gen_func(space, index, conditions, {	28✔
82	tarantool_iter = opts.tarantool_iter,	14✔
83	scan_condition_num = opts.scan_condition_num,	14✔
84	})
85	if err ~= nil then	14✔
86	return SelectError:assert(false, "Failed to generate tuples filter: %s", err)	×
87	end
88
89	-- execute select
90	local resp, err = select_executor.execute(space, index, filter_func, {	28✔
91	scan_value = opts.scan_value,	14✔
92	after_tuple = opts.after_tuple,	14✔
93	tarantool_iter = opts.tarantool_iter,	14✔
94	limit = opts.limit,	14✔
95	yield_every = opts.yield_every,	14✔
96	})
97	if err ~= nil then	14✔
98	return SelectError:assert(false, "Failed to execute select: %s", err)	×
99	end
100
101	if resp.tuples_fetched < opts.limit or opts.limit == 0 then	14✔
102	cursor.is_end = true	12✔
103	else
104	local last_tuple = resp.tuples[#resp.tuples]	2✔
105	cursor.after_tuple = last_tuple:totable()	6✔
106	end
107
108	cursor.stats = {	14✔
109	tuples_lookup = resp.tuples_lookup,	14✔
110	tuples_fetched = resp.tuples_fetched,	14✔
111	}	14✔
112
113	-- getting tuples with user defined fields (if `fields` option is specified)
114	-- and fields that are needed for comparison on router (primary key + scan key)
115	local filtered_tuples = schema.filter_tuples_fields(resp.tuples, opts.field_names)	14✔
116
117	local result = {cursor, filtered_tuples}	14✔
118
119	local select_module_compat_info = stash.get(stash.name.select_module_compat_info)	14✔
120	if not select_module_compat_info.has_merger then	14✔
121	if opts.fetch_latest_metadata then	×
122	result[3] = cursor.storage_info.replica_schema_version	×
123	end
124	end
125
126	return unpack(result)	14✔
127	end
128
129	select_module.storage_api = {[SELECT_FUNC_NAME] = select_on_storage}	19✔
130
131	return select_module	19✔

tarantool / crud / 21351592259

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous