MDEV-10918 Innodb/Linux - Fallback to simulated aio if io_setup() fails, e.g due to insufficient resources

The bug was in the code of the recursive method
With_element::check_unrestricted_recursive. For recursive
calls of this method sel->get_with_element()->owner != owner.

If a materialized derived table / view is specified by a unit
with SELECTs containing ORDER BY ... LIMIT then condition pushdown
cannot be done for these SELECTs.
If a materialized derived table / view is specified by a unit
containing global ORDER BY ... LIMIT then condition pushdown
cannot be done for this unit.

The server missed to call check_dependencies_in_with_clauses()
when processing PREPARE ... FROM CREATE ... SELECT / INSERT ... SELECT
with WITH clause before SELECT.

When a prepared statement uses a CTE definition with a column list
renaming of columns of the CTE expression  must be performed
for every execution of the prepared statement.

Fixes file descriptor leak after unsuccessful attempt to open
unix socket connection.

(Continued after a95e38) Update more test results.

Make sure we select one window function if we have an empty over clause.

The number is irrelevant and may differ by architecture. We are only
interested if it happened or not

Add support for having multiple IO_CACHEs with type=READ_CACHE to share
the file they are reading from.
Each IO_CACHE keeps its own in-memory buffer. When doing a read or seek
operation on the file, it notifies other IO_CACHEs that the file position
has been changed.

Make Rowid_seq_cursor use cloned IO_CACHE when reading filesort result.

Implement nth_value correctly and add a test case for it.

Refactour out (into a copy for now) the logic of Item_sum_hybrid, to
allow for multiple arguments. It does not contain the comparator
members. The result is the class Item_sum_hybrid_simple.

LEAD and LAG make use of this Item to store previous rows in a chache.
It also helps in specifying the field type. Currently LEAD/LAG do not
support default values.

NTH_VALUE behaves identical to LEAD and LAG, except that the starting
position cursor is placed on the top of the frame instead of the current
row.

Also remove some whitespace

Make window functions work with an empty over clause by forcing
a sort on the first column of the current join_tab. This is a temporary
fix until we get window functions to work with big tables.

The positional cursor now fetches rows based on the positional
cursor and an offset (if present). It will fetch rows, based on the
offset, only if the required position is not out of bounds.

Add a test case to check this behavior.

With clever use of partition bounds, we only need to add one row to the
items at a time. This way we remove the need to "reset" the item and run
through the full partition again.

Currently the implementation doesn't support removal, thus the
computation is performed by running over the window frame again.

The test case also checks correct functionality of Frame_scan_cursor, as
currently STD does not implement the remove() call.

We can set values in the record buffer first and only perform one table
write call at the end. No need to write to file every time one column is
updated.

Also, remove unused method from Table_read_cursor.

The counter is available via SHOW [GLOBAL] STATUS and will be reported
by the feedback plugin.

Make sure to call split_sum_func on all items that contain window
functions, so that all the column references are set up correctly.

Fix window function expressions such as win_func() <operator> expr.
The problem was found in 2 places.
First, when we have complex expressions containing window functions, we
can only compute their final value _after_ we have computed the window
function's values. These values must be stored within the temporary
table that we are using, before sending them off.
This is done by performing an extra copy_funcs call before the final
end_send() call.

Second, such expressions need to have their inner arguments,
changed such that the references within those arguments point to fields within
the temporary table.
Ex: sum(t.a) over (order by t.b) + sum(t.a) over (order by t.b)
Before this fix, t.a pointed to the original table's a field. In order
to compute the sum function's value correctly, it needs to point to the
copy of this field inside the temp table.
This is done by calling split_sum_func for each argument in the
expression in turn.

The win.test results have also been updated as they contained wrong
values for such a use case.

This makes them behave exactly like CURRENT ROW. Standard specifies
unsigned integer, which includes the value 0.

Expand the win_min_max test to include this kind of frame definitions.

mincore is defined differently in BSD mincore(void *, size_t, char *) vs
linux variant of: mincore(void *, size_t, unsigned char *).
Account for this difference in TokuDB.

- Change the default @@optimizer_switch value
- Adjust the testcases

In some cases the method Window_funcs_sort::setup() did
not build the sequence of sorting keys correctly.

new MariaDB-shared no longer provides or replaces mysql-libs or mariadb-libs