mariadb/mysql-test
Marko Mäkelä 8f486f2f74 MDEV-36301 SET GLOBAL innodb_log_file_disabled, ...
innodb_log_file_disabled: A new Boolean settable global parameter,
for disabling the InnoDB redo log. When set, the server is not
crash safe.

innodb_log_group_home_dir: Allow the value to be changed with
SET GLOBAL, as long as the log remains in the same file system
or innodb_log_file_disabled=ON was set.

innodb_log_update(): A common function for implementing
SET GLOBAL innodb_log_file_size, innodb_log_file_disabled,
innodb_log_checkpoint_now, innodb_log_group_home_dir.

log_sys.buf_size_requested: The configured innodb_log_buffer_size.
While the log is disabled, we may set log_sys.buf_size
(the actual size of log_sys.buf) differently.

log_sys.disabled: The current setting of innodb_log_file_disabled.

log_t::append_prepare(): Instead of referring to file_size or
capacity() for mmap=true, always refer to buf_size.
When log_sys.disabled holds, log_sys.buf may be much smaller than
log_sys.file_size. Its size is always reflected by log_sys.buf_size.

log_t::attach(): Handle log_sys.disabled.

log_t::disable(): Implements SET innodb_log_file_disabled=ON.
Even if the log used to be in persistent memory, here we will
set up dummy log_sys.buf and log_sys.flush_buf so that the dummy
writes will appear to use file based writes.

log_t::skip_write_buf(): A dummy log writer implementation that is
used when log_sys.disabled holds and the log is not being resized.

log_t::resize_abort(): When the log remains disabled,
"persist" all the log and advance the group_lock and flush_lock
to the current LSN, just like log_t::disable() does.

log_t::resize_start(): Handle log_sys.disabled, that is,
SET GLOBAL innodb_log_file_disabled=OFF when the redo log had
previously been disabled.  If we are on persistent memory,
we will "fake" the dummy log_sys.buf to appear as memory-mapped
as well, so that log_t::resize_write() and log_t::resize_write_buf()
can assume that both log files are of the same type (memory-mapped
or file-based).  The dummy log_sys.flush_buf will be stored in
log_sys.resize_flush_buf in that case.  When moving from memory-mapped
to a regular log file, we will allocate log_sys.checkpoint_buf.
It will be freed in log_t::close().

log_t::resize_rename(): When innodb_log_group_home_dir
is changed between file systems, handle the non-atomic
replacement of the log file in a special way.  For a moment,
a recoverable ib_logfile0 will exist in both locations.

log_t::resize_write(): Detect memory-mapped log by
!resize_log.is_opened().  If the memory-mapped log is being re-enabled,
log_sys.resize_flush_buf may temporarily store the value of a dummy
log_sys.flush_buf.  During any log resizing or disabling or enabling,
both buf and resize_buf must appear to be either file-based or
memory-mapped.

log_t::write_buf(), log_write_up_to(): Handle the special case that
disable() executed or resize_start() started re-enabling the log while
we were waiting for flush_lock or write_lock. In the latter case,
log_sys.writer will be changed from log_t::skip_write_buf to
log_writer_resizing during the execution of log_write_up_to().

log_t::persist(): Skip the writes if the log is disabled, that is,
a memory-mapped log is in the process being re-enabled. In this case,
we cannot trust log_sys.file_size, and the pmem_persist() could be
invoked on an invalid address range.

log_resize_acquire_group(): Acquier the group locks for write and flush.

log_resize_release_group(): Release the group locks for write and flush.

log_resize_acquire(): Return whether the group locks were elided.

log_write_and_flush_prepare(), log_write_and_flush(): Protect also the
log_sys.is_mmap() case with write_lock and flush_lock, in order to
prevent a race condition between mtr_t::commit_file() and
log_t::disable().

