Menu:
event-scheduler-thread-states:: Event Scheduler Thread States
To ascertain what your MySQL server is doing, it can be helpful to examine the process list, which indicates the operations currently being performed by the set of threads executing within the server. For example:
mysql> SHOW PROCESSLIST\G
*************************** 1. row ***************************
Id: 1
User: event_scheduler
Host: localhost
db: NULL
Command: Daemon
Time: 2756681
State: Waiting on empty queue
Info: NULL
*************************** 2. row ***************************
Id: 20
User: me
Host: localhost:52943
db: test
Command: Query
Time: 0
State: starting
Info: SHOW PROCESSLISTThreads can be killed with the note 'KILL': kill. statement. See note kill::.
File: manual.info.tmp, Node: processlist-access, Next: thread-commands, Prev: thread-information, Up: thread-information
The following discussion enumerates the sources of process information, the privileges required to see process information, and describes the content of process list entries.
*note processlist-sources::
*note processlist-privileges::
*note processlist-content::
Sources of Process Information
Process information is available from these sources:
The note 'SHOW PROCESSLIST': show-processlist. statement: note show-processlist::
The note 'mysqladmin processlist': mysqladmin. command: note mysqladmin::
The 'INFORMATION_SCHEMA' note 'PROCESSLIST': information-schema-processlist-table. table: note information-schema-processlist-table::
The Performance Schema note 'processlist': performance-schema-processlist-table. table: note performance-schema-processlist-table::
The Performance Schema note 'threads': performance-schema-threads-table. table columns with names having a prefix of 'PROCESSLIST_': note performance-schema-threads-table::
The 'sys' schema note 'processlist': sys-processlist. and note 'session': sys-session. views: note sys-processlist::, and note sys-session::
The note 'threads': performance-schema-threads-table. table compares to note 'SHOW PROCESSLIST': show-processlist, 'INFORMATION_SCHEMA' note 'PROCESSLIST': information-schema-processlist-table, and note 'mysqladmin processlist': mysqladmin. as follows:
Access to the *note 'threads': performance-schema-threads-table. table does not require a mutex and has minimal impact on server performance. The other sources have negative performance consequences because they require a mutex.
Note:
As of MySQL 5.7.39, an alternative implementation for note 'SHOW PROCESSLIST': show-processlist. is available based on the Performance Schema note 'processlist': performance-schema-processlist-table. table, which, like the note 'threads': performance-schema-threads-table. table, does not require a mutex and has better performance characteristics. For details, see note performance-schema-processlist-table::.
The note 'threads': performance-schema-threads-table. table displays background threads, which the other sources do not. It also provides additional information for each thread that the other sources do not, such as whether the thread is a foreground or background thread, and the location within the server associated with the thread. This means that the note 'threads': performance-schema-threads-table. table can be used to monitor thread activity the other sources cannot.
You can enable or disable Performance Schema thread monitoring, as described in *note performance-schema-threads-table::.
For these reasons, DBAs who perform server monitoring using one of the other thread information sources may wish to monitor using the *note 'threads': performance-schema-threads-table. table instead.
The 'sys' schema note 'processlist': sys-processlist. view presents information from the Performance Schema note 'threads': performance-schema-threads-table. table in a more accessible format. The 'sys' schema note 'session': sys-session. view presents information about user sessions like the 'sys' schema note 'processlist': sys-processlist. view, but with background processes filtered out.
Privileges Required to Access the Process List
For most sources of process information, if you have the 'PROCESS' privilege, you can see all threads, even those belonging to other users. Otherwise (without the 'PROCESS' privilege), nonanonymous users have access to information about their own threads but not threads for other users, and anonymous users have no access to thread information.
The Performance Schema note 'threads': performance-schema-threads-table. table also provides thread information, but table access uses a different privilege model. See note performance-schema-threads-table::.
Content of Process List Entries
Each process list entry contains several pieces of information. The following list describes them using the labels from *note 'SHOW PROCESSLIST': show-processlist. output. Other process information sources use similar labels.
'Id' is the connection identifier for the client associated with the thread.
'User' and 'Host' indicate the account associated with the thread.
'db' is the default database for the thread, or 'NULL' if none has been selected.
'Command' and 'State' indicate what the thread is doing.
Most states correspond to very quick operations. If a thread stays in a given state for many seconds, there might be a problem that needs to be investigated.
The following sections list the possible 'Command' values, and 'State' values grouped by category. The meaning for some of these values is self-evident. For others, additional description is provided.
Note:
Applications that examine process list information should be aware that the commands and states are subject to change.
'Time' indicates how long the thread has been in its current state. The thread's notion of the current time may be altered in some cases: The thread can change the time with note 'SET TIMESTAMP = VALUE': set-variable. For a replica SQL thread, the value is the number of seconds between the timestamp of the last replicated event and the real time of the replica host. See note replication-threads::.
'Info' indicates the statement the thread is executing, or 'NULL' if it is executing no statement. For note 'SHOW PROCESSLIST': show-processlist, this value contains only the first 100 characters of the statement. To see complete statements, use note 'SHOW FULL PROCESSLIST': show-processlist. (or query a diffferent process information source).
File: manual.info.tmp, Node: thread-commands, Next: general-thread-states, Prev: processlist-access, Up: thread-information
A thread can have any of the following 'Command' values:
'Binlog Dump'
This is a thread on a replication source for sending binary log contents to a replica.
'Change user'
The thread is executing a change user operation.
'Close stmt'
The thread is closing a prepared statement.
'Connect'
A replica is connected to its source.
'Connect Out'
A replica is connecting to its source.
'Create DB'
The thread is executing a create database operation.
'Daemon'
This thread is internal to the server, not a thread that services a client connection.
'Debug'
The thread is generating debugging information.
'Delayed insert'
The thread is a delayed insert handler.
'Drop DB'
The thread is executing a drop database operation.
'Error'
'Execute'
The thread is executing a prepared statement.
'Fetch'
The thread is fetching the results from executing a prepared statement.
'Field List'
The thread is retrieving information for table columns.
'Init DB'
The thread is selecting a default database.
'Kill'
The thread is killing another thread.
'Long Data'
The thread is retrieving long data in the result of executing a prepared statement.
'Ping'
The thread is handling a server ping request.
'Prepare'
The thread is preparing a prepared statement.
'Processlist'
The thread is producing information about server threads.
'Query'
The thread is executing a statement.
'Quit'
The thread is terminating.
'Refresh'
The thread is flushing table, logs, or caches, or resetting status variable or replication server information.
'Register Slave'
The thread is registering a replica server.
'Reset stmt'
The thread is resetting a prepared statement.
'Set option'
The thread is setting or resetting a client statement execution option.
'Shutdown'
The thread is shutting down the server.
'Sleep'
The thread is waiting for the client to send a new statement to it.
'Statistics'
The thread is producing server status information.
'Time'
Unused.
File: manual.info.tmp, Node: general-thread-states, Next: query-cache-thread-states, Prev: thread-commands, Up: thread-information
The following list describes thread 'State' values that are associated with general query processing and not more specialized activities such as replication. Many of these are useful only for finding bugs in the server.
'After create'
This occurs when the thread creates a table (including internal temporary tables), at the end of the function that creates the table. This state is used even if the table could not be created due to some error.
'altering table'
The server is in the process of executing an in-place *note 'ALTER TABLE': alter-table.
'Analyzing'
The thread is calculating a 'MyISAM' table key distributions (for example, for *note 'ANALYZE TABLE': analyze-table.).
'checking permissions'
The thread is checking whether the server has the required privileges to execute the statement.
'Checking table'
The thread is performing a table check operation.
'cleaning up'
The thread has processed one command and is preparing to free memory and reset certain state variables.
'committing alter table to storage engine'
The server has finished an in-place *note 'ALTER TABLE': alter-table. and is committing the result.
'closing tables'
The thread is flushing the changed table data to disk and closing the used tables. This should be a fast operation. If not, verify that you do not have a full disk and that the disk is not in very heavy use.
'converting HEAP to ondisk'
The thread is converting an internal temporary table from a 'MEMORY' table to an on-disk table.
'copy to tmp table'
The thread is processing an *note 'ALTER TABLE': alter-table. statement. This state occurs after the table with the new structure has been created but before rows are copied into it.
For a thread in this state, the Performance Schema can be used to obtain about the progress of the copy operation. See *note performance-schema-stage-tables::.
'Copying to group table'
If a statement has different 'ORDER BY' and 'GROUP BY' criteria, the rows are sorted by group and copied to a temporary table.
'Copying to tmp table'
The server is copying to a temporary table in memory.
'Copying to tmp table on disk'
The server is copying to a temporary table on disk. The temporary result set has become too large (see *note internal-temporary-tables::). Consequently, the thread is changing the temporary table from in-memory to disk-based format to save memory.
'Creating index'
The thread is processing 'ALTER TABLE ... ENABLE KEYS' for a 'MyISAM' table.
'Creating sort index'
The thread is processing a *note 'SELECT': select. that is resolved using an internal temporary table.
'creating table'
The thread is creating a table. This includes creation of temporary tables.
'Creating tmp table'
The thread is creating a temporary table in memory or on disk. If the table is created in memory but later is converted to an on-disk table, the state during that operation is 'Copying to tmp table on disk'.
'deleting from main table'
The server is executing the first part of a multiple-table delete. It is deleting only from the first table, and saving columns and offsets to be used for deleting from the other (reference) tables.
'deleting from reference tables'
The server is executing the second part of a multiple-table delete and deleting the matched rows from the other tables.
'discard_or_import_tablespace'
The thread is processing an 'ALTER TABLE ... DISCARD TABLESPACE' or 'ALTER TABLE ... IMPORT TABLESPACE' statement.
'end'
This occurs at the end but before the cleanup of note 'ALTER TABLE': alter-table, note 'CREATE VIEW': create-view, note 'DELETE': delete, note 'INSERT': insert, note 'SELECT': select, or note 'UPDATE': update. statements.
For the 'end' state, the following operations could be happening:
* Removing query cache entries after data in a table is changed
* Writing an event to the binary log
* Freeing memory buffers, including for blobs'executing'
The thread has begun executing a statement.
'Execution of init_command'
The thread is executing statements in the value of the 'init_command' system variable.
'freeing items'
The thread has executed a command. Some freeing of items done during this state involves the query cache. This state is usually followed by 'cleaning up'.
'FULLTEXT initialization'
The server is preparing to perform a natural-language full-text search.
'init'
This occurs before the initialization of note 'ALTER TABLE': alter-table, note 'DELETE': delete, note 'INSERT': insert, note 'SELECT': select, or *note 'UPDATE': update. statements. Actions taken by the server in this state include flushing the binary log, the 'InnoDB' log, and some query cache cleanup operations.
'Killed'
Someone has sent a *note 'KILL': kill. statement to the thread and it should abort next time it checks the kill flag. The flag is checked in each major loop in MySQL, but in some cases it might still take a short time for the thread to die. If the thread is locked by some other thread, the kill takes effect as soon as the other thread releases its lock.
'logging slow query'
The thread is writing a statement to the slow-query log.
'login'
The initial state for a connection thread until the client has been authenticated successfully.
'manage keys'
The server is enabling or disabling a table index.
'Opening tables'
The thread is trying to open a table. This is should be very fast procedure, unless something prevents opening. For example, an note 'ALTER TABLE': alter-table. or a note 'LOCK TABLE': lock-tables. statement can prevent opening a table until the statement is finished. It is also worth checking that your 'table_open_cache' value is large enough.
'optimizing'
The server is performing initial optimizations for a query.
'preparing'
This state occurs during query optimization.
'preparing for alter table'
The server is preparing to execute an in-place *note 'ALTER TABLE': alter-table.
'Purging old relay logs'
The thread is removing unneeded relay log files.
'query end'
This state occurs after processing a query but before the 'freeing items' state.
'Receiving from client'
The server is reading a packet from the client. This state is called 'Reading from net' prior to MySQL 5.7.8.
'Removing duplicates'
The query was using *note 'SELECT DISTINCT': select. in such a way that MySQL could not optimize away the distinct operation at an early stage. Because of this, MySQL requires an extra stage to remove all duplicated rows before sending the result to the client.
'removing tmp table'
The thread is removing an internal temporary table after processing a *note 'SELECT': select. statement. This state is not used if no temporary table was created.
'rename'
The thread is renaming a table.
'rename result table'
The thread is processing an *note 'ALTER TABLE': alter-table. statement, has created the new table, and is renaming it to replace the original table.
'Reopen tables'
The thread got a lock for the table, but noticed after getting the lock that the underlying table structure changed. It has freed the lock, closed the table, and is trying to reopen it.
'Repair by sorting'
The repair code is using a sort to create indexes.
'Repair done'
The thread has completed a multithreaded repair for a 'MyISAM' table.
'Repair with keycache'
The repair code is using creating keys one by one through the key cache. This is much slower than 'Repair by sorting'.
'Rolling back'
The thread is rolling back a transaction.
'Saving state'
For 'MyISAM' table operations such as repair or analysis, the thread is saving the new table state to the '.MYI' file header. State includes information such as number of rows, the 'AUTO_INCREMENT' counter, and key distributions.
'Searching rows for update'
The thread is doing a first phase to find all matching rows before updating them. This has to be done if the *note 'UPDATE': update. is changing the index that is used to find the involved rows.
'Sending data'
The thread is reading and processing rows for a *note 'SELECT': select. statement, and sending data to the client. Because operations occurring during this state tend to perform large amounts of disk access (reads), it is often the longest-running state over the lifetime of a given query.
'Sending to client'
The server is writing a packet to the client. This state is called 'Writing to net' prior to MySQL 5.7.8.
'setup'
The thread is beginning an *note 'ALTER TABLE': alter-table. operation.
'Sorting for group'
The thread is doing a sort to satisfy a 'GROUP BY'.
'Sorting for order'
The thread is doing a sort to satisfy an 'ORDER BY'.
'Sorting index'
The thread is sorting index pages for more efficient access during a 'MyISAM' table optimization operation.
'Sorting result'
For a *note 'SELECT': select. statement, this is similar to 'Creating sort index', but for nontemporary tables.
'starting'
The first stage at the beginning of statement execution.
'statistics'
The server is calculating statistics to develop a query execution plan. If a thread is in this state for a long time, the server is probably disk-bound performing other work.
'System lock'
The thread has called 'mysql_lock_tables()' and the thread state has not been updated since. This is a very general state that can occur for many reasons.
For example, the thread is going to request or is waiting for an internal or external system lock for the table. This can occur when note 'InnoDB': innodb-storage-engine. waits for a table-level lock during execution of note 'LOCK TABLES': lock-tables. If this state is being caused by requests for external locks and you are not using multiple note 'mysqld': mysqld. servers that are accessing the same note 'MyISAM': myisam-storage-engine. tables, you can disable external system locks with the '--skip-external-locking' option. However, external locking is disabled by default, so it is likely that this option has no effect. For *note 'SHOW PROFILE': show-profile, this state means the thread is requesting the lock (not waiting for it).
'update'
The thread is getting ready to start updating the table.
'Updating'
The thread is searching for rows to update and is updating them.
'updating main table'
The server is executing the first part of a multiple-table update. It is updating only the first table, and saving columns and offsets to be used for updating the other (reference) tables.
'updating reference tables'
The server is executing the second part of a multiple-table update and updating the matched rows from the other tables.
'User lock'
The thread is going to request or is waiting for an advisory lock requested with a 'GET_LOCK()' call. For *note 'SHOW PROFILE': show-profile, this state means the thread is requesting the lock (not waiting for it).
'User sleep'
The thread has invoked a 'SLEEP()' call.
'Waiting for commit lock'
'FLUSH TABLES WITH READ LOCK' is waiting for a commit lock.
'Waiting for global read lock'
'FLUSH TABLES WITH READ LOCK' is waiting for a global read lock or the global 'read_only' system variable is being set.
'Waiting for tables'
The thread got a notification that the underlying structure for a table has changed and it needs to reopen the table to get the new structure. However, to reopen the table, it must wait until all other threads have closed the table in question.
This notification takes place if another thread has used 'FLUSH TABLES' or one of the following statements on the table in question: 'FLUSH TABLES TBL_NAME', note 'ALTER TABLE': alter-table, note 'RENAME TABLE': rename-table, note 'REPAIR TABLE': repair-table, note 'ANALYZE TABLE': analyze-table, or *note 'OPTIMIZE TABLE': optimize-table.
'Waiting for table flush'
The thread is executing 'FLUSH TABLES' and is waiting for all threads to close their tables, or the thread got a notification that the underlying structure for a table has changed and it needs to reopen the table to get the new structure. However, to reopen the table, it must wait until all other threads have closed the table in question.
This notification takes place if another thread has used 'FLUSH TABLES' or one of the following statements on the table in question: 'FLUSH TABLES TBL_NAME', note 'ALTER TABLE': alter-table, note 'RENAME TABLE': rename-table, note 'REPAIR TABLE': repair-table, note 'ANALYZE TABLE': analyze-table, or *note 'OPTIMIZE TABLE': optimize-table.
'Waiting for LOCK_TYPE lock'
The server is waiting to acquire a 'THR_LOCK' lock or a lock from the metadata locking subsystem, where LOCK_TYPE indicates the type of lock.
This state indicates a wait for a 'THR_LOCK':
* 'Waiting for table level lock'These states indicate a wait for a metadata lock:
* 'Waiting for event metadata lock'
* 'Waiting for global read lock'
* 'Waiting for schema metadata lock'
* 'Waiting for stored function metadata lock'
* 'Waiting for stored procedure metadata lock'
* 'Waiting for table metadata lock'
* 'Waiting for trigger metadata lock'For information about table lock indicators, see note internal-locking::. For information about metadata locking, see note metadata-locking::. To see which locks are blocking lock requests, use the Performance Schema lock tables described at *note performance-schema-lock-tables::.
'Waiting on cond'
A generic state in which the thread is waiting for a condition to become true. No specific state information is available.
'Writing to net'
The server is writing a packet to the network. This state is called 'Sending to client' as of MySQL 5.7.8.
File: manual.info.tmp, Node: query-cache-thread-states, Next: source-thread-states, Prev: general-thread-states, Up: thread-information
These thread states are associated with the query cache (see *note query-cache::).
'checking privileges on cached query'
The server is checking whether the user has privileges to access a cached query result.
'checking query cache for query'
The server is checking whether the current query is present in the query cache.
'invalidating query cache entries'
Query cache entries are being marked invalid because the underlying tables have changed.
'sending cached result to client'
The server is taking the result of a query from the query cache and sending it to the client.
'storing result in query cache'
The server is storing the result of a query in the query cache.
'Waiting for query cache lock'
This state occurs while a session is waiting to take the query cache lock. This can happen for any statement that needs to perform some query cache operation, such as an note 'INSERT': insert. or note 'DELETE': delete. that invalidates the query cache, a note 'SELECT': select. that looks for a cached entry, note 'RESET QUERY CACHE': reset, and so forth.
File: manual.info.tmp, Node: source-thread-states, Next: replica-io-thread-states, Prev: query-cache-thread-states, Up: thread-information
The following list shows the most common states you may see in the 'State' column for the 'Binlog Dump' thread of the replication source. If you see no 'Binlog Dump' threads on a source, this means that replication is not running; that is, that no replicas are currently connected.
'Finished reading one binlog; switching to next binlog'
The thread has finished reading a binary log file and is opening the next one to send to the replica.
'Master has sent all binlog to slave; waiting for more updates'
The thread has read all remaining updates from the binary logs and sent them to the replica. The thread is now idle, waiting for new events to appear in the binary log resulting from new updates occurring on the source.
'Sending binlog event to slave'
Binary logs consist of events, where an event is usually an update plus some other information. The thread has read an event from the binary log and is now sending it to the replica.
'Waiting to finalize termination'
A very brief state that occurs as the thread is stopping.
File: manual.info.tmp, Node: replica-io-thread-states, Next: replica-sql-thread-states, Prev: source-thread-states, Up: thread-information
The following list shows the most common states you see in the 'State' column for a replica server I/O thread. This state also appears in the 'Slave_IO_State' column displayed by *note 'SHOW SLAVE STATUS': show-slave-status, so you can get a good view of what is happening by using that statement.
'Checking master version'
A state that occurs very briefly, after the connection to the source is established.
'Connecting to master'
The thread is attempting to connect to the source.
'Queueing master event to the relay log'
The thread has read an event and is copying it to the relay log so that the SQL thread can process it.
'Reconnecting after a failed binlog dump request'
The thread is trying to reconnect to the source.
'Reconnecting after a failed master event read'
The thread is trying to reconnect to the source. When connection is established again, the state becomes 'Waiting for master to send event'.
'Registering slave on master'
A state that occurs very briefly after the connection to the source is established.
'Requesting binlog dump'
A state that occurs very briefly, after the connection to the source is established. The thread sends to the source a request for the contents of its binary logs, starting from the requested binary log file name and position.
'Waiting for its turn to commit'
A state that occurs when the replica thread is waiting for older worker threads to commit if 'slave_preserve_commit_order' is enabled.
'Waiting for master to send event'
The thread has connected to the source and is waiting for binary log events to arrive. This can last for a long time if the source is idle. If the wait lasts for 'slave_net_timeout' seconds, a timeout occurs. At that point, the thread considers the connection to be broken and makes an attempt to reconnect.
'Waiting for master update'
The initial state before 'Connecting to master'.
'Waiting for slave mutex on exit'
A state that occurs briefly as the thread is stopping.
'Waiting for the slave SQL thread to free enough relay log space'
You are using a nonzero 'relay_log_space_limit' value, and the relay logs have grown large enough that their combined size exceeds this value. The I/O thread is waiting until the SQL thread frees enough space by processing relay log contents so that it can delete some relay log files.
'Waiting to reconnect after a failed binlog dump request'
If the binary log dump request failed (due to disconnection), the thread goes into this state while it sleeps, then tries to reconnect periodically. The interval between retries can be specified using the *note 'CHANGE MASTER TO': change-master-to. statement.
'Waiting to reconnect after a failed master event read'
An error occurred while reading (due to disconnection). The thread is sleeping for the number of seconds set by the *note 'CHANGE MASTER TO': change-master-to. statement (default 60) before attempting to reconnect.
File: manual.info.tmp, Node: replica-sql-thread-states, Next: replica-connection-thread-states, Prev: replica-io-thread-states, Up: thread-information
The following list shows the most common states you may see in the 'State' column for a replica server SQL thread:
'Making temporary file (append) before replaying LOAD DATA INFILE'
The thread is executing a *note 'LOAD DATA': load-data. statement and is appending the data to a temporary file containing the data from which the replica reads rows.
'Making temporary file (create) before replaying LOAD DATA INFILE'
The thread is executing a note 'LOAD DATA': load-data. statement and is creating a temporary file containing the data from which the replica reads rows. This state can only be encountered if the original note 'LOAD DATA': load-data. statement was logged by a source running a version of MySQL lower than MySQL 5.0.3.
'Reading event from the relay log'
The thread has read an event from the relay log so that the event can be processed.
'Slave has read all relay log; waiting for more updates'
The thread has processed all events in the relay log files, and is now waiting for the I/O thread to write new events to the relay log.
'Waiting for an event from Coordinator'
Using the multithreaded replica ('slave_parallel_workers' is greater than 1), one of the replica worker threads is waiting for an event from the coordinator thread.
'Waiting for slave mutex on exit'
A very brief state that occurs as the thread is stopping.
'Waiting for Slave Workers to free pending events'
This waiting action occurs when the total size of events being processed by Workers exceeds the size of the 'slave_pending_jobs_size_max' system variable. The Coordinator resumes scheduling when the size drops below this limit. This state occurs only when 'slave_parallel_workers' is set greater than'Waiting for the next event in relay log'
The initial state before 'Reading event from the relay log'.
'Waiting until MASTER_DELAY seconds after master executed event'
The SQL thread has read an event but is waiting for the replica delay to lapse. This delay is set with the 'MASTER_DELAY' option of *note 'CHANGE MASTER TO': change-master-to.
The 'Info' column for the SQL thread may also show the text of a statement. This indicates that the thread has read an event from the relay log, extracted the statement from it, and may be executing it.
File: manual.info.tmp, Node: replica-connection-thread-states, Next: mysql-cluster-thread-states, Prev: replica-sql-thread-states, Up: thread-information
These thread states occur on a replica server but are associated with connection threads, not with the I/O or SQL threads.
'Changing master'
The thread is processing a *note 'CHANGE MASTER TO': change-master-to. statement.
'Killing slave'
The thread is processing a 'STOP SLAVE' statement.
'Opening master dump table'
This state occurs after 'Creating table from master dump'.
'Reading master dump table data'
This state occurs after 'Opening master dump table'.
'Rebuilding the index on master dump table'
This state occurs after 'Reading master dump table data'.
File: manual.info.tmp, Node: mysql-cluster-thread-states, Next: event-scheduler-thread-states, Prev: replica-connection-thread-states, Up: thread-information
'Committing events to binlog'
'Opening mysql.ndb_apply_status'
'Processing events'
The thread is processing events for binary logging.
'Processing events from schema table'
The thread is doing the work of schema replication.
'Shutting down'
'Syncing ndb table schema operation and binlog'
This is used to have a correct binary log of schema operations for NDB.
'Waiting for allowed to take ndbcluster global schema lock'
The thread is waiting for permission to take a global schema lock.
'Waiting for event from ndbcluster'
The server is acting as an SQL node in an NDB Cluster, and is connected to a cluster management node.
'Waiting for first event from ndbcluster'
'Waiting for ndbcluster binlog update to reach current position'
'Waiting for ndbcluster global schema lock'
The thread is waiting for a global schema lock held by another thread to be released.
'Waiting for ndbcluster to start'
'Waiting for schema epoch'
The thread is waiting for a schema epoch (that is, a global checkpoint).
File: manual.info.tmp, Node: event-scheduler-thread-states, Prev: mysql-cluster-thread-states, Up: thread-information
These states occur for the Event Scheduler thread, threads that are created to execute scheduled events, or threads that terminate the scheduler.
'Clearing'
The scheduler thread or a thread that was executing an event is terminating and is about to end.
'Initialized'
The scheduler thread or a thread that executes an event has been initialized.
'Waiting for next activation'
The scheduler has a nonempty event queue but the next activation is in the future.
'Waiting for scheduler to stop'
The thread issued 'SET GLOBAL event_scheduler=OFF' and is waiting for the scheduler to stop.
'Waiting on empty queue'
The scheduler's event queue is empty and it is sleeping.
File: manual.info.tmp, Node: optimizer-tracing, Prev: thread-information, Up: optimization