MDEV-27992 DELETE fails to delete record after blocking is released

MDEV-27025 allows to insert records before the record on which DELETE is locked, as a result the DELETE misses those records, what causes serious ACID violation. Revert MDEV-27025, MDEV-27550. The test which shows the scenario of ACID violation is added.

Author: vlad-lesin

mysql-test/suite/galera/disabled.def

@@ -12,7 +12,6 @@
 
 MW-328A : MDEV-22666 galera.MW-328A MTR failed: "Semaphore wait has lasted > 600 seconds" and do not release port 16002
 MW-328B : MDEV-22666 galera.MW-328A MTR failed: "Semaphore wait has lasted > 600 seconds" and do not release port 16002
-MW-328D : MDEV-27550 ER_LOCK_DEADLOCK is gone after MDEV-27025
 MW-329 : MDEV-19962 Galera test failure on MW-329
 galera_as_slave_replication_bundle : MDEV-15785 OPTION_GTID_BEGIN is set in Gtid_log_event::do_apply_event()
 galera_concurrent_ctas : MDEV-24842 Galera test failure on galera_concurrent_ctas

mysql-test/suite/innodb/r/lock_delete_updated.result

@@ -0,0 +1,20 @@
+CREATE TABLE t(a INT PRIMARY KEY) ENGINE=InnoDB;
+INSERT INTO t VALUES (3);
+BEGIN;
+connection default;
+UPDATE t SET a = 2;
+connect con1,localhost,root;
+DELETE FROM t;
+connection default;
+UPDATE t SET a = 1;
+COMMIT;
+connection con1;
+ERROR 40001: Deadlock found when trying to get lock; try restarting transaction
+disconnect con1;
+connection default;
+# The above DELETE must delete all the rows in the table, so the
+# following SELECT must show 0 rows.
+SELECT count(*) FROM t;
+count(*)
+1
+DROP TABLE t;

mysql-test/suite/innodb/r/lock_wait_conflict.result

@@ -0,0 +1,34 @@
+--source include/have_innodb.inc
+--source include/count_sessions.inc
+
+CREATE TABLE t(a INT PRIMARY KEY) ENGINE=InnoDB;
+INSERT INTO t VALUES (3);
+
+BEGIN;
+
+connection default;
+UPDATE t SET a = 2;
+
+connect con1,localhost,root;
+send DELETE FROM t;
+
+connection default;
+let $wait_condition=
+ select count(*) = 1 from information_schema.processlist
+ where state = "Updating" and info = "DELETE FROM t";
+--source include/wait_condition.inc
+
+UPDATE t SET a = 1;
+COMMIT;
+
+connection con1;
+error ER_LOCK_DEADLOCK;
+reap;
+disconnect con1;
+
+connection default;
+--echo # The above DELETE must delete all the rows in the table, so the
+--echo # following SELECT must show 0 rows.
+SELECT count(*) FROM t;
+DROP TABLE t;
+--source include/wait_until_count_sessions.inc

mysql-test/suite/innodb/t/lock_delete_updated.test

@@ -283,6 +283,7 @@ connection default;
 update t1 set b = 'foo';
 connection con1;
 update t1 set a = 'bar';
+ERROR 40001: Deadlock found when trying to get lock; try restarting transaction
 disconnect con1;
 connection default;
 drop table t1;

mysql-test/suite/innodb/t/lock_wait_conflict.test

@@ -186,9 +186,7 @@ send update t1 set b = 'foo';
 connection con1;
 let $wait_condition= select count(*) from information_schema.innodb_lock_waits;
 source include/wait_condition.inc;
-# There must no be DEADLOCK here as con1 transaction already holds locks, and
-# default's transaction lock is waiting, so the locks of the following "UPDATE"
-# must not conflict with waiting lock.
+error ER_LOCK_DEADLOCK;
 update t1 set a = 'bar';
 disconnect con1;
 connection default;

mysql-test/suite/versioning/r/update.result

