10768990700

Committed 09 Sep 2024 07:56AM UTC coverage: 85.882% (-0.02%) from 85.906%

Build # 10768990700

Build Type

push

github

Committed by

locker

Commit Message

test: add test for #10148

The fix itself is in the small submodule which is bumped in the previous
commit.

Closes #10148

NO_DOC=bugfix

(cherry picked from commit e4ce9e111)

Run Details

62984 of 114257 branches covered (55.12%)

93883 of 109316 relevant lines covered (85.88%)

2600057.09 hits per line

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

94.24

/src/box/vy_point_lookup.c

/*
 * Copyright 2010-2017, Tarantool AUTHORS, please see AUTHORS file.
 *
 * Redistribution and use in source and binary forms, with or
 * without modification, are permitted provided that the following
 * conditions are met:
 *
 * 1. Redistributions of source code must retain the above
 *    copyright notice, this list of conditions and the
 *    following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above
 *    copyright notice, this list of conditions and the following
 *    disclaimer in the documentation and/or other materials
 *    provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY AUTHORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
 * AUTHORS 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 "vy_point_lookup.h"

#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>

#include <small/region.h>
#include <small/rlist.h>

#include "fiber.h"

#include "vy_lsm.h"
#include "vy_stmt.h"
#include "vy_tx.h"
#include "vy_mem.h"
#include "vy_run.h"
#include "vy_cache.h"
#include "vy_history.h"

/**
 * Scan TX write set for given key.
 * Add one or no statement to the history list.
 */
static int
vy_point_lookup_scan_txw(struct vy_lsm *lsm, struct vy_tx *tx,
                         struct vy_entry key, struct vy_history *history)
{
        if (tx == NULL)
                return 0;
        lsm->stat.txw.iterator.lookup++;
        struct txv *txv =
                write_set_search_key(&tx->write_set, lsm, key);
        assert(txv == NULL || txv->lsm == lsm);
        if (txv == NULL)
                return 0;
        vy_stmt_counter_acct_tuple(&lsm->stat.txw.iterator.get,
                                   txv->entry.stmt);
        return vy_history_append_stmt(history, txv->entry);
}

/**
 * Scan LSM tree cache for given key.
 * Add one or no statement to the history list.
 */
static int
vy_point_lookup_scan_cache(struct vy_lsm *lsm, const struct vy_read_view **rv,
                           bool is_prepared_ok, struct vy_entry key,
                           struct vy_history *history)
{
        lsm->cache.stat.lookup++;
        struct vy_entry entry = vy_cache_get(&lsm->cache, key);

        if (entry.stmt == NULL || vy_stmt_lsn(entry.stmt) > (*rv)->vlsn ||
            (!is_prepared_ok && vy_stmt_is_prepared(entry.stmt)))
                return 0;

        vy_stmt_counter_acct_tuple(&lsm->cache.stat.get, entry.stmt);
        return vy_history_append_stmt(history, entry);
}

/**
 * Scan one particular mem.
 * Add found statements to the history list up to terminal statement.
 */
static int
vy_point_lookup_scan_mem(struct vy_lsm *lsm, struct vy_mem *mem,
                         const struct vy_read_view **rv, bool is_prepared_ok,
                         struct vy_entry key, struct vy_history *history,
                         int64_t *min_skipped_plsn)
{
        struct vy_mem_iterator mem_itr;
        vy_mem_iterator_open(&mem_itr, &lsm->stat.memory.iterator,
                             mem, ITER_EQ, key, rv, is_prepared_ok);
        struct vy_history mem_history;
        vy_history_create(&mem_history, &lsm->env->history_node_pool);
        int rc = vy_mem_iterator_next(&mem_itr, &mem_history);
        vy_history_splice(history, &mem_history);
        *min_skipped_plsn = MIN(*min_skipped_plsn, mem_itr.min_skipped_plsn);
        vy_mem_iterator_close(&mem_itr);
        return rc;

}

/**
 * Scan all mems that belongs to the LSM tree.
 * Add found statements to the history list up to terminal statement.
 */
