Imported the following tests from Oracle MySQL:

* mysql-test/t/locking_clause.test
* mysql-test/suite/innodb/t/skip_locked_nowait.test
* mysql-test/t/locking_part.test

Ported to MariaDB by Daniel Black, changes include:
* Removed 'FOR SHARE OF /FOR UPDATE OF' tests that are part of
  MDEV-17514 (not yet implemented)
* mysql-test/t/locking_clause.test removes broken the limit test (outstanding MDEV-25244) bug.
* mysql-test/suite/innodb/t/skip_locked_nowait.test - removed high
  priority transactions
* mysql-test/t/locking_part.test imported to mysql-test/suite/innodb/t/partition_locking.test
  changed ER_LOCK_NOWAIT -> ER_LOCK_WAIT_TIMEOUT consistent with already
  implemented WAIT/NOWAIT feature. Changed "FOR SHARE SKIP LOCKED" ->
  "LOCK IN SHARE MODE SKIP LOCKED".

Adds an implementation for SELECT ... FOR UPDATE SKIP LOCKED /
SELECT ... LOCK IN SHARED MODE SKIP LOCKED

This is implemented only InnoDB at the moment, not in RockDB yet.

This adds a new hander flag HA_CAN_SKIP_LOCKED than
will be used when the storage engine advertises the flag.

When a storage engine indicates this flag it will get
TL_WRITE_SKIP_LOCKED and TL_READ_SKIP_LOCKED transaction types.

The Lex structure has been updated to store both the FOR UPDATE/LOCK IN
SHARE as well as the SKIP LOCKED so the SHOW CREATE VIEW
implementation is simplier.

"SELECT FOR UPDATE ... SKIP LOCKED" combined with CREATE TABLE AS or
INSERT.. SELECT on the result set is not safe for STATEMENT based
replication. MIXED replication will replicate this as row based events."

Thanks to guidance from Facebook commit
https://github.com/facebook/mysql-5.6/commit/193896c466d43fd905a62a60f1d73fd9c551a6e4
This helped verify basic test case, and components that need implementing
(even though every part was implemented differently).

Thanks Marko for guidance on simplier InnoDB implementation.

Reviewers: Marko, Monty

Use < TL_FIRST_WRITE for determining a READ transaction.

Use TL_FIRST_WRITE as the relative operator replacing TL_WRITE_ALLOW_WRITE
as the minimium WRITE lock type.

A consistency check for fil_space_t::name is causing recovery failures
in MDEV-25180 (Atomic ALTER TABLE). So, we'd better remove that field
altogether.

fil_space_t::name was more or less a copy of dict_table_t::name
(except for some special cases), and it was not being used for
anything useful.

There used to be a name_hash, but it had been removed already in
commit a75dbfd7 (MDEV-12266).

We will also remove os_normalize_path(), OS_PATH_SEPARATOR,
OS_PATH_SEPATOR_ALT. On Microsoft Windows, we will treat \ and /
roughly in the same way. The intention is that for per-table
tablespaces, the filenames will always follow the pattern
prefix/databasename/tablename.ibd. (Any \ in the prefix must not
be converted.)

ut_basename_noext(): Remove (unused function).

read_link_file(): Replaces RemoteDatafile::read_link_file().
We will ensure that the last two path component separators are
forward slashes (converting up to 2 trailing backslashes on
Microsoft Windows), so that everywhere else we can
assume that data file names end in "/databasename/tablename.ibd".

Note: On Microsoft Windows, path names that start with \\?\ must
not contain / as path component separators. Previously, such paths
did work in the DATA DIRECTORY argument of InnoDB tables.

Reviewed by: Vladislav Vaintroub

log_flush_notify(): Restore the reload of log_requests.start that was
accidentally removed in commit 8c2e3259.

Thanks to Elena Stepanova for a test case (repeatedly running FLUSH LOGS
concurrently with InnoDB write transactions).

In commit 1bd41158 the intention
was to move the trx_t::is_wsrep() check to the caller of the function
wsrep_is_BF_lock_timeout().

Merge commit 176aaf93
accidentally broke the WITH_WSREP release build.

buf_page_get_low(): Do not try to re-evict the page if it is
multiply buffer-fixed.

In commit 7cffb5f6 (MDEV-23399)
a livelock was introduced. If multiple threads are concurrently
requesting the same secondary index leaf page in buf_page_get_low()
and innodb_change_buffering_debug is set, all threads would try
to evict the page in a busy loop, never succeeding because the
block is buffer-fixed by other threads.

Thanks to Roel Van de Paar for reporting the original failure and
Elena Stepanova for producing an "rr replay" trace.

rocksdb_checkpoint_request() should call FlushWAL(sync=true) (which does
write-out and sync), not just SyncWAL()  (which just syncs without writing
out)
Followup: the test requires debug sync facility

(This is a backport to 10.5)

The code compares two query plans with identical costs, the plan
with lateral is the same as one without. Introduce a small difference
to cost numbers to prefer non-lateral plan in this case.

Followup: the test requires debug sync facility

- Aborting of fulltext index creation fails to remove the
index from sys indexes table. When we try to reload the
table definition, InnoDB fails with index count mismatch
error. InnoDB should remove the index from sys indexes while
rollbacking the secondary index creation.

- Post push to address 32-bit build failure.