@@ -1,7 +1,7 @@
 /*****************************************************************************
 
 Copyright (c) 1997, 2016, Oracle and/or its affiliates. All Rights Reserved.
-Copyright (c) 2018, 2022, MariaDB Corporation.
+Copyright (c) 2018, MariaDB Corporation.
 
 This program is free software; you can redistribute it and/or modify it under
 the terms of the GNU General Public License as published by the Free Software
@@ -31,31 +31,7 @@ Created 5/20/1997 Heikki Tuuri
 #include "sync0rw.h"
 
 struct hash_table_t;
-
-struct hash_cell_t
-{
- /** singly-linked, nullptr terminated list of hash buckets */
- void *node;
-
- /** Insert an element after another.
- @tparam T type of the element
- @param after the element after which to insert
- @param insert the being-inserted element
- @param next the next-element pointer in T */
- template<typename T>
- void insert_after(T &after, T &insert, T *T::*next)
- {
-#ifdef UNIV_DEBUG
- for (const T *c= static_cast<const T*>(node); c; c= c->*next)
- if (c == &after)
- goto found;
- ut_error;
- found:
-#endif
- insert.*next= after.*next;
- after.*next= &insert;
- }
-};
+struct hash_cell_t;
 
 typedef void*hash_node_t;
 
@@ -501,6 +477,10 @@ hash_unlock_x_all_but(
 hash_table_t*table,/*!< in: hash table */
 rw_lock_t*keep_lock);/*!< in: lock to keep */
 
