10923548804

Committed 18 Sep 2024 01:49PM UTC coverage: 85.943% (+0.02%) from 85.928%

Build # 10923548804

Build Type

push

github

Committed by

Buristan

Commit Message

datetime: introduce tz in datetime.parse()

There is an option tz in `datetime.parse()`, it was added in
commit 3c40366172e3 ("datetime, lua: date parsing functions").
The option is not documented, and the commit message says that
option `tz` is "Not yet implemented in this commit.".

The patch added tests and a doc request for this option.
The behaviour of the option `tz` is the same as with option
`tzoffset`:
- if timezone was not set in a parsed string then it is set to
  a value specified by `tz`
- if timezone was set in a parsed string then option `tz` is
  ignored

```
tarantool> date.parse("1970-01-01T01:00:00 MSK", { tz = 'Europe/Paris' })
---
- 1970-01-01T01:00:00 MSK
- 23
...

tarantool> date.parse("1970-01-01T01:00:00", { tz = 'Europe/Paris' })
---
- 1970-01-01T01:00:00 Europe/Paris
- 19
...
```

Follows up #6731
Fixes #10420

@TarantoolBot document
Title: Introduce option `tz` in `datetime.parse()`

The option `tz` is added in a function `datetime.parse()`.
The option set timezone to a passed value if it was not set in
a parsed string.

(cherry picked from commit c6bab23a6)

Run Details

63049 of 114311 branches covered (55.16%)

93945 of 109311 relevant lines covered (85.94%)

3415337.64 hits per line

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

92.81

/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);
        ERROR_INJECT_YIELD(ERRINJ_VY_POINT_LOOKUP_DELAY);
        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;

        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,933,110✔