rocksdb_checkpoint_request() should call FlushWAL(sync=true) (which does
write-out and sync), not just SyncWAL()  (which just syncs without writing
out)

Commit 76d2846a was for 10.5 only.
It caused some performance regression on 10.6 in some cases,
likely related to the removal of ib_mutex_t in MDEV-21452.

            memory barrier on ARM

As suggested in the said JIRA ticket based on the contribution done by
the community (in an attempt to optimize the spin-loop) the said approach
was evaluated against MariaDB Server 10.5 and found to help improve
throughput in the range of 2-5%.

Note: 10.6 timing graph and model are different as home-brew
mutexes are replaced with pthread mutexes. Said patch has mixed
impact on 10.6 so not recommended for 10.6.

- Importing table operation fails to punch the hole in
the filesystem when page compressed table is involved.
To achieve that, InnoDB firstly punches the hole for
the IOBuffer size(1MB). After that, InnoDB should write
page by page when page compression is involved.

As pointed out by Andrei Elkin, the previous fix did not fix one
race condition that may have caused the observed hang.

innodb_log_flush_request(): If we are enqueueing the very first
request at the same time the log write is being completed,
we must ensure that a near-concurrent call to log_flush_notify()
will not result in a missed notification. We guarantee this by
release-acquire operations on log_requests.start and
log_sys.flushed_to_disk_lsn.

log_flush_notify_and_unlock(): Cleanup: Always release the mutex.

log_sys_t::get_flushed_lsn(): Use acquire memory order.

log_sys_t::set_flushed_lsn(): Use release memory order.

log_sys_t::set_lsn(): Use release memory order.

log_sys_t::get_lsn(): Use relaxed memory order by default, and
allow the caller to specify acquire memory order explicitly.
Whenever the log_sys.mutex is being held or when log writes are
prohibited during startup, we can use a relaxed load. Likewise,
in some assertions where reading a stale value of log_sys.lsn
should not matter, we can use a relaxed load.

This will cause some additional instructions to be emitted on
architectures that do not implement Total Store Ordering (TSO),
such as POWER, ARM, and RISC-V Weak Memory Ordering (RVWMO).

Add condition on trx->state == TRX_STATE_COMMITTED_IN_MEMORY in order to
avoid unnecessary work. If a transaction has already been committed or
rolled back, it will release its locks in lock_release() and let
the waiting thread(s) continue execution.

Let BF wait on lock_rec_has_to_wait and if necessary other BF
is replayed.

wsrep_trx_order_before
  If BF is not even replicated yet then they are ordered
  correctly.

bg_wsrep_kill_trx
  Make sure victim_trx is found and check also its state. If
  state is TRX_STATE_COMMITTED_IN_MEMORY transaction is
  already committed or rolled back and will release it locks
  soon.

wsrep_assert_no_bf_bf_wait
  Transaction requesting new record lock should be TRX_STATE_ACTIVE
  Conflicting transaction can be in states TRX_STATE_ACTIVE,
  TRX_STATE_COMMITTED_IN_MEMORY or in TRX_STATE_PREPARED.
  If conflicting transaction is already committed in memory or
  prepared we should wait. When transaction is committed in memory we
  held trx mutex, but not lock_sys->mutex. Therefore, we
  could end here before transaction has time to do lock_release()
  that is protected with lock_sys->mutex.

lock_rec_has_to_wait
  We very well can let bf to wait normally as other BF will be
  replayed in case of conflict. For debug builds we will do
  additional sanity checks to catch unsupported bf wait if any.

wsrep_kill_victim
  Check is victim already in TRX_STATE_COMMITTED_IN_MEMORY state and
  if it is we can return.

lock_rec_dequeue_from_page
lock_rec_unlock
  Remove unnecessary wsrep_assert_no_bf_bf_wait function calls.
  We can very well let BF wait here.

Amends 48141f3c

This was removed in 09202b2e however
as Roel said, still in use.

Adjusted to not create in WITHOUT_SERVER.

This script is unused and unmaintained.

The logic is implemented in scripts/mysql_system_tables_fix.sql that forms part of mysql_upgrade

Its components:

  alter table mysql.user drop column `password_last_changed`, drop column `password_lifetime`, drop column `account_locked`;

has a friendlier migration path coming MDEV-24122

  alter table mysql.user change column `authentication_string` `auth_string` text COLLATE utf8_bin NOT NULL;

Already part of scripts/mysql_system_tables_fix.sql

  alter table mysql.user add column  `Password` char(41) CHARACTER SET latin1 COLLATE latin1_bin NOT NULL DEFAULT '' after `user`, add column  `is_role` enum('N','Y') CHARACTER SET utf8 NOT NULL DEFAULT 'N' after `auth_string`;

  alter table mysql.user add column `default_role` char(80) COLLATE utf8_bin NOT NULL DEFAULT '', add column `max_statement_time` decimal(12,6) NOT NULL DEFAULT '0.000000';

corrected in MDEV-23201 to be in the right order.

  update mysql.user set `password`=`auth_string`, plugin='' where plugin="mysql_native_password";

Is handled in server in the function acl_load.

A default 4G max_recursive_iterations allows users to far
to easily exhaust CPU, memory and time for a incorrect query.

Reduce this value down to 1000 consistent with Oracle MySQL's
cte_max_recursion_depth.

Signed-off-by: Julius Goryavsky <julius.goryavsky@mariadb.com>