static int
vy_point_lookup_scan_mems(struct vy_lsm *lsm, struct vy_tx *tx,
                          const struct vy_read_view **rv, bool is_prepared_ok,
                          struct vy_entry key, struct vy_history *history)
{
        assert(lsm->mem != NULL);
        int64_t min_skipped_plsn = INT64_MAX;
        if (vy_point_lookup_scan_mem(lsm, lsm->mem, rv, is_prepared_ok,
                                     key, history, &min_skipped_plsn) != 0)
                return -1;
        struct vy_mem *mem;
        rlist_foreach_entry(mem, &lsm->sealed, in_sealed) {
                if (vy_history_is_terminal(history))
                        break;
                if (vy_point_lookup_scan_mem(lsm, mem, rv, is_prepared_ok,
                                             key, history,
                                             &min_skipped_plsn) != 0)
                        return -1;
        }
        if (tx != NULL && min_skipped_plsn != INT64_MAX) {
                if (vy_tx_send_to_read_view(tx, min_skipped_plsn) != 0)
                        return -1;
                if (tx->state == VINYL_TX_ABORT) {
                        diag_set(ClientError, ER_TRANSACTION_CONFLICT);
                        return -1;
                }
        }
        return 0;
}

/**
 * Scan one particular slice.
 * Add found statements to the history list up to terminal statement.
 */
static int
vy_point_lookup_scan_slice(struct vy_lsm *lsm, struct vy_slice *slice,
                           const struct vy_read_view **rv, struct vy_entry key,
                           struct vy_history *history)
{
        /*
         * The format of the statement must be exactly the space
         * format with the same identifier to fully match the
         * format in vy_mem.
         */
        struct vy_run_iterator run_itr;
        vy_run_iterator_open(&run_itr, &lsm->stat.disk.iterator, slice,
                             ITER_EQ, key, rv, lsm->cmp_def, lsm->key_def,
                             lsm->disk_format);
        struct vy_history slice_history;
        vy_history_create(&slice_history, &lsm->env->history_node_pool);
        int rc = vy_run_iterator_next(&run_itr, &slice_history);
        vy_history_splice(history, &slice_history);
        vy_run_iterator_close(&run_itr);
        return rc;
}

/**
 * Find a range and scan all slices that belongs to the range.
 * Add found statements to the history list up to terminal statement.
 * All slices are pinned before first slice scan, so it's guaranteed
 * that complete history from runs will be extracted.
 */
static int
vy_point_lookup_scan_slices(struct vy_lsm *lsm, const struct vy_read_view **rv,
                            struct vy_entry key, struct vy_history *history)
{
        struct vy_range *range = vy_range_tree_find_by_key(&lsm->range_tree,
                                                           ITER_EQ, key);
        assert(range != NULL);
        int slice_count = range->slice_count;
        size_t region_svp = region_used(&fiber()->gc);
        if (slice_count == 0)
                return 0;
        struct vy_slice **slices =
                xregion_alloc_array(&fiber()->gc, typeof(slices[0]),
                                    slice_count);
        int i = 0;
        struct vy_slice *slice;
        rlist_foreach_entry(slice, &range->slices, in_range) {
                vy_slice_pin(slice);
                slices[i++] = slice;
        }
        assert(i == slice_count);
        int rc = 0;
        for (i = 0; i < slice_count; i++) {
                if (rc == 0 && !vy_history_is_terminal(history))
                        rc = vy_point_lookup_scan_slice(lsm, slices[i],
                                                        rv, key, history);
                vy_slice_unpin(slices[i]);
        }
        region_truncate(&fiber()->gc, region_svp);
        return rc;
}

int
vy_point_lookup(struct vy_lsm *lsm, struct vy_tx *tx,
                const struct vy_read_view **rv,
                struct vy_entry key, struct vy_entry *ret)
{
        /* All key parts must be set for a point lookup. */
        assert(vy_stmt_is_full_key(key.stmt, lsm->cmp_def));
        assert(tx == NULL || tx->state == VINYL_TX_READY);

