* WL#4137 Maria- Framework for testing recovery in mysql-test-run
See test maria-recovery.test for a model; all include scripts have
an "API" section at start if they do take parameters from outside.
* Fixing bug reported by Jani and Monty (when two REDOs about the same
page in one group, see ma_blockrec.c).
* Fixing small bugs in recovery
mysql-test/include/wait_until_connected_again.inc:
be sure to enter the loop (the previous query by the caller may not have
failed: it could be
query;
mysqladmin shutdown;
call this script).
mysql-test/lib/mtr_process.pl:
* Through the "expect" file a test can tell mtr that a server crash
is expected. What the file contains is irrelevant. Now if its last
line starts with "wait", mtr will wait before restarting (it will
wait for the last line to not start with "wait"). This is for
tests which need to mangle files under the feet of a dead mysqld.
* Remove "expect" file before restarting; otherwise there could be a
race condition: tests sees server restarted, does something, writes
an "expect" file, and then mtr removes that file, then
test kills mysqld, and then mtr will never restart it.
storage/maria/ma_blockrec.c:
- when applying a REDO in recovery, we don't anymore put UNDO's LSN on the page
at once; indeed if in this REDO's group there comes another REDO
for the same page it would be wrongly skipped. Instead, we keep
pages pinned, don't change their LSN. When done with all REDOs
of the group we unpin them and stamp them with UNDO's LSN.
- fixing bug in applying of REDO_PURGE_BLOCKS in recovery: page_range
sometimes has TAIL_BIT set, need to turn it down to know the real page
range.
- Both bugs are covered in maria-recovery.test
storage/maria/ma_checkpoint.c:
Capability to, in debug builds only, do some special operations
(flush all bitmap and data pages, flush state, flush log)
and crash mysqld, to later test recovery.
Driven by some --debug=d, symbols.
storage/maria/ma_open.c:
debugging info
storage/maria/ma_pagecache.c:
Now that we can _ma_unpin_all_pages() during the REDO phase
to set page's LSN, the assertion needs to be relaxed.
storage/maria/ma_recovery.c:
- open trace file in append mode (useful when a test triggers several
recoveries, we see them all).
- fixing wrong error detection, it's possible that during recovery
we want to open an already open table.
- when applying a REDO in recovery, we don't anymore put UNDO's LSN on the page
at once; indeed if in this REDO's group there comes another REDO
for the same page it would be wrongly skipped. Instead, we keep
pages pinned, don't change their LSN. When done with all REDOs
of the group we unpin them and stamp them with UNDO's LSN.
- we verify that all log records of a group are about the same table,
for debugging.
mysql-test/r/maria-recovery.result:
result
mysql-test/t/maria-recovery-master.opt:
crash is expected, core file would take room, stack trace would
wake pushbuild up.
mysql-test/t/maria-recovery.test:
Test of recovery from mysql-test (it is already tested as unit tests
in ma_test_recovery) (WL#4137)
- test that, if recovery is made to start on an empty table it can
replay the effects of committed and uncommitted statements (having only
the committed ones in the end result). This should be the first test
for someone writing code of new REDOs.
- test that, if mysqld is crashed and recovery runs we have only
committed statements in the end result. Crashes are done in different
ways: flush nothing (so, uncommitted statement is often missing
from the log => no rollback to do); flush pagecache (implicitely flushes
log (WAL)) and flush log, both causes rollbacks; flush log can also
flush state (state.records etc) to test recovery of the state
(not tested well now as we repair the index anyway).
- test of bug found by Jani and Monty in recovery (two REDO about
the same page in one group).
mysql-test/include/maria_empty_logs.inc:
removes logs, to have a clean sheet for testing recovery.
mysql-test/include/maria_make_snapshot.inc:
copies a table to another directory, or back, or compares both
(comparison is not implemented as physical comparison is impossible
if an UNDO phase happened).
mysql-test/include/maria_make_snapshot_for_comparison.inc:
copies tables to another directory so that they can later
serve as a comparison reference (they are the good tables,
recovery should produce similar ones).
mysql-test/include/maria_make_snapshot_for_feeding_recovery.inc:
When we want to force recovery to start on old tables, we prepare
old tables with this script: we put them in a spare directory.
They are later copied back over mysqltest tables while mysqld is dead.
We also need to copy back the control file, otherwise mysqld,
in recovery, would start from the latest checkpoint: latest
checkpoint plus old tables is not a recovery-possible scenario of course.
mysql-test/include/maria_verify_recovery.inc:
causes mysqld to crash, restores old tables if requested,
lets recovery run, compares resulting tables with reference tables
by using CHECKSUM TABLE.
We don't do any sanity checks on page's LSN in resulting tables, yet.
2007-11-13 17:12:29 +01:00
|
|
|
drop database if exists mysqltest;
|
|
|
|
|
create database mysqltest;
|
|
|
|
|
use mysqltest;
|
|
|
|
|
* shut down mysqld, removed logs, restarted it
|
|
|
|
|
use mysqltest;
|
|
|
|
|
create table t1 (a varchar(1000)) engine=maria;
|
2007-11-13 18:49:00 +01:00
|
|
|
* TEST of REDO: see if recovery can reconstruct if we give it an old table
|
* WL#4137 Maria- Framework for testing recovery in mysql-test-run
See test maria-recovery.test for a model; all include scripts have
an "API" section at start if they do take parameters from outside.
* Fixing bug reported by Jani and Monty (when two REDOs about the same
page in one group, see ma_blockrec.c).
* Fixing small bugs in recovery
mysql-test/include/wait_until_connected_again.inc:
be sure to enter the loop (the previous query by the caller may not have
failed: it could be
query;
mysqladmin shutdown;
call this script).
mysql-test/lib/mtr_process.pl:
* Through the "expect" file a test can tell mtr that a server crash
is expected. What the file contains is irrelevant. Now if its last
line starts with "wait", mtr will wait before restarting (it will
wait for the last line to not start with "wait"). This is for
tests which need to mangle files under the feet of a dead mysqld.
* Remove "expect" file before restarting; otherwise there could be a
race condition: tests sees server restarted, does something, writes
an "expect" file, and then mtr removes that file, then
test kills mysqld, and then mtr will never restart it.
storage/maria/ma_blockrec.c:
- when applying a REDO in recovery, we don't anymore put UNDO's LSN on the page
at once; indeed if in this REDO's group there comes another REDO
for the same page it would be wrongly skipped. Instead, we keep
pages pinned, don't change their LSN. When done with all REDOs
of the group we unpin them and stamp them with UNDO's LSN.
- fixing bug in applying of REDO_PURGE_BLOCKS in recovery: page_range
sometimes has TAIL_BIT set, need to turn it down to know the real page
range.
- Both bugs are covered in maria-recovery.test
storage/maria/ma_checkpoint.c:
Capability to, in debug builds only, do some special operations
(flush all bitmap and data pages, flush state, flush log)
and crash mysqld, to later test recovery.
Driven by some --debug=d, symbols.
storage/maria/ma_open.c:
debugging info
storage/maria/ma_pagecache.c:
Now that we can _ma_unpin_all_pages() during the REDO phase
to set page's LSN, the assertion needs to be relaxed.
storage/maria/ma_recovery.c:
- open trace file in append mode (useful when a test triggers several
recoveries, we see them all).
- fixing wrong error detection, it's possible that during recovery
we want to open an already open table.
- when applying a REDO in recovery, we don't anymore put UNDO's LSN on the page
at once; indeed if in this REDO's group there comes another REDO
for the same page it would be wrongly skipped. Instead, we keep
pages pinned, don't change their LSN. When done with all REDOs
of the group we unpin them and stamp them with UNDO's LSN.
- we verify that all log records of a group are about the same table,
for debugging.
mysql-test/r/maria-recovery.result:
result
mysql-test/t/maria-recovery-master.opt:
crash is expected, core file would take room, stack trace would
wake pushbuild up.
mysql-test/t/maria-recovery.test:
Test of recovery from mysql-test (it is already tested as unit tests
in ma_test_recovery) (WL#4137)
- test that, if recovery is made to start on an empty table it can
replay the effects of committed and uncommitted statements (having only
the committed ones in the end result). This should be the first test
for someone writing code of new REDOs.
- test that, if mysqld is crashed and recovery runs we have only
committed statements in the end result. Crashes are done in different
ways: flush nothing (so, uncommitted statement is often missing
from the log => no rollback to do); flush pagecache (implicitely flushes
log (WAL)) and flush log, both causes rollbacks; flush log can also
flush state (state.records etc) to test recovery of the state
(not tested well now as we repair the index anyway).
- test of bug found by Jani and Monty in recovery (two REDO about
the same page in one group).
mysql-test/include/maria_empty_logs.inc:
removes logs, to have a clean sheet for testing recovery.
mysql-test/include/maria_make_snapshot.inc:
copies a table to another directory, or back, or compares both
(comparison is not implemented as physical comparison is impossible
if an UNDO phase happened).
mysql-test/include/maria_make_snapshot_for_comparison.inc:
copies tables to another directory so that they can later
serve as a comparison reference (they are the good tables,
recovery should produce similar ones).
mysql-test/include/maria_make_snapshot_for_feeding_recovery.inc:
When we want to force recovery to start on old tables, we prepare
old tables with this script: we put them in a spare directory.
They are later copied back over mysqltest tables while mysqld is dead.
We also need to copy back the control file, otherwise mysqld,
in recovery, would start from the latest checkpoint: latest
checkpoint plus old tables is not a recovery-possible scenario of course.
mysql-test/include/maria_verify_recovery.inc:
causes mysqld to crash, restores old tables if requested,
lets recovery run, compares resulting tables with reference tables
by using CHECKSUM TABLE.
We don't do any sanity checks on page's LSN in resulting tables, yet.
2007-11-13 17:12:29 +01:00
|
|
|
* copied t1 for feeding_recovery
|
|
|
|
|
insert into t1 values ("00000000");
|
|
|
|
|
flush table t1;
|
|
|
|
|
* copied t1 for comparison
|
|
|
|
|
SET SESSION debug="+d,maria_flush_whole_log,maria_crash";
|
|
|
|
|
* crashing mysqld intentionally
|
|
|
|
|
set global maria_checkpoint_interval=1;
|
|
|
|
|
ERROR HY000: Lost connection to MySQL server during query
|
|
|
|
|
* copied t1 back for feeding_recovery
|
|
|
|
|
* recovery happens
|
|
|
|
|
* rebuilding index (until we have recovery of index)
|
|
|
|
|
repair table t1 quick;
|
|
|
|
|
Table Op Msg_type Msg_text
|
|
|
|
|
mysqltest.t1 repair status OK
|
|
|
|
|
* testing that checksum after recovery is as expected
|
|
|
|
|
select if(substring("mysqltest.t1 488070860",instr("mysqltest.t1 488070860",".t1")) = substring("mysqltest_for_comparison.t1 488070860",instr("mysqltest_for_comparison.t1 488070860",".t1")),"ok","failure");
|
|
|
|
|
if(substring("mysqltest.t1 488070860",instr("mysqltest.t1 488070860",".t1")) = substring("mysqltest_for_comparison.t1 488070860",instr("mysqltest_for_comparison.t1 488070860",".t1")),"ok","failure")
|
|
|
|
|
ok
|
2007-11-13 18:49:00 +01:00
|
|
|
* compared t1 to old version
|
* WL#4137 Maria- Framework for testing recovery in mysql-test-run
See test maria-recovery.test for a model; all include scripts have
an "API" section at start if they do take parameters from outside.
* Fixing bug reported by Jani and Monty (when two REDOs about the same
page in one group, see ma_blockrec.c).
* Fixing small bugs in recovery
mysql-test/include/wait_until_connected_again.inc:
be sure to enter the loop (the previous query by the caller may not have
failed: it could be
query;
mysqladmin shutdown;
call this script).
mysql-test/lib/mtr_process.pl:
* Through the "expect" file a test can tell mtr that a server crash
is expected. What the file contains is irrelevant. Now if its last
line starts with "wait", mtr will wait before restarting (it will
wait for the last line to not start with "wait"). This is for
tests which need to mangle files under the feet of a dead mysqld.
* Remove "expect" file before restarting; otherwise there could be a
race condition: tests sees server restarted, does something, writes
an "expect" file, and then mtr removes that file, then
test kills mysqld, and then mtr will never restart it.
storage/maria/ma_blockrec.c:
- when applying a REDO in recovery, we don't anymore put UNDO's LSN on the page
at once; indeed if in this REDO's group there comes another REDO
for the same page it would be wrongly skipped. Instead, we keep
pages pinned, don't change their LSN. When done with all REDOs
of the group we unpin them and stamp them with UNDO's LSN.
- fixing bug in applying of REDO_PURGE_BLOCKS in recovery: page_range
sometimes has TAIL_BIT set, need to turn it down to know the real page
range.
- Both bugs are covered in maria-recovery.test
storage/maria/ma_checkpoint.c:
Capability to, in debug builds only, do some special operations
(flush all bitmap and data pages, flush state, flush log)
and crash mysqld, to later test recovery.
Driven by some --debug=d, symbols.
storage/maria/ma_open.c:
debugging info
storage/maria/ma_pagecache.c:
Now that we can _ma_unpin_all_pages() during the REDO phase
to set page's LSN, the assertion needs to be relaxed.
storage/maria/ma_recovery.c:
- open trace file in append mode (useful when a test triggers several
recoveries, we see them all).
- fixing wrong error detection, it's possible that during recovery
we want to open an already open table.
- when applying a REDO in recovery, we don't anymore put UNDO's LSN on the page
at once; indeed if in this REDO's group there comes another REDO
for the same page it would be wrongly skipped. Instead, we keep
pages pinned, don't change their LSN. When done with all REDOs
of the group we unpin them and stamp them with UNDO's LSN.
- we verify that all log records of a group are about the same table,
for debugging.
mysql-test/r/maria-recovery.result:
result
mysql-test/t/maria-recovery-master.opt:
crash is expected, core file would take room, stack trace would
wake pushbuild up.
mysql-test/t/maria-recovery.test:
Test of recovery from mysql-test (it is already tested as unit tests
in ma_test_recovery) (WL#4137)
- test that, if recovery is made to start on an empty table it can
replay the effects of committed and uncommitted statements (having only
the committed ones in the end result). This should be the first test
for someone writing code of new REDOs.
- test that, if mysqld is crashed and recovery runs we have only
committed statements in the end result. Crashes are done in different
ways: flush nothing (so, uncommitted statement is often missing
from the log => no rollback to do); flush pagecache (implicitely flushes
log (WAL)) and flush log, both causes rollbacks; flush log can also
flush state (state.records etc) to test recovery of the state
(not tested well now as we repair the index anyway).
- test of bug found by Jani and Monty in recovery (two REDO about
the same page in one group).
mysql-test/include/maria_empty_logs.inc:
removes logs, to have a clean sheet for testing recovery.
mysql-test/include/maria_make_snapshot.inc:
copies a table to another directory, or back, or compares both
(comparison is not implemented as physical comparison is impossible
if an UNDO phase happened).
mysql-test/include/maria_make_snapshot_for_comparison.inc:
copies tables to another directory so that they can later
serve as a comparison reference (they are the good tables,
recovery should produce similar ones).
mysql-test/include/maria_make_snapshot_for_feeding_recovery.inc:
When we want to force recovery to start on old tables, we prepare
old tables with this script: we put them in a spare directory.
They are later copied back over mysqltest tables while mysqld is dead.
We also need to copy back the control file, otherwise mysqld,
in recovery, would start from the latest checkpoint: latest
checkpoint plus old tables is not a recovery-possible scenario of course.
mysql-test/include/maria_verify_recovery.inc:
causes mysqld to crash, restores old tables if requested,
lets recovery run, compares resulting tables with reference tables
by using CHECKSUM TABLE.
We don't do any sanity checks on page's LSN in resulting tables, yet.
2007-11-13 17:12:29 +01:00
|
|
|
use mysqltest;
|
|
|
|
|
select * from t1;
|
|
|
|
|
a
|
|
|
|
|
00000000
|
2007-11-13 18:49:00 +01:00
|
|
|
* TEST of REDO+UNDO: normal recovery test (no moving tables under its feet)
|
* WL#4137 Maria- Framework for testing recovery in mysql-test-run
See test maria-recovery.test for a model; all include scripts have
an "API" section at start if they do take parameters from outside.
* Fixing bug reported by Jani and Monty (when two REDOs about the same
page in one group, see ma_blockrec.c).
* Fixing small bugs in recovery
mysql-test/include/wait_until_connected_again.inc:
be sure to enter the loop (the previous query by the caller may not have
failed: it could be
query;
mysqladmin shutdown;
call this script).
mysql-test/lib/mtr_process.pl:
* Through the "expect" file a test can tell mtr that a server crash
is expected. What the file contains is irrelevant. Now if its last
line starts with "wait", mtr will wait before restarting (it will
wait for the last line to not start with "wait"). This is for
tests which need to mangle files under the feet of a dead mysqld.
* Remove "expect" file before restarting; otherwise there could be a
race condition: tests sees server restarted, does something, writes
an "expect" file, and then mtr removes that file, then
test kills mysqld, and then mtr will never restart it.
storage/maria/ma_blockrec.c:
- when applying a REDO in recovery, we don't anymore put UNDO's LSN on the page
at once; indeed if in this REDO's group there comes another REDO
for the same page it would be wrongly skipped. Instead, we keep
pages pinned, don't change their LSN. When done with all REDOs
of the group we unpin them and stamp them with UNDO's LSN.
- fixing bug in applying of REDO_PURGE_BLOCKS in recovery: page_range
sometimes has TAIL_BIT set, need to turn it down to know the real page
range.
- Both bugs are covered in maria-recovery.test
storage/maria/ma_checkpoint.c:
Capability to, in debug builds only, do some special operations
(flush all bitmap and data pages, flush state, flush log)
and crash mysqld, to later test recovery.
Driven by some --debug=d, symbols.
storage/maria/ma_open.c:
debugging info
storage/maria/ma_pagecache.c:
Now that we can _ma_unpin_all_pages() during the REDO phase
to set page's LSN, the assertion needs to be relaxed.
storage/maria/ma_recovery.c:
- open trace file in append mode (useful when a test triggers several
recoveries, we see them all).
- fixing wrong error detection, it's possible that during recovery
we want to open an already open table.
- when applying a REDO in recovery, we don't anymore put UNDO's LSN on the page
at once; indeed if in this REDO's group there comes another REDO
for the same page it would be wrongly skipped. Instead, we keep
pages pinned, don't change their LSN. When done with all REDOs
of the group we unpin them and stamp them with UNDO's LSN.
- we verify that all log records of a group are about the same table,
for debugging.
mysql-test/r/maria-recovery.result:
result
mysql-test/t/maria-recovery-master.opt:
crash is expected, core file would take room, stack trace would
wake pushbuild up.
mysql-test/t/maria-recovery.test:
Test of recovery from mysql-test (it is already tested as unit tests
in ma_test_recovery) (WL#4137)
- test that, if recovery is made to start on an empty table it can
replay the effects of committed and uncommitted statements (having only
the committed ones in the end result). This should be the first test
for someone writing code of new REDOs.
- test that, if mysqld is crashed and recovery runs we have only
committed statements in the end result. Crashes are done in different
ways: flush nothing (so, uncommitted statement is often missing
from the log => no rollback to do); flush pagecache (implicitely flushes
log (WAL)) and flush log, both causes rollbacks; flush log can also
flush state (state.records etc) to test recovery of the state
(not tested well now as we repair the index anyway).
- test of bug found by Jani and Monty in recovery (two REDO about
the same page in one group).
mysql-test/include/maria_empty_logs.inc:
removes logs, to have a clean sheet for testing recovery.
mysql-test/include/maria_make_snapshot.inc:
copies a table to another directory, or back, or compares both
(comparison is not implemented as physical comparison is impossible
if an UNDO phase happened).
mysql-test/include/maria_make_snapshot_for_comparison.inc:
copies tables to another directory so that they can later
serve as a comparison reference (they are the good tables,
recovery should produce similar ones).
mysql-test/include/maria_make_snapshot_for_feeding_recovery.inc:
When we want to force recovery to start on old tables, we prepare
old tables with this script: we put them in a spare directory.
They are later copied back over mysqltest tables while mysqld is dead.
We also need to copy back the control file, otherwise mysqld,
in recovery, would start from the latest checkpoint: latest
checkpoint plus old tables is not a recovery-possible scenario of course.
mysql-test/include/maria_verify_recovery.inc:
causes mysqld to crash, restores old tables if requested,
lets recovery run, compares resulting tables with reference tables
by using CHECKSUM TABLE.
We don't do any sanity checks on page's LSN in resulting tables, yet.
2007-11-13 17:12:29 +01:00
|
|
|
insert into t1 values ("00000000");
|
|
|
|
|
flush table t1;
|
|
|
|
|
* copied t1 for comparison
|
|
|
|
|
lock tables t1 write;
|
|
|
|
|
insert into t1 values ("aaaaaaaaa");
|
|
|
|
|
SET SESSION debug="+d,maria_crash";
|
|
|
|
|
* crashing mysqld intentionally
|
|
|
|
|
set global maria_checkpoint_interval=1;
|
|
|
|
|
ERROR HY000: Lost connection to MySQL server during query
|
|
|
|
|
* recovery happens
|
|
|
|
|
* rebuilding index (until we have recovery of index)
|
|
|
|
|
repair table t1 quick;
|
|
|
|
|
Table Op Msg_type Msg_text
|
|
|
|
|
mysqltest.t1 repair status OK
|
|
|
|
|
* testing that checksum after recovery is as expected
|
|
|
|
|
select if(substring("mysqltest.t1 976141720",instr("mysqltest.t1 976141720",".t1")) = substring("mysqltest_for_comparison.t1 976141720",instr("mysqltest_for_comparison.t1 976141720",".t1")),"ok","failure");
|
|
|
|
|
if(substring("mysqltest.t1 976141720",instr("mysqltest.t1 976141720",".t1")) = substring("mysqltest_for_comparison.t1 976141720",instr("mysqltest_for_comparison.t1 976141720",".t1")),"ok","failure")
|
|
|
|
|
ok
|
|
|
|
|
use mysqltest;
|
|
|
|
|
select * from t1;
|
|
|
|
|
a
|
|
|
|
|
00000000
|
|
|
|
|
00000000
|
|
|
|
|
insert into t1 values ("00000000");
|
|
|
|
|
flush table t1;
|
|
|
|
|
* copied t1 for comparison
|
|
|
|
|
lock tables t1 write;
|
|
|
|
|
insert into t1 values ("aaaaaaaaa");
|
|
|
|
|
SET SESSION debug="+d,maria_flush_whole_page_cache,maria_crash";
|
|
|
|
|
* crashing mysqld intentionally
|
|
|
|
|
set global maria_checkpoint_interval=1;
|
|
|
|
|
ERROR HY000: Lost connection to MySQL server during query
|
|
|
|
|
* recovery happens
|
|
|
|
|
* rebuilding index (until we have recovery of index)
|
|
|
|
|
repair table t1 quick;
|
|
|
|
|
Table Op Msg_type Msg_text
|
|
|
|
|
mysqltest.t1 repair status OK
|
|
|
|
|
* testing that checksum after recovery is as expected
|
|
|
|
|
select if(substring("mysqltest.t1 1464212580",instr("mysqltest.t1 1464212580",".t1")) = substring("mysqltest_for_comparison.t1 1464212580",instr("mysqltest_for_comparison.t1 1464212580",".t1")),"ok","failure");
|
|
|
|
|
if(substring("mysqltest.t1 1464212580",instr("mysqltest.t1 1464212580",".t1")) = substring("mysqltest_for_comparison.t1 1464212580",instr("mysqltest_for_comparison.t1 1464212580",".t1")),"ok","failure")
|
|
|
|
|
ok
|
|
|
|
|
use mysqltest;
|
|
|
|
|
select * from t1;
|
|
|
|
|
a
|
|
|
|
|
00000000
|
|
|
|
|
00000000
|
|
|
|
|
00000000
|
|
|
|
|
insert into t1 values ("00000000");
|
|
|
|
|
flush table t1;
|
|
|
|
|
* copied t1 for comparison
|
|
|
|
|
lock tables t1 write;
|
|
|
|
|
insert into t1 values ("aaaaaaaaa");
|
|
|
|
|
SET SESSION debug="+d,maria_flush_states,maria_flush_whole_log,maria_crash";
|
|
|
|
|
* crashing mysqld intentionally
|
|
|
|
|
set global maria_checkpoint_interval=1;
|
|
|
|
|
ERROR HY000: Lost connection to MySQL server during query
|
|
|
|
|
* recovery happens
|
|
|
|
|
* rebuilding index (until we have recovery of index)
|
|
|
|
|
repair table t1 quick;
|
|
|
|
|
Table Op Msg_type Msg_text
|
|
|
|
|
mysqltest.t1 repair status OK
|
|
|
|
|
* testing that checksum after recovery is as expected
|
|
|
|
|
select if(substring("mysqltest.t1 1952283440",instr("mysqltest.t1 1952283440",".t1")) = substring("mysqltest_for_comparison.t1 1952283440",instr("mysqltest_for_comparison.t1 1952283440",".t1")),"ok","failure");
|
|
|
|
|
if(substring("mysqltest.t1 1952283440",instr("mysqltest.t1 1952283440",".t1")) = substring("mysqltest_for_comparison.t1 1952283440",instr("mysqltest_for_comparison.t1 1952283440",".t1")),"ok","failure")
|
|
|
|
|
ok
|
|
|
|
|
use mysqltest;
|
|
|
|
|
select * from t1;
|
|
|
|
|
a
|
|
|
|
|
00000000
|
|
|
|
|
00000000
|
|
|
|
|
00000000
|
|
|
|
|
00000000
|
|
|
|
|
insert into t1 values ("00000000");
|
|
|
|
|
flush table t1;
|
|
|
|
|
* copied t1 for comparison
|
|
|
|
|
lock tables t1 write;
|
|
|
|
|
insert into t1 values ("aaaaaaaaa");
|
|
|
|
|
SET SESSION debug="+d,maria_flush_whole_log,maria_crash";
|
|
|
|
|
* crashing mysqld intentionally
|
|
|
|
|
set global maria_checkpoint_interval=1;
|
|
|
|
|
ERROR HY000: Lost connection to MySQL server during query
|
|
|
|
|
* recovery happens
|
|
|
|
|
* rebuilding index (until we have recovery of index)
|
|
|
|
|
repair table t1 quick;
|
|
|
|
|
Table Op Msg_type Msg_text
|
|
|
|
|
mysqltest.t1 repair status OK
|
|
|
|
|
* testing that checksum after recovery is as expected
|
|
|
|
|
select if(substring("mysqltest.t1 2440354300",instr("mysqltest.t1 2440354300",".t1")) = substring("mysqltest_for_comparison.t1 2440354300",instr("mysqltest_for_comparison.t1 2440354300",".t1")),"ok","failure");
|
|
|
|
|
if(substring("mysqltest.t1 2440354300",instr("mysqltest.t1 2440354300",".t1")) = substring("mysqltest_for_comparison.t1 2440354300",instr("mysqltest_for_comparison.t1 2440354300",".t1")),"ok","failure")
|
|
|
|
|
ok
|
|
|
|
|
use mysqltest;
|
|
|
|
|
select * from t1;
|
|
|
|
|
a
|
|
|
|
|
00000000
|
|
|
|
|
00000000
|
|
|
|
|
00000000
|
|
|
|
|
00000000
|
|
|
|
|
00000000
|
|
|
|
|
drop table t1;
|
|
|
|
|
* shut down mysqld, removed logs, restarted it
|
|
|
|
|
use mysqltest;
|
|
|
|
|
CREATE TABLE t1 (
|
|
|
|
|
i int,
|
|
|
|
|
b blob default NULL,
|
|
|
|
|
c varchar(6000) default NULL
|
|
|
|
|
) ENGINE=MARIA CHECKSUM=1;
|
|
|
|
|
* copied t1 for feeding_recovery
|
|
|
|
|
INSERT INTO t1 VALUES (1, REPEAT('a', 5000), REPEAT('b', 5000));
|
|
|
|
|
UPDATE t1 SET i=3, b=CONCAT(b,'c') WHERE i=1;
|
|
|
|
|
SELECT LENGTH(b) FROM t1 WHERE i=3;
|
|
|
|
|
LENGTH(b)
|
|
|
|
|
5001
|
|
|
|
|
flush table t1;
|
|
|
|
|
* copied t1 for comparison
|
|
|
|
|
SET SESSION debug="+d,maria_flush_whole_log,maria_crash";
|
|
|
|
|
* crashing mysqld intentionally
|
|
|
|
|
set global maria_checkpoint_interval=1;
|
|
|
|
|
ERROR HY000: Lost connection to MySQL server during query
|
|
|
|
|
* copied t1 back for feeding_recovery
|
|
|
|
|
* recovery happens
|
|
|
|
|
* rebuilding index (until we have recovery of index)
|
|
|
|
|
repair table t1 quick;
|
|
|
|
|
Table Op Msg_type Msg_text
|
|
|
|
|
mysqltest.t1 repair status OK
|
|
|
|
|
* testing that checksum after recovery is as expected
|
|
|
|
|
select if(substring("mysqltest.t1 3472399915",instr("mysqltest.t1 3472399915",".t1")) = substring("mysqltest_for_comparison.t1 3472399915",instr("mysqltest_for_comparison.t1 3472399915",".t1")),"ok","failure");
|
|
|
|
|
if(substring("mysqltest.t1 3472399915",instr("mysqltest.t1 3472399915",".t1")) = substring("mysqltest_for_comparison.t1 3472399915",instr("mysqltest_for_comparison.t1 3472399915",".t1")),"ok","failure")
|
|
|
|
|
ok
|
|
|
|
|
use mysqltest;
|
|
|
|
|
SELECT LENGTH(b) FROM t1 WHERE i=3;
|
|
|
|
|
LENGTH(b)
|
|
|
|
|
5001
|
|
|
|
|
drop table t1;
|
|
|
|
|
drop database mysqltest_for_feeding_recovery;
|
|
|
|
|
drop database mysqltest_for_comparison;
|
|
|
|
|
drop database mysqltest;
|