56	struct vy_entry key, struct vy_history *history)
57	{
58	if (tx == NULL)	1,933,110✔
59	return 0;	97✔
60	lsm->stat.txw.iterator.lookup++;	1,933,020✔
61	struct txv *txv =
62	write_set_search_key(&tx->write_set, lsm, key);	1,933,020✔
63	assert(txv == NULL \|\| txv->lsm == lsm);	1,933,020!
64	if (txv == NULL)	1,933,020✔
65	return 0;	1,927,590✔
66	vy_stmt_counter_acct_tuple(&lsm->stat.txw.iterator.get,	5,425✔
67	txv->entry.stmt);
68	return vy_history_append_stmt(history, txv->entry);	5,425✔
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,	2,055,330✔
77	bool is_prepared_ok, struct vy_entry key,
78	struct vy_history *history)
79	{
80	lsm->cache.stat.lookup++;	2,055,330✔
81	struct vy_entry entry = vy_cache_get(&lsm->cache, key);	2,055,330!
82
83	if (entry.stmt == NULL \|\| vy_stmt_lsn(entry.stmt) > (*rv)->vlsn \|\|	2,055,330!
84	(!is_prepared_ok && vy_stmt_is_prepared(entry.stmt)))	672,713!
85	return 0;	2,055,330✔
86
87	vy_stmt_counter_acct_tuple(&lsm->cache.stat.get, entry.stmt);	672,713!
88	return vy_history_append_stmt(history, entry);	672,713!
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,	2,065,260✔
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,	2,065,260!
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);	2,065,260!
106	int rc = vy_mem_iterator_next(&mem_itr, &mem_history);	2,065,260!
107	vy_history_splice(history, &mem_history);	2,065,260!
108	min_skipped_plsn = MIN(min_skipped_plsn, mem_itr.min_skipped_plsn);	2,065,260✔
109	vy_mem_iterator_close(&mem_itr);	2,065,260!
110	return rc;	2,065,260✔
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,459,340✔
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,459,340!
124	int64_t min_skipped_plsn = INT64_MAX;	1,459,340✔
125	if (vy_point_lookup_scan_mem(lsm, lsm->mem, rv, is_prepared_ok,	1,459,340!
126	key, history, &min_skipped_plsn) != 0)
127	return -1;	1,459,340✔
128	struct vy_mem *mem;
129	rlist_foreach_entry(mem, &lsm->sealed, in_sealed) {	4,130,520✔
130	if (vy_history_is_terminal(history))	790,354!
131	break;	184,434✔
132	if (vy_point_lookup_scan_mem(lsm, mem, rv, is_prepared_ok,	605,920!
133	key, history,
134	&min_skipped_plsn) != 0)
135	return -1;	×
136	}
137	if (tx != NULL && min_skipped_plsn != INT64_MAX) {	1,459,340!
138	if (vy_tx_send_to_read_view(tx, min_skipped_plsn) != 0)	×
139	return -1;	×
140	if (tx->state == VINYL_TX_ABORT) {	×
141	diag_set(ClientError, ER_TRANSACTION_CONFLICT);	×
142	return -1;	×
143	}
144	}
145	return 0;	1,459,340✔
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,	930,690✔
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,	930,690!
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);	930,690!
168	int rc = vy_run_iterator_next(&run_itr, &slice_history);	930,690!
169	vy_history_splice(history, &slice_history);	930,689!
170	vy_run_iterator_close(&run_itr);	930,689!
171	return rc;	930,689✔
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,	1,057,760✔
182	struct vy_entry key, struct vy_history *history)
183	{
184	struct vy_range *range = vy_range_tree_find_by_key(&lsm->range_tree,	1,057,760✔
185	ITER_EQ, key);
186	assert(range != NULL);	1,057,760!
187	int slice_count = range->slice_count;	1,057,760✔
188	size_t region_svp = region_used(&fiber()->gc);	1,057,760!
189	if (slice_count == 0)	1,057,760✔
190	return 0;	652,149✔
191	struct vy_slice **slices =	405,608✔
192	xregion_alloc_array(&fiber()->gc, typeof(slices[0]),	405,608!
193	slice_count);
194	int i = 0;	405,608✔
195	struct vy_slice *slice;
196	rlist_foreach_entry(slice, &range->slices, in_range) {	1,777,100✔
197	vy_slice_pin(slice);	965,889✔
198	slices[i++] = slice;	965,889✔
199	}
200	assert(i == slice_count);	405,608!
201	ERROR_INJECT_YIELD(ERRINJ_VY_POINT_LOOKUP_DELAY);	405,612!
202	int rc = 0;	405,608✔
203	for (i = 0; i < slice_count; i++) {	1,371,500✔
204	if (rc == 0 && !vy_history_is_terminal(history))	965,889!
205	rc = vy_point_lookup_scan_slice(lsm, slices[i],	930,690✔
206	rv, key, history);
207	vy_slice_unpin(slices[i]);	965,888✔
208	}
209	region_truncate(&fiber()->gc, region_svp);	405,607!
210	return rc;	405,607✔
211	}
212
213	int
214	vy_point_lookup(struct vy_lsm lsm, struct vy_tx tx,	1,933,110✔
215	const struct vy_read_view **rv,
216	struct vy_entry key, struct vy_entry *ret)
217	{
218	/* All key parts must be set for a point lookup. */
219	assert(vy_stmt_is_full_key(key.stmt, lsm->cmp_def));	1,933,110!
220	assert(tx == NULL \|\| tx->state == VINYL_TX_READY);	1,933,110!
221
222	*ret = vy_entry_none();	1,933,110!
223	int rc = 0;	1,933,110✔
224
225	/* History list */
226	struct vy_history history, mem_history, disk_history;
227	vy_history_create(&history, &lsm->env->history_node_pool);	1,933,110!
228	vy_history_create(&mem_history, &lsm->env->history_node_pool);	1,933,110!
229	vy_history_create(&disk_history, &lsm->env->history_node_pool);	1,933,110!
230
231	rc = vy_point_lookup_scan_txw(lsm, tx, key, &history);	1,933,110!
232	if (rc != 0 \|\| vy_history_is_terminal(&history))	1,933,110!
233	goto done;	5,425✔
234
235	bool is_prepared_ok = tx != NULL ? vy_tx_is_prepared_ok(tx) : false;	1,927,690!
236	rc = vy_point_lookup_scan_cache(lsm, rv, is_prepared_ok, key, &history);	1,927,690!
237	if (rc != 0 \|\| vy_history_is_terminal(&history))	1,927,690!
238	goto done;	670,693✔
239
240	restart:	1,256,990✔
241	rc = vy_point_lookup_scan_mems(lsm, tx, rv, is_prepared_ok,	1,257,630!
242	key, &mem_history);
243	if (rc != 0 \|\| vy_history_is_terminal(&mem_history))	1,257,630!
244	goto done;	199,877✔
245
246	/* Save version before yield */
247	uint32_t mem_version = lsm->mem->version;	1,057,760✔
248	uint32_t mem_list_version = lsm->mem_list_version;	1,057,760✔
249
250	rc = vy_point_lookup_scan_slices(lsm, rv, key, &disk_history);	1,057,760!
251	if (rc != 0)	1,057,760!
252	goto done;	×
253
254	if (tx != NULL && tx->state == VINYL_TX_ABORT) {	1,057,760✔
255	/*
256	* The transaction was aborted while we were reading
257	* disk. We must stop now and return an error as this
258	* function could be called by a DML request aborted
259	* by a DDL operation: failing early will prevent it
260	* from dereferencing a destroyed space.
261	*/
262	diag_set(ClientError, ER_TRANSACTION_CONFLICT);	50!
263	rc = -1;	50✔
264	goto done;	50✔
265	}
266
267	if (mem_list_version != lsm->mem_list_version) {	1,057,710✔
268	/*
269	* Mem list was changed during yield. This could be rotation
270	* or a dump. In case of dump the memory referenced by
271	* statement history is gone and we need to reread new history.
272	* This in unnecessary in case of rotation but since we
273	* cannot distinguish these two cases we always restart.
274	*/
275	vy_history_cleanup(&mem_history);	640!
276	vy_history_cleanup(&disk_history);	640!
277	goto restart;	640✔
278	}
279
280	if (mem_version != lsm->mem->version) {	1,057,070✔
281	/*
282	* Rescan the memory level if its version changed while we
283	* were reading disk, because there may be new statements
284	* matching the search key.
285	*/
286	vy_history_cleanup(&mem_history);	76,086!
287	rc = vy_point_lookup_scan_mems(lsm, tx, rv, is_prepared_ok,	76,086!
288	key, &mem_history);
289	if (rc != 0)	76,086!
290	goto done;	×
291	if (vy_history_is_terminal(&mem_history))	76,086!
292	vy_history_cleanup(&disk_history);	×
293	}
294
295	done:	1,057,070✔
296	vy_history_splice(&history, &mem_history);	1,933,110!
297	vy_history_splice(&history, &disk_history);	1,933,110!
298
299	if (rc == 0) {	1,933,110✔
300	int upserts_applied;
301	rc = vy_history_apply(&history, lsm->cmp_def,	1,933,060!
302	false, &upserts_applied, ret);
303	lsm->stat.upsert.applied += upserts_applied;	1,933,060✔
304	}
305	vy_history_cleanup(&history);	1,933,110!
306
307	if (rc != 0)	1,933,110✔
308	return -1;	1,933,110✔
309
310	return 0;	1,933,060✔
311	}
312
313	int
314	vy_point_lookup_mem(struct vy_lsm lsm, const struct vy_read_view *rv,	127,642✔
315	struct vy_entry key, struct vy_entry *ret)
316	{
317	assert(vy_stmt_is_full_key(key.stmt, lsm->cmp_def));	127,642!
318
319	int rc;
320	struct vy_history history;
321	vy_history_create(&history, &lsm->env->history_node_pool);	127,642!
322
323	rc = vy_point_lookup_scan_cache(lsm, rv, /is_prepared_ok=/true,	127,642!
324	key, &history);
325	if (rc != 0 \|\| vy_history_is_terminal(&history))	127,642!
326	goto done;	2,020✔
327
328	rc = vy_point_lookup_scan_mems(lsm, /tx=/NULL, rv,	125,622!
329	/is_prepared_ok=/true, key, &history);
330	if (rc != 0 \|\| vy_history_is_terminal(&history))	125,622!
331	goto done;	2,739✔
332
333	*ret = vy_entry_none();	122,883!
334	goto out;	122,883✔
335	done:	4,759✔
336	if (rc == 0) {	4,759!
337	int upserts_applied;
338	rc = vy_history_apply(&history, lsm->cmp_def,	4,759!
339	true, &upserts_applied, ret);
340	lsm->stat.upsert.applied += upserts_applied;	4,759✔
341	}
342	out:	×
343	vy_history_cleanup(&history);	127,642!
344	return rc;	127,642✔
345	}

tarantool / tarantool / 10923548804

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