        *ret = vy_entry_none();
        int rc = 0;

        /* History list */
        struct vy_history history, mem_history, disk_history;
        vy_history_create(&history, &lsm->env->history_node_pool);
        vy_history_create(&mem_history, &lsm->env->history_node_pool);
        vy_history_create(&disk_history, &lsm->env->history_node_pool);

        rc = vy_point_lookup_scan_txw(lsm, tx, key, &history);
        if (rc != 0 || vy_history_is_terminal(&history))
                goto done;

        bool is_prepared_ok = tx != NULL ? vy_tx_is_prepared_ok(tx) : false;
        rc = vy_point_lookup_scan_cache(lsm, rv, is_prepared_ok, key, &history);
        if (rc != 0 || vy_history_is_terminal(&history))
                goto done;

restart:
        rc = vy_point_lookup_scan_mems(lsm, tx, rv, is_prepared_ok,
                                       key, &mem_history);
        if (rc != 0 || vy_history_is_terminal(&mem_history))
                goto done;

        /* Save version before yield */
        uint32_t mem_version = lsm->mem->version;
        uint32_t mem_list_version = lsm->mem_list_version;

        rc = vy_point_lookup_scan_slices(lsm, rv, key, &disk_history);
        if (rc != 0)
                goto done;

        ERROR_INJECT(ERRINJ_VY_POINT_ITER_WAIT, {
                while (mem_list_version == lsm->mem_list_version)
                        fiber_sleep(0.01);
                /* Turn of the injection to avoid infinite loop */
                errinj(ERRINJ_VY_POINT_ITER_WAIT, ERRINJ_BOOL)->bparam = false;
        });

        if (tx != NULL && tx->state == VINYL_TX_ABORT) {
                /*
                 * The transaction was aborted while we were reading
                 * disk. We must stop now and return an error as this
                 * function could be called by a DML request aborted
                 * by a DDL operation: failing early will prevent it
                 * from dereferencing a destroyed space.
                 */
                diag_set(ClientError, ER_TRANSACTION_CONFLICT);
                rc = -1;
                goto done;
        }

        if (mem_list_version != lsm->mem_list_version) {
                /*
                 * Mem list was changed during yield. This could be rotation
                 * or a dump. In case of dump the memory referenced by
                 * statement history is gone and we need to reread new history.
                 * This in unnecessary in case of rotation but since we
                 * cannot distinguish these two cases we always restart.
                 */
                vy_history_cleanup(&mem_history);
                vy_history_cleanup(&disk_history);
                goto restart;
        }

        if (mem_version != lsm->mem->version) {
                /*
                 * Rescan the memory level if its version changed while we
                 * were reading disk, because there may be new statements
                 * matching the search key.
                 */
                vy_history_cleanup(&mem_history);
                rc = vy_point_lookup_scan_mems(lsm, tx, rv, is_prepared_ok,
                                               key, &mem_history);
                if (rc != 0)
                        goto done;
                if (vy_history_is_terminal(&mem_history))
                        vy_history_cleanup(&disk_history);
        }

done:
        vy_history_splice(&history, &mem_history);
        vy_history_splice(&history, &disk_history);

        if (rc == 0) {
                int upserts_applied;
                rc = vy_history_apply(&history, lsm->cmp_def,
                                      false, &upserts_applied, ret);
                lsm->stat.upsert.applied += upserts_applied;
        }
        vy_history_cleanup(&history);

        if (rc != 0)
                return -1;

        return 0;
}

int
vy_point_lookup_mem(struct vy_lsm *lsm, const struct vy_read_view **rv,
                    struct vy_entry key, struct vy_entry *ret)
{
        assert(vy_stmt_is_full_key(key.stmt, lsm->cmp_def));

        int rc;
        struct vy_history history;
        vy_history_create(&history, &lsm->env->history_node_pool);

        rc = vy_point_lookup_scan_cache(lsm, rv, /*is_prepared_ok=*/true,
                                        key, &history);
        if (rc != 0 || vy_history_is_terminal(&history))
                goto done;