+struct hash_cell_t{
+void*node;/*!< hash chain node, NULL if none */
+};
+
 /* The hash table structure */
 struct hash_table_t {
 enum hash_table_sync_ttype;/*<! type of hash_table. */

mysql-test/suite/versioning/t/update.test

@@ -1,7 +1,7 @@
 /*****************************************************************************
 
 Copyright (c) 1996, 2016, Oracle and/or its affiliates. All Rights Reserved.
-Copyright (c) 2017, 2020, 2022, MariaDB Corporation.
+Copyright (c) 2017, 2020, MariaDB Corporation.
 
 This program is free software; you can redistribute it and/or modify it under
 the terms of the GNU General Public License as published by the Free Software
@@ -888,29 +888,26 @@ class lock_sys_t
 /*********************************************************************//**
 Creates a new record lock and inserts it to the lock queue. Does NOT check
 for deadlocks or lock compatibility!
-@param[in] c_lock conflicting lock
-@param[in] thr thread owning trx
-@param[in] type_mode lock mode and wait flag, type is ignored and replaced by
-LOCK_REC
-@param[in] block buffer block containing the record
-@param[in] heap_no heap number of the record
-@param[in] index index of record
-@param[in,out] trx transaction
-@param[in] caller_owns_trx_mutex TRUE if caller owns trx mutex
-@param[in] insert_before_waiting if true, inserts new B-tree record lock
-just after the last non-waiting lock of the current transaction which is
-located before the first waiting for the current transaction lock, otherwise
-the lock is inserted at the end of the queue
 @return created lock */
 UNIV_INLINE
-lock_t *lock_rec_create(lock_t *c_lock,
+lock_t*
+lock_rec_create(
+/*============*/
 #ifdef WITH_WSREP
- que_thr_t *thr,
+lock_t*	c_lock,/*!< conflicting lock */
+que_thr_t*	thr,/*!< thread owning trx */
 #endif
- ulint type_mode, const buf_block_t *block,
- ulint heap_no, dict_index_t *index, trx_t *trx,
- bool caller_owns_trx_mutex,
- bool insert_before_waiting= false);
+ulint	type_mode,/*!< in: lock mode and wait
+flag, type is ignored and
+replaced by LOCK_REC */
+const buf_block_t*	block,/*!< in: buffer block containing
+the record */
+ulint	heap_no,/*!< in: heap number of the record */
+dict_index_t*	index,/*!< in: index of record */
+trx_t*	trx,/*!< in,out: transaction */
+boolcaller_owns_trx_mutex);
+/*!< in: true if caller owns
+trx mutex */
 
 /*************************************************************//**
 Removes a record lock request, waiting or granted, from the queue. */
@@ -923,7 +920,6 @@ lock_rec_discard(
 
 /** Create a new record lock and inserts it to the lock queue,
 without checking for deadlocks or conflicts.
-@param[in]	c_lock	conflicting lock
 @param[in]	type_mode	lock mode and wait flag; type will be replaced
 with LOCK_REC
 @param[in]	space	tablespace id
@@ -933,15 +929,11 @@ without checking for deadlocks or conflicts.
 @param[in]	index	the index tree
 @param[in,out]	trx	transaction
 @param[in]	holds_trx_mutex	whether the caller holds trx->mutex
-@param[in]	insert_before_waiting if true, inserts new B-tree record lock
-just after the last non-waiting lock of the current transaction which is
-located before the first waiting for the current transaction lock, otherwise
-the lock is inserted at the end of the queue
 @return created lock */
 lock_t*
 lock_rec_create_low(
-lock_t*	c_lock,
 #ifdef WITH_WSREP
+lock_t*	c_lock,/*!< conflicting lock */
 que_thr_t*	thr,/*!< thread owning trx */
 #endif
 ulint	type_mode,
@@ -951,12 +943,9 @@ lock_rec_create_low(
 ulint	heap_no,
 dict_index_t*	index,
 trx_t*	trx,
-boolholds_trx_mutex,
-boolinsert_before_waiting = false);
-
+boolholds_trx_mutex);
 /** Enqueue a waiting request for a lock which cannot be granted immediately.
 Check for deadlocks.
-@param[in]	c_lock	conflicting lock
 @param[in]	type_mode	the requested lock mode (LOCK_S or LOCK_X)
 possibly ORed with LOCK_GAP or
 LOCK_REC_NOT_GAP, ORed with
@@ -975,7 +964,9 @@ Check for deadlocks.
 (or it happened to commit) */
 dberr_t
 lock_rec_enqueue_waiting(
-lock_t*	c_lock,
+#ifdef WITH_WSREP
+lock_t*	c_lock,/*!< conflicting lock */
+#endif
 ulint	type_mode,
 const buf_block_t*	block,
 ulint	heap_no,

storage/innobase/include/hash0hash.h

@@ -101,37 +101,34 @@ lock_hash_get(
 /*********************************************************************//**
 Creates a new record lock and inserts it to the lock queue. Does NOT check
 for deadlocks or lock compatibility!
-@param[in] c_lock conflicting lock
-@param[in] thr thread owning trx
-@param[in] type_mode lock mode and wait flag, type is ignored and replaced by
-LOCK_REC
-@param[in] block buffer block containing the record
-@param[in] heap_no heap number of the record
-@param[in] index index of record
-@param[in,out] trx transaction
-@param[in] caller_owns_trx_mutex TRUE if caller owns trx mutex
-@param[in] insert_before_waiting if true, inserts new B-tree record lock
-just after the last non-waiting lock of the current transaction which is
-located before the first waiting for the current transaction lock, otherwise
-the lock is inserted at the end of the queue
 @return created lock */
 UNIV_INLINE
-lock_t *lock_rec_create(lock_t *c_lock,
+lock_t*
+lock_rec_create(
+/*============*/
 #ifdef WITH_WSREP
- que_thr_t *thr,
+lock_t*	c_lock,/*!< conflicting lock */
+que_thr_t*	thr,/*!< thread owning trx */
 #endif
- ulint type_mode, const buf_block_t *block,
- ulint heap_no, dict_index_t *index, trx_t *trx,
- bool caller_owns_trx_mutex,
- bool insert_before_waiting)
+ulint	type_mode,/*!< in: lock mode and wait
+flag, type is ignored and
+replaced by LOCK_REC */
+const buf_block_t*	block,/*!< in: buffer block containing
+the record */
+ulint	heap_no,/*!< in: heap number of the record */
+dict_index_t*	index,/*!< in: index of record */
+trx_t*	trx,/*!< in,out: transaction */
+boolcaller_owns_trx_mutex)
+/*!< in: TRUE if caller owns
+trx mutex */
 {
 btr_assert_not_corrupted(block, index);
-return lock_rec_create_low(c_lock,
+return lock_rec_create_low(
 #ifdef WITH_WSREP
-thr,
+c_lock, thr,
 #endif
 type_mode,
 block->page.id.space(), block->page.id.page_no(),
-block->frame, heap_no, index, trx,
-caller_owns_trx_mutex, insert_before_waiting);
+block->frame, heap_no,
+index, trx, caller_owns_trx_mutex);
 }