vinyl: do not reset cache link LSN on partial key lookup

Since commit e8109b2 ("vinyl: ignore cache chains with invisible
DELETEs") each cache node stores the LSNs of the left and right links.
They are used to ignore links that are invisible from the current read
view (created after the read view was opened). We update the LSN not
only when we link two nodes together but also when we update the node's
boundary level. This is incorrect if the node is linked.

For example, suppose we have an index over two fields that contains
tuples {0,2} and {2,0} and there's a transaction that was sent to
a read view. Now another transaction inserts {0,1} and deletes {0,2},
then selects all tuples. This results in creation of two interlinked
cache nodes: {0,1} and {2,0}. The link is invisible from the read view:
since we skipped DELETE{0,2}, its LSN equals the LSN of the DELETE
statement, which is greater than the read view LSN. However, if we now
select GT{1}, we will update the boundary level of the node storing
{2,0} from 2 to 1 and reset its LSN to 0 because we didn't skip any
DELETE statements. As a result, if the transaction operating in the read
view tries to select GT{0,1}, it will find {2,0}, see that it's
left-linked and the link LSN is 0, and return it right away, skipping
{0,2}, which is visible from the read view.

To fix this issue, let's skip the boundary level update if the node
is linked. It doesn't make sense anyway because the boundary level is
used only for unlinked nodes, see vy_cache_iterator_is_stop().

Follow-up tarantool#11079
Closes tarantool#11294

NO_DOC=bug fix

Author: locker

changelogs/unreleased/gh-11079-vy-cache-read-view-fix.md

@@ -1,4 +1,4 @@
 ## bugfix/vinyl
 
 * Fixed a bug in the tuple cache when a transaction operating in a read view
-  could skip a tuple deleted after the read view creation (gh-11079).
+  could skip a tuple deleted after the read view creation (gh-11079, gh-11294).

src/box/vy_cache.c

@@ -333,10 +333,12 @@ vy_cache_add(struct vy_cache *cache, struct vy_entry curr,
 		vy_cache_node_delete(cache->env, replaced);
 	}
 	if (direction > 0 &&
+	    !(node->flags & VY_CACHE_LEFT_LINKED) &&
 	    boundary_level < node->left_boundary_level) {
 		node->left_boundary_level = boundary_level;
 		node->left_lsn = link_lsn;
 	} else if (direction < 0 &&
+		   !(node->flags & VY_CACHE_RIGHT_LINKED) &&
 		   boundary_level < node->right_boundary_level) {
 		node->right_boundary_level = boundary_level;
 		node->right_lsn = link_lsn;

test/vinyl-luatest/gh_11079_invisible_delete_caching_test.lua

@@ -199,3 +199,59 @@ g.test_deferred_delete = function(cg)
                         {{60, 600}, {40, 400}, {20, 200}})
     end)
 end
+
+g.test_partial_key_forward = function(cg)
+    cg.server:exec(function()
+        local fiber = require('fiber')
+
+        local s = box.schema.space.create('test', {engine = 'vinyl'})
+        s:create_index('primary', {parts = {{1, 'unsigned'}, {2, 'unsigned'}}})
+
+        s:replace({0, 2})
+        s:replace({2, 0})
+
+        box.begin()
+        t.assert_equals(s:select(), {{0, 2}, {2, 0}})
+
+        local f = fiber.new(function()
+            s:replace({0, 1})
+            s:delete({0, 2})
+            t.assert_equals(s:select(), {{0, 1}, {2, 0}})
+            t.assert_equals(s:select({1}, {iterator = 'gt'}), {{2, 0}})
+        end)
+        f:set_joinable(true)
+        t.assert_equals({f:join(5)}, {true})
+
+        t.assert_equals(s:select({}, {iterator = 'lt'}), {{2, 0}, {0, 2}})
+        t.assert_equals(s:select({0, 1}, {iterator = 'gt'}), {{0, 2}, {2, 0}})
+        box.commit()
+    end)
+end
+
+g.test_partial_key_backward = function(cg)
+    cg.server:exec(function()
+        local fiber = require('fiber')
+
+        local s = box.schema.space.create('test', {engine = 'vinyl'})
+        s:create_index('primary', {parts = {{1, 'unsigned'}, {2, 'unsigned'}}})
+
+        s:replace({0, 2})
+        s:replace({2, 0})
+
+        box.begin()
+        t.assert_equals(s:select(), {{0, 2}, {2, 0}})
+
+        local f = fiber.new(function()
+            s:replace({2, 1})
+            s:delete({2, 0})
+            t.assert_equals(s:select(), {{0, 2}, {2, 1}})
+            t.assert_equals(s:select({1}, {iterator = 'lt'}), {{0, 2}})
+        end)
+        f:set_joinable(true)
+        t.assert_equals({f:join(5)}, {true})
+
+        t.assert_equals(s:select({}, {iterator = 'gt'}), {{0, 2}, {2, 0}})
+        t.assert_equals(s:select({2, 1}, {iterator = 'lt'}), {{2, 0}, {0, 2}})
+        box.commit()
+    end)
+end