5199459215

pending completion

Build # 5199459215

Build Type

push

github

Committed by

DifferentialOrange

Commit Message

Release 1.2.0

Overview

  This release add two new flags: `noreturn` to ignore return values
  excessive transfer and encoding/decoding for insert/replace/etc
  (performance improvement up to 10% for batch requests) and
  `fetch_latest_metadata` to force fetching latest space format metadata
  right after a live migration (performance overhead may be up to 15%).

New features
  * Add `noreturn` option for operations:
    `insert`, `insert_object`, `insert_many`, `insert_object_many`,
    `replace`, `replace_object`, `replace_many`, `insert_object_many`,
    `upsert`, `upsert_object`, `upsert_many`, `upsert_object_many`,
    `update`, `delete` (#267).

Bugfixes
  * Crud DML operations returning stale schema for metadata generation.
    Now you may use `fetch_latest_metadata` flag to work with latest
    schema (#236).

Run Details

1 of 1 new or added line in 1 file covered. (100.0%)

4549 of 4888 relevant lines covered (93.06%)

18261.17 hits per line

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

87.5

/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_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',
        after_tuple = '?table',
        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,
            replica_schema_version = replica_schema_version,
        }
    end

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

    local index = space.index[index_id]
    if index == nil then
        return cursor, SelectError:new("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, conditions, {
        tarantool_iter = opts.tarantool_iter,
        scan_condition_num = opts.scan_condition_num,
    })
    if err ~= nil then
        return cursor, SelectError:new("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 cursor, SelectError:new("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
    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

function select_module.init()
   _G._crud.select_on_storage = select_on_storage
end

return select_module

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

tarantool / crud / 5199459215

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