        rc = vy_point_lookup_scan_mems(lsm, /*tx=*/NULL, rv,
                                       /*is_prepared_ok=*/true, key, &history);
        if (rc != 0 || vy_history_is_terminal(&history))
                goto done;

        *ret = vy_entry_none();
        goto out;
done:
        if (rc == 0) {
                int upserts_applied;
                rc = vy_history_apply(&history, lsm->cmp_def,
                                      true, &upserts_applied, ret);
                lsm->stat.upsert.applied += upserts_applied;
        }
out:
        vy_history_cleanup(&history);
        return rc;
}

1	/*
2	* Copyright 2010-2017, Tarantool AUTHORS, please see AUTHORS file.
3	*
4	* Redistribution and use in source and binary forms, with or
5	* without modification, are permitted provided that the following
6	* conditions are met:
7	*
8	* 1. Redistributions of source code must retain the above
9	* copyright notice, this list of conditions and the
10	* following disclaimer.
11	*
12	* 2. Redistributions in binary form must reproduce the above
13	* copyright notice, this list of conditions and the following
14	* disclaimer in the documentation and/or other materials
15	* provided with the distribution.
16	*
17	* THIS SOFTWARE IS PROVIDED BY AUTHORS ``AS IS'' AND
18	* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
19	* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
20	* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
21	* AUTHORS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
22	* INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
23	* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
24	* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
25	* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
26	* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
27	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
28	* THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
29	* SUCH DAMAGE.
30	*/
31	#include "vy_point_lookup.h"
32
33	#include <stdbool.h>
34	#include <stddef.h>
35	#include <stdint.h>
36
37	#include <small/region.h>
38	#include <small/rlist.h>
39
40	#include "fiber.h"
41
42	#include "vy_lsm.h"
43	#include "vy_stmt.h"
44	#include "vy_tx.h"
45	#include "vy_mem.h"
46	#include "vy_run.h"
47	#include "vy_cache.h"
48	#include "vy_history.h"
49
50	/**
51	* Scan TX write set for given key.
52	* Add one or no statement to the history list.
53	*/
54	static int
55	vy_point_lookup_scan_txw(struct vy_lsm lsm, struct vy_tx tx,	1,495,240✔
56	struct vy_entry key, struct vy_history *history)
57	{
58	if (tx == NULL)	1,495,240✔
59	return 0;	97✔
60	lsm->stat.txw.iterator.lookup++;	1,495,140✔
61	struct txv *txv =
62	write_set_search_key(&tx->write_set, lsm, key);	1,495,140✔
63	assert(txv == NULL \|\| txv->lsm == lsm);	1,495,140!
64	if (txv == NULL)	1,495,140✔
65	return 0;	1,489,720✔
66	vy_stmt_counter_acct_tuple(&lsm->stat.txw.iterator.get,	5,423✔
67	txv->entry.stmt);
68	return vy_history_append_stmt(history, txv->entry);	5,423✔
69	}
70
71	/**
72	* Scan LSM tree cache for given key.
73	* Add one or no statement to the history list.
74	*/
75	static int
76	vy_point_lookup_scan_cache(struct vy_lsm lsm, const struct vy_read_view *rv,	1,521,180✔
77	bool is_prepared_ok, struct vy_entry key,
78	struct vy_history *history)
79	{
80	lsm->cache.stat.lookup++;	1,521,180✔
81	struct vy_entry entry = vy_cache_get(&lsm->cache, key);	1,521,180!
82
83	if (entry.stmt == NULL \|\| vy_stmt_lsn(entry.stmt) > (*rv)->vlsn \|\|	1,521,180!
84	(!is_prepared_ok && vy_stmt_is_prepared(entry.stmt)))	518,163!
85	return 0;	1,521,180✔
86
87	vy_stmt_counter_acct_tuple(&lsm->cache.stat.get, entry.stmt);	518,163!
88	return vy_history_append_stmt(history, entry);	518,163!
89	}
90
91	/**
92	* Scan one particular mem.
93	* Add found statements to the history list up to terminal statement.
94	*/
95	static int
96	vy_point_lookup_scan_mem(struct vy_lsm lsm, struct vy_mem mem,	1,495,660✔
97	const struct vy_read_view **rv, bool is_prepared_ok,
98	struct vy_entry key, struct vy_history *history,
99	int64_t *min_skipped_plsn)
100	{
101	struct vy_mem_iterator mem_itr;
102	vy_mem_iterator_open(&mem_itr, &lsm->stat.memory.iterator,	1,495,660!
103	mem, ITER_EQ, key, rv, is_prepared_ok);
104	struct vy_history mem_history;
105	vy_history_create(&mem_history, &lsm->env->history_node_pool);	1,495,660!
106	int rc = vy_mem_iterator_next(&mem_itr, &mem_history);	1,495,660!
107	vy_history_splice(history, &mem_history);	1,495,660!
108	min_skipped_plsn = MIN(min_skipped_plsn, mem_itr.min_skipped_plsn);	1,495,660✔
109	vy_mem_iterator_close(&mem_itr);	1,495,660!
110	return rc;	1,495,660✔
111
112	}
113
114	/**
115	* Scan all mems that belongs to the LSM tree.
116	* Add found statements to the history list up to terminal statement.
117	*/
118	static int
119	vy_point_lookup_scan_mems(struct vy_lsm lsm, struct vy_tx tx,	1,028,040✔
120	const struct vy_read_view **rv, bool is_prepared_ok,
121	struct vy_entry key, struct vy_history *history)
122	{
123	assert(lsm->mem != NULL);	1,028,040!
124	int64_t min_skipped_plsn = INT64_MAX;	1,028,040✔
125	if (vy_point_lookup_scan_mem(lsm, lsm->mem, rv, is_prepared_ok,	1,028,040!
126	key, history, &min_skipped_plsn) != 0)
127	return -1;	1,028,040✔
128	struct vy_mem *mem;
129	rlist_foreach_entry(mem, &lsm->sealed, in_sealed) {	2,991,320✔
130	if (vy_history_is_terminal(history))	632,828!
131	break;	165,204✔
132	if (vy_point_lookup_scan_mem(lsm, mem, rv, is_prepared_ok,	467,624!
133	key, history,
134	&min_skipped_plsn) != 0)
135	return -1;	×
136	}
137	if (tx != NULL && min_skipped_plsn != INT64_MAX) {	1,028,040✔
138	if (vy_tx_send_to_read_view(tx, min_skipped_plsn) != 0)	3!
139	return -1;	×
140	if (tx->state == VINYL_TX_ABORT) {	3!
141	diag_set(ClientError, ER_TRANSACTION_CONFLICT);	×
142	return -1;	×
143	}
144	}
145	return 0;	1,028,040✔
146	}
147
148	/**
149	* Scan one particular slice.
150	* Add found statements to the history list up to terminal statement.
151	*/
152	static int
153	vy_point_lookup_scan_slice(struct vy_lsm lsm, struct vy_slice slice,	387,821✔
154	const struct vy_read_view **rv, struct vy_entry key,
155	struct vy_history *history)
156	{
157	/*
158	* The format of the statement must be exactly the space
159	* format with the same identifier to fully match the
160	* format in vy_mem.
161	*/
162	struct vy_run_iterator run_itr;
163	vy_run_iterator_open(&run_itr, &lsm->stat.disk.iterator, slice,	387,821!
164	ITER_EQ, key, rv, lsm->cmp_def, lsm->key_def,
165	lsm->disk_format);
166	struct vy_history slice_history;
167	vy_history_create(&slice_history, &lsm->env->history_node_pool);	387,821!
168	int rc = vy_run_iterator_next(&run_itr, &slice_history);	387,821!
169	vy_history_splice(history, &slice_history);	387,820!
170	vy_run_iterator_close(&run_itr);	387,820!
171	return rc;	387,820✔
172	}
173
174	/**
175	* Find a range and scan all slices that belongs to the range.
176	* Add found statements to the history list up to terminal statement.
177	* All slices are pinned before first slice scan, so it's guaranteed
178	* that complete history from runs will be extracted.
179	*/
180	static int
181	vy_point_lookup_scan_slices(struct vy_lsm lsm, const struct vy_read_view *rv,	801,202✔
182	struct vy_entry key, struct vy_history *history)
183	{
184	struct vy_range *range = vy_range_tree_find_by_key(&lsm->range_tree,	801,202✔
185	ITER_EQ, key);
186	assert(range != NULL);	801,202!
187	int slice_count = range->slice_count;	801,202✔
188	size_t region_svp = region_used(&fiber()->gc);	801,202!
189	if (slice_count == 0)	801,202✔
190	return 0;	620,554✔
191	struct vy_slice **slices =	180,648✔
192	xregion_alloc_array(&fiber()->gc, typeof(slices[0]),	180,648!
193	slice_count);
194	int i = 0;	180,648✔
195	struct vy_slice *slice;
196	rlist_foreach_entry(slice, &range->slices, in_range) {	766,217✔
197	vy_slice_pin(slice);	404,921✔
198	slices[i++] = slice;	404,921✔
199	}
200	assert(i == slice_count);	180,648!
201	int rc = 0;	180,648✔
202	for (i = 0; i < slice_count; i++) {	585,568✔
203	if (rc == 0 && !vy_history_is_terminal(history))	404,921!
204	rc = vy_point_lookup_scan_slice(lsm, slices[i],	387,821✔
205	rv, key, history);
206	vy_slice_unpin(slices[i]);	404,920✔
207	}
208	region_truncate(&fiber()->gc, region_svp);	180,647!
209	return rc;	180,647✔
210	}
211
212	int
213	vy_point_lookup(struct vy_lsm lsm, struct vy_tx tx,	1,495,240✔
214	const struct vy_read_view **rv,
215	struct vy_entry key, struct vy_entry *ret)
216	{
217	/* All key parts must be set for a point lookup. */
218	assert(vy_stmt_is_full_key(key.stmt, lsm->cmp_def));	1,495,240!
219	assert(tx == NULL \|\| tx->state == VINYL_TX_READY);	1,495,240!
220
221	*ret = vy_entry_none();	1,495,240!
222	int rc = 0;	1,495,240✔
223
224	/* History list */
225	struct vy_history history, mem_history, disk_history;
226	vy_history_create(&history, &lsm->env->history_node_pool);	1,495,240!
227	vy_history_create(&mem_history, &lsm->env->history_node_pool);	1,495,240!
228	vy_history_create(&disk_history, &lsm->env->history_node_pool);	1,495,240!
229
230	rc = vy_point_lookup_scan_txw(lsm, tx, key, &history);	1,495,240!
231	if (rc != 0 \|\| vy_history_is_terminal(&history))	1,495,240!
232	goto done;	5,423✔
233
234	bool is_prepared_ok = tx != NULL ? vy_tx_is_prepared_ok(tx) : false;	1,489,820!
235	rc = vy_point_lookup_scan_cache(lsm, rv, is_prepared_ok, key, &history);	1,489,820!
236	if (rc != 0 \|\| vy_history_is_terminal(&history))	1,489,820!
237	goto done;	517,659✔
238
239	restart:	972,159✔
240	rc = vy_point_lookup_scan_mems(lsm, tx, rv, is_prepared_ok,	972,423!
241	key, &mem_history);
242	if (rc != 0 \|\| vy_history_is_terminal(&mem_history))	972,423!
243	goto done;	171,221✔
244
245	/* Save version before yield */
246	uint32_t mem_version = lsm->mem->version;	801,202✔
247	uint32_t mem_list_version = lsm->mem_list_version;	801,202✔
248
249	rc = vy_point_lookup_scan_slices(lsm, rv, key, &disk_history);	801,202!
250	if (rc != 0)	801,201!
251	goto done;	×
252
253	ERROR_INJECT(ERRINJ_VY_POINT_ITER_WAIT, {	801,229!
254	while (mem_list_version == lsm->mem_list_version)
255	fiber_sleep(0.01);
256	/* Turn of the injection to avoid infinite loop */
257	errinj(ERRINJ_VY_POINT_ITER_WAIT, ERRINJ_BOOL)->bparam = false;
258	});
259
260	if (tx != NULL && tx->state == VINYL_TX_ABORT) {	801,201✔
261	/*
262	* The transaction was aborted while we were reading
263	* disk. We must stop now and return an error as this
264	* function could be called by a DML request aborted
265	* by a DDL operation: failing early will prevent it
266	* from dereferencing a destroyed space.
267	*/
268	diag_set(ClientError, ER_TRANSACTION_CONFLICT);	16!
269	rc = -1;	16✔
270	goto done;	16✔
271	}
272
273	if (mem_list_version != lsm->mem_list_version) {	801,185✔
274	/*
275	* Mem list was changed during yield. This could be rotation
276	* or a dump. In case of dump the memory referenced by
277	* statement history is gone and we need to reread new history.
278	* This in unnecessary in case of rotation but since we
279	* cannot distinguish these two cases we always restart.
280	*/
281	vy_history_cleanup(&mem_history);	264!
282	vy_history_cleanup(&disk_history);	264!
283	goto restart;	264✔
284	}
285
286	if (mem_version != lsm->mem->version) {	800,921✔
287	/*
288	* Rescan the memory level if its version changed while we
289	* were reading disk, because there may be new statements
290	* matching the search key.
291	*/
292	vy_history_cleanup(&mem_history);	24,753!
293	rc = vy_point_lookup_scan_mems(lsm, tx, rv, is_prepared_ok,	24,753!
294	key, &mem_history);
295	if (rc != 0)	24,753!
296	goto done;	×
297	if (vy_history_is_terminal(&mem_history))	24,753!
298	vy_history_cleanup(&disk_history);	×
299	}
300
301	done:	800,921✔
302	vy_history_splice(&history, &mem_history);	1,495,240!
303	vy_history_splice(&history, &disk_history);	1,495,240!
304
305	if (rc == 0) {	1,495,240✔
306	int upserts_applied;
307	rc = vy_history_apply(&history, lsm->cmp_def,	1,495,220!
308	false, &upserts_applied, ret);
309	lsm->stat.upsert.applied += upserts_applied;	1,495,220✔
310	}
311	vy_history_cleanup(&history);	1,495,240!
312
313	if (rc != 0)	1,495,240✔
314	return -1;	1,495,240✔
315
316	return 0;	1,495,220✔
317	}
318
319	int
320	vy_point_lookup_mem(struct vy_lsm lsm, const struct vy_read_view *rv,	31,363✔
321	struct vy_entry key, struct vy_entry *ret)
322	{
323	assert(vy_stmt_is_full_key(key.stmt, lsm->cmp_def));	31,363!
324
325	int rc;
326	struct vy_history history;
327	vy_history_create(&history, &lsm->env->history_node_pool);	31,363!
328
329	rc = vy_point_lookup_scan_cache(lsm, rv, /is_prepared_ok=/true,	31,363!
330	key, &history);
331	if (rc != 0 \|\| vy_history_is_terminal(&history))	31,363!
332	goto done;	504✔
333
334	rc = vy_point_lookup_scan_mems(lsm, /tx=/NULL, rv,	30,859!
335	/is_prepared_ok=/true, key, &history);
336	if (rc != 0 \|\| vy_history_is_terminal(&history))	30,859!
337	goto done;	666✔
338
339	*ret = vy_entry_none();	30,193!
340	goto out;	30,193✔
341	done:	1,170✔
342	if (rc == 0) {	1,170!
343	int upserts_applied;
344	rc = vy_history_apply(&history, lsm->cmp_def,	1,170!
345	true, &upserts_applied, ret);
346	lsm->stat.upsert.applied += upserts_applied;	1,170✔
347	}
348	out:	×
349	vy_history_cleanup(&history);	31,363!
350	return rc;	31,363✔
351	}

tarantool / tarantool / 10768990700

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