log_t::persist(): Remove the assertions about not holding write_lock or
flush_lock.  We will hold them during DDL operations.
2025-05-28 14:14:20 +03:00
..
collections
include MDEV-34888 Implement SEMIJOIN() and SUBQUERY() hints 2025-05-05 12:02:47 +07:00
lib Fix typos in mysql-test/ 2025-04-29 13:53:16 +10:00
main MDEV-36503 add Pad_attribute column to INFORMATION_SCHEMA.COLLATIONS 2025-05-19 17:07:18 +04:00
std_data Fix typos in mysql-test/ 2025-04-29 13:53:16 +10:00
suite MDEV-36301 SET GLOBAL innodb_log_file_disabled, ... 2025-05-28 14:14:20 +03:00
asan.supp
CMakeLists.txt Merge branch '10.5' into 10.6 2025-03-31 12:12:50 +02:00
dgcov.pl
lsan.supp
mariadb-stress-test.pl Fix typos in mysql-test/ 2025-04-29 13:53:16 +10:00
mariadb-test-run.pl Fix typos in mysql-test/ 2025-04-29 13:53:16 +10:00
mtr.out-of-source
purify.supp
README
README-gcov
README.stress
suite.pm
valgrind.supp Fix typos in mysql-test/ 2025-04-29 13:53:16 +10:00

This directory contains test suites for the MariaDB server. To run
currently existing test cases, execute ./mysql-test-run in this directory.

Some tests are known to fail on some platforms or be otherwise unreliable.
In the file collections/smoke_test there is a list of tests that are
expected to be stable.

In general you do not have to do "make install", and you can have
a co-existing MariaDB installation, the tests will not conflict with it.
To run the tests in a source directory, you must do "make" first.

In Red Hat distributions, you should run the script as user "mysql".
The user is created with nologin shell, so the best bet is something like
  # su -
  # cd /usr/share/mariadb-test
  # su -s /bin/bash mysql -c ./mysql-test-run

This will use the installed MariaDB executables, but will run a private
copy of the server process (using data files within /usr/share/mariadb-test),
so you need not start the mysqld service beforehand.

You can omit --skip-test-list option if you want to check whether
the listed failures occur for you.

To clean up afterwards, remove the created "var" subdirectory, e.g.
  # su -s /bin/bash - mysql -c "rm -rf /usr/share/mariadb-test/var"

If tests fail on your system, please read the following manual section
for instructions on how to report the problem:

https://mariadb.com/kb/en/reporting-bugs

If you want to use an already running MySQL server for specific tests,
use the --extern option to mysql-test-run. Please note that in this mode,
you are expected to provide names of the tests to run.

For example, here is the command to run the "alias" and "analyze" tests
with an external server:

  # mariadb-test-run --extern socket=/tmp/mysql.sock alias analyze

To match your setup, you might need to provide other relevant options.

With no test names on the command line, mysql-test-run will attempt
to execute the default set of tests, which will certainly fail, because
many tests cannot run with an external server (they need to control the
options with which the server is started, restart the server during
execution, etc.)

You can create your own test cases. To create a test case, create a new
file in the main subdirectory using a text editor. The file should have a .test
extension. For example:

  # xemacs t/test_case_name.test

In the file, put a set of SQL statements that create some tables,
load test data, and run some queries to manipulate it.

Your test should begin by dropping the tables you are going to create and
end by dropping them again. This ensures that you can run the test over
and over again.

If you are using mysqltest commands in your test case, you should create
the result file as follows:

  # mariadb-test-run --record test_case_name

  or

  # mariadb-test --record < t/test_case_name.test

If you only have a simple test case consisting of SQL statements and
comments, you can create the result file in one of the following ways:

  # mariadb-test-run --record test_case_name

  # mariadb test < t/test_case_name.test > r/test_case_name.result

  # mariadb-test --record --database test --result-file=r/test_case_name.result < t/test_case_name.test

When this is done, take a look at r/test_case_name.result.
If the result is incorrect, you have found a bug. In this case, you should
edit the test result to the correct results so that we can verify that
the bug is corrected in future releases.

If you want to submit your test case you can send it
to developers@lists.mariadb.org or attach it to a bug report on
http://mariadb.org/jira/.

If the test case is really big or if it contains 'not public' data,
then put your .test file and .result file(s) into a tar.gz archive,
add a README that explains the problem, ftp the archive to
ftp://ftp.mariadb.org/private and submit a report to
https://mariadb.org/jira about it.

The latest information about mysql-test-run can be found at:
https://mariadb.com/kb/en/mariadb/mysqltest/

If you want to create .rdiff files, check
https://mariadb.com/kb/en/mariadb/mysql-test-auxiliary-files/