-
Notifications
You must be signed in to change notification settings - Fork 713
New issue
Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.
By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.
Already on GitHub? Sign in to your account
Fix handling race conditions on statistics writes when DDSE is MyRocks #1363
Fix handling race conditions on statistics writes when DDSE is MyRocks #1363
Conversation
If two threads attempt to update statistics for the same object in parallel, one of them may fail, and the failure is discarded. InnoDB fails with ER_DUP_ENTRY, but MyRocks may return ER_LOCK_WAIT_TIMEOUT instead in the same situation, thus handle accordingly. The server layer patch could be avoided by making MyRocks return ER_DUP_ENTRY too in the same situation, but I don't see an obvious way to do it. This fixes main.information_schema_statistics and main.alter_table_myisam when DDSE == MyRocks
@luqun has imported this pull request. If you are a Meta employee, you can view this diff on Phabricator. |
#1363 If deadlock detection is excluded, then in order not to patch the server layer MyRocks would need to return |
pushed.. |
#1363) Summary: If two threads attempt to update statistics for the same object in parallel, one of them may fail, and the failure is discarded. InnoDB fails with ER_DUP_ENTRY, but MyRocks may return ER_LOCK_WAIT_TIMEOUT instead in the same situation, thus handle accordingly. The server layer patch could be avoided by making MyRocks return ER_DUP_ENTRY too in the same situation, but I don't see an obvious way to do it. This fixes main.information_schema_statistics and main.alter_table_myisam when DDSE == MyRocks Pull Request resolved: #1363 Differential Revision: D49595129 fbshipit-source-id: 8e304def5aa00062da3d0c8948fdfceeaf1db81e
facebook#1363) Summary: If two threads attempt to update statistics for the same object in parallel, one of them may fail, and the failure is discarded. InnoDB fails with ER_DUP_ENTRY, but MyRocks may return ER_LOCK_WAIT_TIMEOUT instead in the same situation, thus handle accordingly. The server layer patch could be avoided by making MyRocks return ER_DUP_ENTRY too in the same situation, but I don't see an obvious way to do it. This fixes main.information_schema_statistics and main.alter_table_myisam when DDSE == MyRocks Pull Request resolved: facebook#1363 Differential Revision: D49595129
The fix was PR'ed in facebook#1363 without a testcase. Squash with f176e2b
The fix was PR'ed in facebook#1363 without a testcase. Squash with f176e2b
facebook#1363) Summary: If two threads attempt to update statistics for the same object in parallel, one of them may fail, and the failure is discarded. InnoDB fails with ER_DUP_ENTRY, but MyRocks may return ER_LOCK_WAIT_TIMEOUT instead in the same situation, thus handle accordingly. The server layer patch could be avoided by making MyRocks return ER_DUP_ENTRY too in the same situation, but I don't see an obvious way to do it. This fixes main.information_schema_statistics and main.alter_table_myisam when DDSE == MyRocks Pull Request resolved: facebook#1363 Differential Revision: D49595129
facebook#1363) Summary: If two threads attempt to update statistics for the same object in parallel, one of them may fail, and the failure is discarded. InnoDB fails with ER_DUP_ENTRY, but MyRocks may return ER_LOCK_WAIT_TIMEOUT instead in the same situation, thus handle accordingly. The server layer patch could be avoided by making MyRocks return ER_DUP_ENTRY too in the same situation, but I don't see an obvious way to do it. This fixes main.information_schema_statistics and main.alter_table_myisam when DDSE == MyRocks Pull Request resolved: facebook#1363 Differential Revision: D49595129
facebook#1363) Summary: If two threads attempt to update statistics for the same object in parallel, one of them may fail, and the failure is discarded. InnoDB fails with ER_DUP_ENTRY, but MyRocks may return ER_LOCK_WAIT_TIMEOUT instead in the same situation, thus handle accordingly. The server layer patch could be avoided by making MyRocks return ER_DUP_ENTRY too in the same situation, but I don't see an obvious way to do it. This fixes main.information_schema_statistics and main.alter_table_myisam when DDSE == MyRocks Pull Request resolved: facebook#1363 Differential Revision: D49595129
facebook#1363) Summary: If two threads attempt to update statistics for the same object in parallel, one of them may fail, and the failure is discarded. InnoDB fails with ER_DUP_ENTRY, but MyRocks may return ER_LOCK_WAIT_TIMEOUT instead in the same situation, thus handle accordingly. The server layer patch could be avoided by making MyRocks return ER_DUP_ENTRY too in the same situation, but I don't see an obvious way to do it. This fixes main.information_schema_statistics and main.alter_table_myisam when DDSE == MyRocks Pull Request resolved: facebook#1363 Differential Revision: D49595129
facebook#1363) Summary: If two threads attempt to update statistics for the same object in parallel, one of them may fail, and the failure is discarded. InnoDB fails with ER_DUP_ENTRY, but MyRocks may return ER_LOCK_WAIT_TIMEOUT instead in the same situation, thus handle accordingly. The server layer patch could be avoided by making MyRocks return ER_DUP_ENTRY too in the same situation, but I don't see an obvious way to do it. This fixes main.information_schema_statistics and main.alter_table_myisam when DDSE == MyRocks Pull Request resolved: facebook#1363 Differential Revision: D49595129
facebook#1363) Summary: If two threads attempt to update statistics for the same object in parallel, one of them may fail, and the failure is discarded. InnoDB fails with ER_DUP_ENTRY, but MyRocks may return ER_LOCK_WAIT_TIMEOUT instead in the same situation, thus handle accordingly. The server layer patch could be avoided by making MyRocks return ER_DUP_ENTRY too in the same situation, but I don't see an obvious way to do it. This fixes main.information_schema_statistics and main.alter_table_myisam when DDSE == MyRocks Pull Request resolved: facebook#1363 Differential Revision: D49595129
facebook#1363) Summary: If two threads attempt to update statistics for the same object in parallel, one of them may fail, and the failure is discarded. InnoDB fails with ER_DUP_ENTRY, but MyRocks may return ER_LOCK_WAIT_TIMEOUT instead in the same situation, thus handle accordingly. The server layer patch could be avoided by making MyRocks return ER_DUP_ENTRY too in the same situation, but I don't see an obvious way to do it. This fixes main.information_schema_statistics and main.alter_table_myisam when DDSE == MyRocks Pull Request resolved: facebook#1363 Differential Revision: D49595129
facebook#1363) Summary: If two threads attempt to update statistics for the same object in parallel, one of them may fail, and the failure is discarded. InnoDB fails with ER_DUP_ENTRY, but MyRocks may return ER_LOCK_WAIT_TIMEOUT instead in the same situation, thus handle accordingly. The server layer patch could be avoided by making MyRocks return ER_DUP_ENTRY too in the same situation, but I don't see an obvious way to do it. This fixes main.information_schema_statistics and main.alter_table_myisam when DDSE == MyRocks Pull Request resolved: facebook#1363 Differential Revision: D49595129
facebook#1363) Summary: If two threads attempt to update statistics for the same object in parallel, one of them may fail, and the failure is discarded. InnoDB fails with ER_DUP_ENTRY, but MyRocks may return ER_LOCK_WAIT_TIMEOUT instead in the same situation, thus handle accordingly. The server layer patch could be avoided by making MyRocks return ER_DUP_ENTRY too in the same situation, but I don't see an obvious way to do it. This fixes main.information_schema_statistics and main.alter_table_myisam when DDSE == MyRocks Pull Request resolved: facebook#1363 Differential Revision: D49595129
facebook#1363) Summary: If two threads attempt to update statistics for the same object in parallel, one of them may fail, and the failure is discarded. InnoDB fails with ER_DUP_ENTRY, but MyRocks may return ER_LOCK_WAIT_TIMEOUT instead in the same situation, thus handle accordingly. The server layer patch could be avoided by making MyRocks return ER_DUP_ENTRY too in the same situation, but I don't see an obvious way to do it. This fixes main.information_schema_statistics and main.alter_table_myisam when DDSE == MyRocks Pull Request resolved: facebook#1363 Differential Revision: D49595129
facebook#1363) Summary: If two threads attempt to update statistics for the same object in parallel, one of them may fail, and the failure is discarded. InnoDB fails with ER_DUP_ENTRY, but MyRocks may return ER_LOCK_WAIT_TIMEOUT instead in the same situation, thus handle accordingly. The server layer patch could be avoided by making MyRocks return ER_DUP_ENTRY too in the same situation, but I don't see an obvious way to do it. This fixes main.information_schema_statistics and main.alter_table_myisam when DDSE == MyRocks Pull Request resolved: facebook#1363 Differential Revision: D49595129
facebook#1363) Summary: If two threads attempt to update statistics for the same object in parallel, one of them may fail, and the failure is discarded. InnoDB fails with ER_DUP_ENTRY, but MyRocks may return ER_LOCK_WAIT_TIMEOUT instead in the same situation, thus handle accordingly. The server layer patch could be avoided by making MyRocks return ER_DUP_ENTRY too in the same situation, but I don't see an obvious way to do it. This fixes main.information_schema_statistics and main.alter_table_myisam when DDSE == MyRocks Pull Request resolved: facebook#1363 Differential Revision: D49595129
facebook#1363) Summary: If two threads attempt to update statistics for the same object in parallel, one of them may fail, and the failure is discarded. InnoDB fails with ER_DUP_ENTRY, but MyRocks may return ER_LOCK_WAIT_TIMEOUT instead in the same situation, thus handle accordingly. The server layer patch could be avoided by making MyRocks return ER_DUP_ENTRY too in the same situation, but I don't see an obvious way to do it. This fixes main.information_schema_statistics and main.alter_table_myisam when DDSE == MyRocks Pull Request resolved: facebook#1363 Differential Revision: D49595129
facebook#1363) Summary: If two threads attempt to update statistics for the same object in parallel, one of them may fail, and the failure is discarded. InnoDB fails with ER_DUP_ENTRY, but MyRocks may return ER_LOCK_WAIT_TIMEOUT instead in the same situation, thus handle accordingly. The server layer patch could be avoided by making MyRocks return ER_DUP_ENTRY too in the same situation, but I don't see an obvious way to do it. This fixes main.information_schema_statistics and main.alter_table_myisam when DDSE == MyRocks Pull Request resolved: facebook#1363 Differential Revision: D49595129
facebook#1363) Summary: If two threads attempt to update statistics for the same object in parallel, one of them may fail, and the failure is discarded. InnoDB fails with ER_DUP_ENTRY, but MyRocks may return ER_LOCK_WAIT_TIMEOUT instead in the same situation, thus handle accordingly. The server layer patch could be avoided by making MyRocks return ER_DUP_ENTRY too in the same situation, but I don't see an obvious way to do it. This fixes main.information_schema_statistics and main.alter_table_myisam when DDSE == MyRocks Pull Request resolved: facebook#1363 Differential Revision: D49595129
facebook#1363) Summary: If two threads attempt to update statistics for the same object in parallel, one of them may fail, and the failure is discarded. InnoDB fails with ER_DUP_ENTRY, but MyRocks may return ER_LOCK_WAIT_TIMEOUT instead in the same situation, thus handle accordingly. The server layer patch could be avoided by making MyRocks return ER_DUP_ENTRY too in the same situation, but I don't see an obvious way to do it. This fixes main.information_schema_statistics and main.alter_table_myisam when DDSE == MyRocks Pull Request resolved: facebook#1363 Differential Revision: D49595129
facebook#1363) Summary: If two threads attempt to update statistics for the same object in parallel, one of them may fail, and the failure is discarded. InnoDB fails with ER_DUP_ENTRY, but MyRocks may return ER_LOCK_WAIT_TIMEOUT instead in the same situation, thus handle accordingly. The server layer patch could be avoided by making MyRocks return ER_DUP_ENTRY too in the same situation, but I don't see an obvious way to do it. This fixes main.information_schema_statistics and main.alter_table_myisam when DDSE == MyRocks Pull Request resolved: facebook#1363 Differential Revision: D49595129
facebook#1363) Summary: If two threads attempt to update statistics for the same object in parallel, one of them may fail, and the failure is discarded. InnoDB fails with ER_DUP_ENTRY, but MyRocks may return ER_LOCK_WAIT_TIMEOUT instead in the same situation, thus handle accordingly. The server layer patch could be avoided by making MyRocks return ER_DUP_ENTRY too in the same situation, but I don't see an obvious way to do it. This fixes main.information_schema_statistics and main.alter_table_myisam when DDSE == MyRocks Pull Request resolved: facebook#1363 Differential Revision: D49595129
facebook#1363) Summary: If two threads attempt to update statistics for the same object in parallel, one of them may fail, and the failure is discarded. InnoDB fails with ER_DUP_ENTRY, but MyRocks may return ER_LOCK_WAIT_TIMEOUT instead in the same situation, thus handle accordingly. The server layer patch could be avoided by making MyRocks return ER_DUP_ENTRY too in the same situation, but I don't see an obvious way to do it. This fixes main.information_schema_statistics and main.alter_table_myisam when DDSE == MyRocks Pull Request resolved: facebook#1363 Differential Revision: D49595129
facebook#1363) Summary: If two threads attempt to update statistics for the same object in parallel, one of them may fail, and the failure is discarded. InnoDB fails with ER_DUP_ENTRY, but MyRocks may return ER_LOCK_WAIT_TIMEOUT instead in the same situation, thus handle accordingly. The server layer patch could be avoided by making MyRocks return ER_DUP_ENTRY too in the same situation, but I don't see an obvious way to do it. This fixes main.information_schema_statistics and main.alter_table_myisam when DDSE == MyRocks Pull Request resolved: facebook#1363 Differential Revision: D49595129
If two threads attempt to update statistics for the same object in parallel, one of them may fail, and the failure is discarded. InnoDB fails with ER_DUP_ENTRY, but MyRocks may return ER_LOCK_WAIT_TIMEOUT instead in the same situation, thus handle accordingly. The server layer patch could be avoided by making MyRocks return ER_DUP_ENTRY too in the same situation, but I don't see an obvious way to do it.
This fixes main.information_schema_statistics and main.alter_table_myisam when DDSE == MyRocks