mirror of
https://github.com/MariaDB/server.git
synced 2025-01-17 20:42:30 +01:00
aae4932775
As reported in MDEV-11969 "there's no way to ditch knowledge" about some domain that is no longer updated on a server. Besides being of annoyance to clutter output in DBA console stale domains can prevent the slave to connect the master as MDEV-12012 witnesses. What domain is obsolete must be evaluated by the user (DBA) according to whether the domain info is still relevant and will the domain ever receive any update. This patch introduces a method to discard obsolete gtid domains from the server binlog state. The removal requires no event group from such domain present in existing binlog files though. If there are any the containing logs must be first PURGEd in order for FLUSH BINARY LOGS DELETE_DOMAIN_ID=(list-of-domains) succeed. Otherwise the command returns an error. The list of obsolete domains can be computed through intersecting two sets - the earliest (first) binlog's Gtid_list and the current value of @@global.gtid_binlog_state - and extracting the domain id components from the intersection list items. The new DELETE_DOMAIN_ID featured FLUSH continues to rotate binlog omitting the deleted domains from the active binlog file's Gtid_list. Notice though when the command is ineffective - that none of requested to delete domain exists in the binlog state - rotation does not occur. Obsolete domain deletion is not harmful for connected slaves as long as master side binlog files *purge* is synchronized with FLUSH-DELETE_DOMAIN_ID. The slaves must have the last event from purged files processed as usual, in order not to bump later into requesting a gtid from a file which was already gone. While the command is not replicated (as ordinary FLUSH BINLOG LOGS is) slaves, even though having extra domains, won't suffer from reconnection errors thanks to master-slave gtid connection protocol allowing the master to be ignorant about a gtid domain. Should at failover such slave to be promoted into master role it may run the ex-master's FLUSH BINARY LOGS DELETE_DOMAIN_ID=(list-of-domains) to clean its own binlog state. NOTES. suite/perfschema/r/start_server_low_digest.result is re-recorded as consequence of internal parser codes changes.
617 lines
19 KiB
C++
617 lines
19 KiB
C++
/* Copyright (c) 2010, 2016, Oracle and/or its affiliates.
|
|
Copyright (c) 2011, 2016, MariaDB
|
|
|
|
This program is free software; you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation; version 2 of the License.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program; if not, write to the Free Software
|
|
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */
|
|
|
|
#include <my_global.h>
|
|
#include "sql_reload.h"
|
|
#include "sql_priv.h"
|
|
#include "mysqld.h" // select_errors
|
|
#include "sql_class.h" // THD
|
|
#include "sql_acl.h" // acl_reload
|
|
#include "sql_servers.h" // servers_reload
|
|
#include "sql_connect.h" // reset_mqh
|
|
#include "sql_base.h" // close_cached_tables
|
|
#include "sql_db.h" // my_dbopt_cleanup
|
|
#include "hostname.h" // hostname_cache_refresh
|
|
#include "sql_repl.h" // reset_master, reset_slave
|
|
#include "rpl_mi.h" // Master_info::data_lock
|
|
#include "sql_show.h"
|
|
#include "debug_sync.h"
|
|
#include "des_key_file.h"
|
|
|
|
static void disable_checkpoints(THD *thd);
|
|
|
|
/**
|
|
Reload/resets privileges and the different caches.
|
|
|
|
@param thd Thread handler (can be NULL!)
|
|
@param options What should be reset/reloaded (tables, privileges, slave...)
|
|
@param tables Tables to flush (if any)
|
|
@param write_to_binlog < 0 if there was an error while interacting with the binary log inside
|
|
reload_acl_and_cache,
|
|
0 if we should not write to the binary log,
|
|
> 0 if we can write to the binlog.
|
|
|
|
|
|
@note Depending on 'options', it may be very bad to write the
|
|
query to the binlog (e.g. FLUSH SLAVE); this is a
|
|
pointer where reload_acl_and_cache() will put 0 if
|
|
it thinks we really should not write to the binlog.
|
|
Otherwise it will put 1.
|
|
|
|
@return Error status code
|
|
@retval 0 Ok
|
|
@retval !=0 Error; thd->killed is set or thd->is_error() is true
|
|
*/
|
|
|
|
bool reload_acl_and_cache(THD *thd, unsigned long long options,
|
|
TABLE_LIST *tables, int *write_to_binlog)
|
|
{
|
|
bool result=0;
|
|
select_errors=0; /* Write if more errors */
|
|
int tmp_write_to_binlog= *write_to_binlog= 1;
|
|
|
|
DBUG_ASSERT(!thd || !thd->in_sub_stmt);
|
|
|
|
#ifndef NO_EMBEDDED_ACCESS_CHECKS
|
|
if (options & REFRESH_GRANT)
|
|
{
|
|
THD *tmp_thd= 0;
|
|
/*
|
|
If reload_acl_and_cache() is called from SIGHUP handler we have to
|
|
allocate temporary THD for execution of acl_reload()/grant_reload().
|
|
*/
|
|
if (!thd && (thd= (tmp_thd= new THD)))
|
|
{
|
|
thd->thread_stack= (char*) &tmp_thd;
|
|
thd->store_globals();
|
|
}
|
|
|
|
if (thd)
|
|
{
|
|
bool reload_acl_failed= acl_reload(thd);
|
|
bool reload_grants_failed= grant_reload(thd);
|
|
bool reload_servers_failed= servers_reload(thd);
|
|
|
|
if (reload_acl_failed || reload_grants_failed || reload_servers_failed)
|
|
{
|
|
result= 1;
|
|
/*
|
|
When an error is returned, my_message may have not been called and
|
|
the client will hang waiting for a response.
|
|
*/
|
|
my_error(ER_UNKNOWN_ERROR, MYF(0));
|
|
}
|
|
}
|
|
opt_noacl= 0;
|
|
|
|
if (tmp_thd)
|
|
{
|
|
delete tmp_thd;
|
|
thd= 0;
|
|
}
|
|
reset_mqh((LEX_USER *)NULL, TRUE);
|
|
}
|
|
#endif
|
|
if (options & REFRESH_LOG)
|
|
{
|
|
/*
|
|
Flush the normal query log, the update log, the binary log,
|
|
the slow query log, the relay log (if it exists) and the log
|
|
tables.
|
|
*/
|
|
|
|
options|= REFRESH_BINARY_LOG;
|
|
options|= REFRESH_RELAY_LOG;
|
|
options|= REFRESH_SLOW_LOG;
|
|
options|= REFRESH_GENERAL_LOG;
|
|
options|= REFRESH_ENGINE_LOG;
|
|
options|= REFRESH_ERROR_LOG;
|
|
}
|
|
|
|
if (options & REFRESH_ERROR_LOG)
|
|
if (flush_error_log())
|
|
{
|
|
/*
|
|
When flush_error_log() failed, my_error() has not been called.
|
|
So, we have to do it here to keep the protocol.
|
|
*/
|
|
my_error(ER_UNKNOWN_ERROR, MYF(0));
|
|
result= 1;
|
|
}
|
|
|
|
if ((options & REFRESH_SLOW_LOG) && global_system_variables.sql_log_slow)
|
|
logger.flush_slow_log();
|
|
|
|
if ((options & REFRESH_GENERAL_LOG) && opt_log)
|
|
logger.flush_general_log();
|
|
|
|
if (options & REFRESH_ENGINE_LOG)
|
|
if (ha_flush_logs(NULL))
|
|
result= 1;
|
|
|
|
if (options & REFRESH_BINARY_LOG)
|
|
{
|
|
/*
|
|
Writing this command to the binlog may result in infinite loops
|
|
when doing mysqlbinlog|mysql, and anyway it does not really make
|
|
sense to log it automatically (would cause more trouble to users
|
|
than it would help them)
|
|
*/
|
|
tmp_write_to_binlog= 0;
|
|
if (mysql_bin_log.is_open())
|
|
{
|
|
DYNAMIC_ARRAY *drop_gtid_domain=
|
|
(thd && (thd->lex->delete_gtid_domain.elements > 0)) ?
|
|
&thd->lex->delete_gtid_domain : NULL;
|
|
if (mysql_bin_log.rotate_and_purge(true, drop_gtid_domain))
|
|
*write_to_binlog= -1;
|
|
|
|
if (WSREP_ON)
|
|
{
|
|
/* Wait for last binlog checkpoint event to be logged. */
|
|
mysql_bin_log.wait_for_last_checkpoint_event();
|
|
}
|
|
}
|
|
}
|
|
if (options & REFRESH_RELAY_LOG)
|
|
{
|
|
#ifdef HAVE_REPLICATION
|
|
LEX_STRING connection_name;
|
|
Master_info *mi;
|
|
if (thd)
|
|
connection_name= thd->lex->relay_log_connection_name;
|
|
else
|
|
{
|
|
connection_name.str= (char*) "";
|
|
connection_name.length= 0;
|
|
}
|
|
|
|
/*
|
|
Writing this command to the binlog may cause problems as the
|
|
slave is not likely to have the same connection names.
|
|
*/
|
|
tmp_write_to_binlog= 0;
|
|
if (connection_name.length == 0)
|
|
{
|
|
if (master_info_index->flush_all_relay_logs())
|
|
*write_to_binlog= -1;
|
|
}
|
|
else if (!(mi= (get_master_info(&connection_name,
|
|
Sql_condition::WARN_LEVEL_ERROR))))
|
|
{
|
|
result= 1;
|
|
}
|
|
else
|
|
{
|
|
mysql_mutex_lock(&mi->data_lock);
|
|
if (rotate_relay_log(mi))
|
|
*write_to_binlog= -1;
|
|
mysql_mutex_unlock(&mi->data_lock);
|
|
mi->release();
|
|
}
|
|
#endif
|
|
}
|
|
#ifdef HAVE_QUERY_CACHE
|
|
if (options & REFRESH_QUERY_CACHE_FREE)
|
|
{
|
|
query_cache.pack(thd); // FLUSH QUERY CACHE
|
|
options &= ~REFRESH_QUERY_CACHE; // Don't flush cache, just free memory
|
|
}
|
|
if (options & (REFRESH_TABLES | REFRESH_QUERY_CACHE))
|
|
{
|
|
query_cache.flush(); // RESET QUERY CACHE
|
|
}
|
|
#endif /*HAVE_QUERY_CACHE*/
|
|
|
|
DBUG_ASSERT(!thd || thd->locked_tables_mode ||
|
|
!thd->mdl_context.has_locks() ||
|
|
thd->handler_tables_hash.records ||
|
|
thd->ull_hash.records ||
|
|
thd->global_read_lock.is_acquired());
|
|
|
|
/*
|
|
Note that if REFRESH_READ_LOCK bit is set then REFRESH_TABLES is set too
|
|
(see sql_yacc.yy)
|
|
*/
|
|
if (options & (REFRESH_TABLES | REFRESH_READ_LOCK))
|
|
{
|
|
if ((options & REFRESH_READ_LOCK) && thd)
|
|
{
|
|
/*
|
|
On the first hand we need write lock on the tables to be flushed,
|
|
on the other hand we must not try to aspire a global read lock
|
|
if we have a write locked table as this would lead to a deadlock
|
|
when trying to reopen (and re-lock) the table after the flush.
|
|
*/
|
|
if (thd->locked_tables_mode)
|
|
{
|
|
my_error(ER_LOCK_OR_ACTIVE_TRANSACTION, MYF(0));
|
|
return 1;
|
|
}
|
|
/*
|
|
Writing to the binlog could cause deadlocks, as we don't log
|
|
UNLOCK TABLES
|
|
*/
|
|
tmp_write_to_binlog= 0;
|
|
if (thd->global_read_lock.lock_global_read_lock(thd))
|
|
return 1; // Killed
|
|
if (close_cached_tables(thd, tables,
|
|
((options & REFRESH_FAST) ? FALSE : TRUE),
|
|
thd->variables.lock_wait_timeout))
|
|
{
|
|
/*
|
|
NOTE: my_error() has been already called by reopen_tables() within
|
|
close_cached_tables().
|
|
*/
|
|
thd->global_read_lock.unlock_global_read_lock(thd);
|
|
return 1;
|
|
}
|
|
|
|
if (thd->global_read_lock.make_global_read_lock_block_commit(thd)) // Killed
|
|
{
|
|
/* Don't leave things in a half-locked state */
|
|
thd->global_read_lock.unlock_global_read_lock(thd);
|
|
return 1;
|
|
}
|
|
if (options & REFRESH_CHECKPOINT)
|
|
disable_checkpoints(thd);
|
|
/*
|
|
We need to do it second time after wsrep appliers were blocked in
|
|
make_global_read_lock_block_commit(thd) above since they could have
|
|
modified the tables too.
|
|
*/
|
|
if (WSREP(thd) &&
|
|
close_cached_tables(thd, tables, (options & REFRESH_FAST) ?
|
|
FALSE : TRUE, TRUE))
|
|
result= 1;
|
|
}
|
|
else
|
|
{
|
|
if (thd && thd->locked_tables_mode)
|
|
{
|
|
/*
|
|
If we are under LOCK TABLES we should have a write
|
|
lock on tables which we are going to flush.
|
|
*/
|
|
if (tables)
|
|
{
|
|
for (TABLE_LIST *t= tables; t; t= t->next_local)
|
|
if (!find_table_for_mdl_upgrade(thd, t->db, t->table_name, false))
|
|
return 1;
|
|
}
|
|
else
|
|
{
|
|
/*
|
|
It is not safe to upgrade the metadata lock without GLOBAL IX lock.
|
|
This can happen with FLUSH TABLES <list> WITH READ LOCK as we in
|
|
these cases don't take a GLOBAL IX lock in order to be compatible
|
|
with global read lock.
|
|
*/
|
|
if (thd->open_tables &&
|
|
!thd->mdl_context.is_lock_owner(MDL_key::GLOBAL, "", "",
|
|
MDL_INTENTION_EXCLUSIVE))
|
|
{
|
|
my_error(ER_TABLE_NOT_LOCKED_FOR_WRITE, MYF(0),
|
|
thd->open_tables->s->table_name.str);
|
|
return true;
|
|
}
|
|
|
|
for (TABLE *tab= thd->open_tables; tab; tab= tab->next)
|
|
{
|
|
if (! tab->mdl_ticket->is_upgradable_or_exclusive())
|
|
{
|
|
my_error(ER_TABLE_NOT_LOCKED_FOR_WRITE, MYF(0),
|
|
tab->s->table_name.str);
|
|
return 1;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
#ifdef WITH_WSREP
|
|
if (thd && thd->wsrep_applier)
|
|
{
|
|
/*
|
|
In case of applier thread, do not wait for table share(s) to be
|
|
removed from table definition cache.
|
|
*/
|
|
options|= REFRESH_FAST;
|
|
}
|
|
#endif
|
|
if (close_cached_tables(thd, tables,
|
|
((options & REFRESH_FAST) ? FALSE : TRUE),
|
|
(thd ? thd->variables.lock_wait_timeout :
|
|
LONG_TIMEOUT)))
|
|
{
|
|
/*
|
|
NOTE: my_error() has been already called by reopen_tables() within
|
|
close_cached_tables().
|
|
*/
|
|
result= 1;
|
|
}
|
|
}
|
|
my_dbopt_cleanup();
|
|
}
|
|
if (options & REFRESH_HOSTS)
|
|
hostname_cache_refresh();
|
|
if (thd && (options & REFRESH_STATUS))
|
|
refresh_status(thd);
|
|
if (options & REFRESH_THREADS)
|
|
flush_thread_cache();
|
|
#ifdef HAVE_REPLICATION
|
|
if (options & REFRESH_MASTER)
|
|
{
|
|
DBUG_ASSERT(thd);
|
|
tmp_write_to_binlog= 0;
|
|
if (reset_master(thd, NULL, 0, thd->lex->next_binlog_file_number))
|
|
{
|
|
/* NOTE: my_error() has been already called by reset_master(). */
|
|
result= 1;
|
|
}
|
|
}
|
|
#endif
|
|
#ifdef HAVE_OPENSSL
|
|
if (options & REFRESH_DES_KEY_FILE)
|
|
{
|
|
if (des_key_file && load_des_key_file(des_key_file))
|
|
{
|
|
/* NOTE: my_error() has been already called by load_des_key_file(). */
|
|
result= 1;
|
|
}
|
|
}
|
|
#endif
|
|
#ifdef HAVE_REPLICATION
|
|
if (options & REFRESH_SLAVE)
|
|
{
|
|
LEX_MASTER_INFO* lex_mi= &thd->lex->mi;
|
|
Master_info *mi;
|
|
tmp_write_to_binlog= 0;
|
|
|
|
if (!(mi= get_master_info(&lex_mi->connection_name,
|
|
Sql_condition::WARN_LEVEL_ERROR)))
|
|
{
|
|
result= 1;
|
|
}
|
|
else
|
|
{
|
|
/* The following will fail if slave is running */
|
|
if (reset_slave(thd, mi))
|
|
{
|
|
mi->release();
|
|
/* NOTE: my_error() has been already called by reset_slave(). */
|
|
result= 1;
|
|
}
|
|
else if (mi->connection_name.length && thd->lex->reset_slave_info.all)
|
|
{
|
|
/* If not default connection and 'all' is used */
|
|
mi->release();
|
|
mysql_mutex_lock(&LOCK_active_mi);
|
|
if (master_info_index->remove_master_info(mi))
|
|
result= 1;
|
|
mysql_mutex_unlock(&LOCK_active_mi);
|
|
}
|
|
else
|
|
mi->release();
|
|
}
|
|
}
|
|
#endif
|
|
if (options & REFRESH_USER_RESOURCES)
|
|
reset_mqh((LEX_USER *) NULL, 0); /* purecov: inspected */
|
|
if (options & REFRESH_GENERIC)
|
|
{
|
|
List_iterator_fast<LEX_STRING> li(thd->lex->view_list);
|
|
LEX_STRING *ls;
|
|
while ((ls= li++))
|
|
{
|
|
ST_SCHEMA_TABLE *table= find_schema_table(thd, ls->str);
|
|
if (table->reset_table())
|
|
result= 1;
|
|
}
|
|
}
|
|
if (*write_to_binlog != -1)
|
|
*write_to_binlog= tmp_write_to_binlog;
|
|
/*
|
|
If the query was killed then this function must fail.
|
|
*/
|
|
return result || (thd ? thd->killed : 0);
|
|
}
|
|
|
|
|
|
/**
|
|
Implementation of FLUSH TABLES <table_list> WITH READ LOCK
|
|
and FLUSH TABLES <table_list> FOR EXPORT
|
|
|
|
In brief: take exclusive locks, expel tables from the table
|
|
cache, reopen the tables, enter the 'LOCKED TABLES' mode,
|
|
downgrade the locks.
|
|
Note: the function is written to be called from
|
|
mysql_execute_command(), it is not reusable in arbitrary
|
|
execution context.
|
|
|
|
Required privileges
|
|
-------------------
|
|
Since the statement implicitly enters LOCK TABLES mode,
|
|
it requires LOCK TABLES privilege on every table.
|
|
But since the rest of FLUSH commands require
|
|
the global RELOAD_ACL, it also requires RELOAD_ACL.
|
|
|
|
Compatibility with the global read lock
|
|
---------------------------------------
|
|
We don't wait for the GRL, since neither the
|
|
5.1 combination that this new statement is intended to
|
|
replace (LOCK TABLE <list> WRITE; FLUSH TABLES;),
|
|
nor FLUSH TABLES WITH READ LOCK do.
|
|
@todo: this is not implemented, Dmitry disagrees.
|
|
Currently we wait for GRL in another connection,
|
|
but are compatible with a GRL in our own connection.
|
|
|
|
Behaviour under LOCK TABLES
|
|
---------------------------
|
|
Bail out: i.e. don't perform an implicit UNLOCK TABLES.
|
|
This is not consistent with LOCK TABLES statement, but is
|
|
in line with behaviour of FLUSH TABLES WITH READ LOCK, and we
|
|
try to not introduce any new statements with implicit
|
|
semantics.
|
|
|
|
Compatibility with parallel updates
|
|
-----------------------------------
|
|
As a result, we will wait for all open transactions
|
|
against the tables to complete. After the lock downgrade,
|
|
new transactions will be able to read the tables, but not
|
|
write to them.
|
|
|
|
Differences from FLUSH TABLES <list>
|
|
-------------------------------------
|
|
- you can't flush WITH READ LOCK a non-existent table
|
|
- you can't flush WITH READ LOCK under LOCK TABLES
|
|
|
|
Effect on views and temporary tables.
|
|
------------------------------------
|
|
You can only apply this command to existing base tables.
|
|
If a view with such name exists, ER_WRONG_OBJECT is returned.
|
|
If a temporary table with such name exists, it's ignored:
|
|
if there is a base table, it's used, otherwise ER_NO_SUCH_TABLE
|
|
is returned.
|
|
|
|
Handling of MERGE tables
|
|
------------------------
|
|
For MERGE table this statement will open and lock child tables
|
|
for read (it is impossible to lock parent table without it).
|
|
Child tables won't be flushed unless they are explicitly present
|
|
in the statement's table list.
|
|
|
|
Implicit commit
|
|
---------------
|
|
This statement causes an implicit commit before and
|
|
after it.
|
|
|
|
HANDLER SQL
|
|
-----------
|
|
If this connection has HANDLERs open against
|
|
some of the tables being FLUSHed, these handlers
|
|
are implicitly flushed (lose their position).
|
|
*/
|
|
|
|
bool flush_tables_with_read_lock(THD *thd, TABLE_LIST *all_tables)
|
|
{
|
|
Lock_tables_prelocking_strategy lock_tables_prelocking_strategy;
|
|
TABLE_LIST *table_list;
|
|
|
|
/*
|
|
This is called from SQLCOM_FLUSH, the transaction has
|
|
been committed implicitly.
|
|
*/
|
|
|
|
if (thd->locked_tables_mode)
|
|
{
|
|
my_error(ER_LOCK_OR_ACTIVE_TRANSACTION, MYF(0));
|
|
goto error;
|
|
}
|
|
|
|
if (thd->lex->type & REFRESH_READ_LOCK)
|
|
{
|
|
/*
|
|
Acquire SNW locks on tables to be flushed. Don't acquire global
|
|
IX and database-scope IX locks on the tables as this will make
|
|
this statement incompatible with FLUSH TABLES WITH READ LOCK.
|
|
*/
|
|
if (lock_table_names(thd, all_tables, NULL,
|
|
thd->variables.lock_wait_timeout,
|
|
MYSQL_OPEN_SKIP_SCOPED_MDL_LOCK))
|
|
goto error;
|
|
|
|
DEBUG_SYNC(thd,"flush_tables_with_read_lock_after_acquire_locks");
|
|
|
|
for (table_list= all_tables; table_list;
|
|
table_list= table_list->next_global)
|
|
{
|
|
/* Request removal of table from cache. */
|
|
tdc_remove_table(thd, TDC_RT_REMOVE_UNUSED,
|
|
table_list->db,
|
|
table_list->table_name, FALSE);
|
|
/* Reset ticket to satisfy asserts in open_tables(). */
|
|
table_list->mdl_request.ticket= NULL;
|
|
}
|
|
}
|
|
|
|
thd->variables.option_bits|= OPTION_TABLE_LOCK;
|
|
|
|
/*
|
|
Before opening and locking tables the below call also waits
|
|
for old shares to go away, so the fact that we don't pass
|
|
MYSQL_OPEN_IGNORE_FLUSH flag to it is important.
|
|
Also we don't pass MYSQL_OPEN_HAS_MDL_LOCK flag as we want
|
|
to open underlying tables if merge table is flushed.
|
|
For underlying tables of the merge the below call has to
|
|
acquire SNW locks to ensure that they can be locked for
|
|
read without further waiting.
|
|
*/
|
|
if (open_and_lock_tables(thd, all_tables, FALSE,
|
|
MYSQL_OPEN_SKIP_SCOPED_MDL_LOCK,
|
|
&lock_tables_prelocking_strategy))
|
|
goto error_reset_bits;
|
|
|
|
if (thd->lex->type & REFRESH_FOR_EXPORT)
|
|
{
|
|
// Check if all storage engines support FOR EXPORT.
|
|
for (TABLE_LIST *table_list= all_tables; table_list;
|
|
table_list= table_list->next_global)
|
|
{
|
|
if (!(table_list->table->file->ha_table_flags() & HA_CAN_EXPORT))
|
|
{
|
|
my_error(ER_ILLEGAL_HA, MYF(0),table_list->table->file->table_type(),
|
|
table_list->db, table_list->table_name);
|
|
goto error_reset_bits;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (thd->locked_tables_list.init_locked_tables(thd))
|
|
goto error_reset_bits;
|
|
|
|
|
|
/*
|
|
We don't downgrade MDL_SHARED_NO_WRITE here as the intended
|
|
post effect of this call is identical to LOCK TABLES <...> READ,
|
|
and we didn't use thd->in_lock_talbes and
|
|
thd->sql_command= SQLCOM_LOCK_TABLES hacks to enter the LTM.
|
|
*/
|
|
|
|
return FALSE;
|
|
|
|
error_reset_bits:
|
|
close_thread_tables(thd);
|
|
thd->variables.option_bits&= ~OPTION_TABLE_LOCK;
|
|
error:
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
/**
|
|
Disable checkpoints for all handlers
|
|
This is released in unlock_global_read_lock()
|
|
*/
|
|
|
|
static void disable_checkpoints(THD *thd)
|
|
{
|
|
if (!thd->global_disable_checkpoint)
|
|
{
|
|
thd->global_disable_checkpoint= 1;
|
|
if (!global_disable_checkpoint++)
|
|
ha_checkpoint_state(1); // Disable checkpoints
|
|
}
|
|
}
|
|
|