×

Welcome to Knowledge Base!

KB at your finger tips

This is one stop global knowledge base where you can learn about all the products, solutions and support features.

Categories
All
Database-MySQL
MySQL :: MySQL 8.0 Reference Manual :: MySQL Glossary

MySQL Glossary

These terms are commonly used in information about the MySQL database server.

A

.ARM file

Metadata for ARCHIVE tables. Contrast with .ARZ file . Files with this extension are always included in backups produced by the mysqlbackup command of the MySQL Enterprise Backup product.

See Also .ARZ file, MySQL Enterprise Backup, mysqlbackup command.

.ARZ file

Data for ARCHIVE tables. Contrast with .ARM file . Files with this extension are always included in backups produced by the mysqlbackup command of the MySQL Enterprise Backup product.

See Also .ARM file, MySQL Enterprise Backup, mysqlbackup command.

ACID

An acronym standing for atomicity, consistency, isolation, and durability. These properties are all desirable in a database system, and are all closely tied to the notion of a transaction . The transactional features of InnoDB adhere to the ACID principles.

Transactions are atomic units of work that can be committed or rolled back . When a transaction makes multiple changes to the database, either all the changes succeed when the transaction is committed, or all the changes are undone when the transaction is rolled back.

The database remains in a consistent state at all times — after each commit or rollback, and while transactions are in progress. If related data is being updated across multiple tables, queries see either all old values or all new values, not a mix of old and new values.

Transactions are protected (isolated) from each other while they are in progress; they cannot interfere with each other or see each other's uncommitted data. This isolation is achieved through the locking mechanism. Experienced users can adjust the isolation level , trading off less protection in favor of increased performance and concurrency , when they can be sure that the transactions really do not interfere with each other.

The results of transactions are durable: once a commit operation succeeds, the changes made by that transaction are safe from power failures, system crashes, race conditions, or other potential dangers that many non-database applications are vulnerable to. Durability typically involves writing to disk storage, with a certain amount of redundancy to protect against power failures or software crashes during write operations. (In InnoDB , the doublewrite buffer assists with durability.)

See Also atomic, commit, concurrency, doublewrite buffer, isolation level, locking, rollback, transaction.

adaptive flushing

An algorithm for InnoDB tables that smooths out the I/O overhead introduced by checkpoints . Instead of flushing all modified pages from the buffer pool to the data files at once, MySQL periodically flushes small sets of modified pages. The adaptive flushing algorithm extends this process by estimating the optimal rate to perform these periodic flushes, based on the rate of flushing and how fast redo information is generated.

See Also buffer pool, checkpoint, data files, flush, InnoDB, page, redo log.

adaptive hash index

An optimization for InnoDB tables that can speed up lookups using = and IN operators, by constructing a hash index in memory. MySQL monitors index searches for InnoDB tables, and if queries could benefit from a hash index, it builds one automatically for index pages that are frequently accessed. In a sense, the adaptive hash index configures MySQL at runtime to take advantage of ample main memory, coming closer to the architecture of main-memory databases. This feature is controlled by the innodb_adaptive_hash_index configuration option. Because this feature benefits some workloads and not others, and the memory used for the hash index is reserved in the buffer pool , typically you should benchmark with this feature both enabled and disabled.

The hash index is always built based on an existing B-tree index on the table. MySQL can build a hash index on a prefix of any length of the key defined for the B-tree, depending on the pattern of searches against the index. A hash index can be partial; the whole B-tree index does not need to be cached in the buffer pool.

In MySQL 5.6 and higher, another way to take advantage of fast single-value lookups with InnoDB tables is to use the InnoDB memcached plugin. See Section 15.20, “InnoDB memcached Plugin” for details.

See Also B-tree, buffer pool, hash index, memcached, page, secondary index.

ADO.NET

An object-relational mapping (ORM) framework for applications built using .NET technologies such as ASP.NET . Such applications can interface with MySQL through the Connector/NET component.

See Also .NET, ASP.net, Connector/NET, Mono, Visual Studio.

AIO

Acronym for asynchronous I/O . You might see this acronym in InnoDB messages or keywords.

See Also asynchronous I/O.

ANSI

In ODBC , an alternative method of supporting character sets and other internationalization aspects. Contrast with Unicode . Connector/ODBC 3.51 is an ANSI driver, while Connector/ODBC 5.1 is a Unicode driver.

See Also Connector/ODBC, ODBC, Unicode.

API

APIs provide low-level access to the MySQL protocol and MySQL resources from client programs. Contrast with the higher-level access provided by a Connector .

See Also C API, client, connector, native C API, Perl API, PHP API, Python API, Ruby API.

application programming interface (API)

A set of functions or procedures. An API provides a stable set of names and types for functions, procedures, parameters, and return values.

apply

When a backup produced by the MySQL Enterprise Backup product does not include the most recent changes that occurred while the backup was underway, the process of updating the backup files to include those changes is known as the apply step. It is specified by the apply-log option of the mysqlbackup command.

Before the changes are applied, we refer to the files as a raw backup . After the changes are applied, we refer to the files as a prepared backup . The changes are recorded in the ibbackup_logfile file; once the apply step is finished, this file is no longer necessary.

See Also hot backup, ibbackup_logfile, MySQL Enterprise Backup, prepared backup, raw backup.

AS

A Kerberos authentication server. AS can also refer to the authentication service provided by an authentication server.

See Also authentication server.

ASP.net

A framework for developing web-based applications using .NET technologies and languages. Such applications can interface with MySQL through the Connector/NET component.

Another technology for writing server-side web pages with MySQL is PHP .

See Also .NET, ADO.NET, Connector/NET, Mono, PHP, Visual Studio.

assembly

A library of compiled code in a .NET system, accessed through Connector/NET . Stored in the GAC to allow versioning without naming conflicts.

See Also .NET, GAC.

asynchronous I/O

A type of I/O operation that allows other processing to proceed before the I/O is completed. Also known as nonblocking I/O and abbreviated as AIO . InnoDB uses this type of I/O for certain operations that can run in parallel without affecting the reliability of the database, such as reading pages into the buffer pool that have not actually been requested, but might be needed soon.

Historically, InnoDB used asynchronous I/O on Windows systems only. Starting with the InnoDB Plugin 1.1 and MySQL 5.5, InnoDB uses asynchronous I/O on Linux systems. This change introduces a dependency on libaio . Asynchronous I/O on Linux systems is configured using the innodb_use_native_aio option, which is enabled by default. On other Unix-like systems, InnoDB uses synchronous I/O only.

See Also buffer pool, nonblocking I/O.

atomic

In the SQL context, transactions are units of work that either succeed entirely (when committed ) or have no effect at all (when rolled back ). The indivisible ("atomic") property of transactions is the A in the acronym ACID .

See Also ACID, commit, rollback, transaction.

atomic DDL

An atomic DDL statement is one that combines the data dictionary updates, storage engine operations, and binary log writes associated with a DDL operation into a single, atomic transaction. The transaction is either fully committed or rolled back, even if the server halts during the operation. Atomic DDL support was added in MySQL 8.0. For more information, see Section 13.1.1, “Atomic Data Definition Statement Support”.

See Also binary log, data dictionary, DDL, storage engine.

atomic instruction

Special instructions provided by the CPU, to ensure that critical low-level operations cannot be interrupted.

authentication server

In Kerberos, a service that provides the initial ticket needed to obtain a ticket-granting ticket (TGT) that is needed to obtain other tickets from the ticket-granting server (TGS). The authentication server (AS) combined with a TGS make up a key distribution center (KDC).

See Also key distribution center, ticket-granting server.

auto-increment

A property of a table column (specified by the AUTO_INCREMENT keyword) that automatically adds an ascending sequence of values in the column.

It saves work for the developer, not to have to produce new unique values when inserting new rows. It provides useful information for the query optimizer, because the column is known to be not null and with unique values. The values from such a column can be used as lookup keys in various contexts, and because they are auto-generated there is no reason to ever change them; for this reason, primary key columns are often specified as auto-incrementing.

Auto-increment columns can be problematic with statement-based replication, because replaying the statements on a replica might not produce the same set of column values as on the source, due to timing issues. When you have an auto-incrementing primary key, you can use statement-based replication only with the setting innodb_autoinc_lock_mode=1 . If you have innodb_autoinc_lock_mode=2 , which allows higher concurrency for insert operations, use row-based replication rather than statement-based replication . The setting innodb_autoinc_lock_mode=0 should not be used except for compatibility purposes.

Consecutive lock mode ( innodb_autoinc_lock_mode=1 ) is the default setting prior to MySQL 8.0.3. As of MySQL 8.0.3, interleaved lock mode ( innodb_autoinc_lock_mode=2 ) is the default, which reflects the change from statement-based to row-based replication as the default replication type.

See Also auto-increment locking, innodb_autoinc_lock_mode, primary key, row-based replication, statement-based replication.

auto-increment locking

The convenience of an auto-increment primary key involves some tradeoff with concurrency. In the simplest case, if one transaction is inserting values into the table, any other transactions must wait to do their own inserts into that table, so that rows inserted by the first transaction receive consecutive primary key values. InnoDB includes optimizations and the innodb_autoinc_lock_mode option so that you can configure and optimal balance between predictable sequences of auto-increment values and maximum concurrency for insert operations.

See Also auto-increment, concurrency, innodb_autoinc_lock_mode.

autocommit

A setting that causes a commit operation after each SQL statement. This mode is not recommended for working with InnoDB tables with transactions that span several statements. It can help performance for read-only transactions on InnoDB tables, where it minimizes overhead from locking and generation of undo data, especially in MySQL 5.6.4 and up. It is also appropriate for working with MyISAM tables, where transactions are not applicable.

See Also commit, locking, read-only transaction, SQL, transaction, undo.

availability

The ability to cope with, and if necessary recover from, failures on the host, including failures of MySQL, the operating system, or the hardware and maintenance activity that may otherwise cause downtime. Often paired with scalability as critical aspects of a large-scale deployment.

See Also scalability.

B

B-tree

A tree data structure that is popular for use in database indexes. The structure is kept sorted at all times, enabling fast lookup for exact matches (equals operator) and ranges (for example, greater than, less than, and BETWEEN operators). This type of index is available for most storage engines, such as InnoDB and MyISAM .

Because B-tree nodes can have many children, a B-tree is not the same as a binary tree, which is limited to 2 children per node.

Contrast with hash index , which is only available in the MEMORY storage engine. The MEMORY storage engine can also use B-tree indexes, and you should choose B-tree indexes for MEMORY tables if some queries use range operators.

The use of the term B-tree is intended as a reference to the general class of index design. B-tree structures used by MySQL storage engines may be regarded as variants due to sophistications not present in a classic B-tree design. For related information, refer to the InnoDB Page Structure Fil Header section of the MySQL Internals Manual .

See Also hash index.

backticks

Identifiers within MySQL SQL statements must be quoted using the backtick character ( ` ) if they contain special characters or reserved words. For example, to refer to a table named FOO#BAR or a column named SELECT , you would specify the identifiers as `FOO#BAR` and `SELECT` . Since the backticks provide an extra level of safety, they are used extensively in program-generated SQL statements, where the identifier names might not be known in advance.

Many other database systems use double quotation marks ( " ) around such special names. For portability, you can enable ANSI_QUOTES mode in MySQL and use double quotation marks instead of backticks to qualify identifier names.

See Also SQL.

backup

The process of copying some or all table data and metadata from a MySQL instance, for safekeeping. Can also refer to the set of copied files. This is a crucial task for DBAs. The reverse of this process is the restore operation.

With MySQL, physical backups are performed by the MySQL Enterprise Backup product, and logical backups are performed by the mysqldump command. These techniques have different characteristics in terms of size and representation of the backup data, and speed (especially speed of the restore operation).

Backups are further classified as hot , warm , or cold depending on how much they interfere with normal database operation. (Hot backups have the least interference, cold backups the most.)

See Also cold backup, hot backup, logical backup, MySQL Enterprise Backup, mysqldump, physical backup, warm backup.

base column

A non-generated table column upon which a stored generated column or virtual generated column is based. In other words, a base column is a non-generated table column that is part of a generated column definition.

See Also generated column, stored generated column, virtual generated column.

beta

An early stage in the life of a software product, when it is available only for evaluation, typically without a definite release number or a number less than 1. InnoDB does not use the beta designation, preferring an early adopter phase that can extend over several point releases, leading to a GA release.

See Also early adopter, GA.

binary log

A file containing a record of all statements or row changes that attempt to change table data. The contents of the binary log can be replayed to bring replicas up to date in a replication scenario, or to bring a database up to date after restoring table data from a backup. The binary logging feature can be turned on and off, although Oracle recommends always enabling it if you use replication or perform backups.

You can examine the contents of the binary log, or replay it during replication or recovery, by using the mysqlbinlog command. For full information about the binary log, see Section 5.4.4, “The Binary Log”. For MySQL configuration options related to the binary log, see Section 17.1.6.4, “Binary Logging Options and Variables”.

For the MySQL Enterprise Backup product, the file name of the binary log and the current position within the file are important details. To record this information for the source when taking a backup in a replication context, you can specify the --slave-info option.

Prior to MySQL 5.0, a similar capability was available, known as the update log. In MySQL 5.0 and higher, the binary log replaces the update log.

See Also binlog, MySQL Enterprise Backup, replication.

binlog

An informal name for the binary log file. For example, you might see this abbreviation used in e-mail messages or forum discussions.

See Also binary log.

blind query expansion

A special mode of full-text search enabled by the WITH QUERY EXPANSION clause. It performs the search twice, where the search phrase for the second search is the original search phrase concatenated with the few most highly relevant documents from the first search. This technique is mainly applicable for short search phrases, perhaps only a single word. It can uncover relevant matches where the precise search term does not occur in the document.

See Also full-text search.

BLOB

An SQL data type ( TINYBLOB , BLOB , MEDIUMBLOB , and LONGBLOB ) for objects containing any kind of binary data, of arbitrary size. Used for storing documents, images, sound files, and other kinds of information that cannot easily be decomposed to rows and columns within a MySQL table. The techniques for handling BLOBs within a MySQL application vary with each Connector and API . MySQL Connector/ODBC defines BLOB values as LONGVARBINARY . For large, free-form collections of character data, the industry term is CLOB , represented by the MySQL TEXT data types.

See Also API, CLOB, connector, Connector/ODBC.

bottleneck

A portion of a system that is constrained in size or capacity, that has the effect of limiting overall throughput. For example, a memory area might be smaller than necessary; access to a single required resource might prevent multiple CPU cores from running simultaneously; or waiting for disk I/O to complete might prevent the CPU from running at full capacity. Removing bottlenecks tends to improve concurrency . For example, the ability to have multiple InnoDB buffer pool instances reduces contention when multiple sessions read from and write to the buffer pool simultaneously.

See Also buffer pool, concurrency.

bounce

A shutdown operation immediately followed by a restart. Ideally with a relatively short warmup period so that performance and throughput quickly return to a high level.

See Also shutdown.

buddy allocator

A mechanism for managing different-sized pages in the InnoDB buffer pool .

See Also buffer pool, page, page size.

buffer

A memory or disk area used for temporary storage. Data is buffered in memory so that it can be written to disk efficiently, with a few large I/O operations rather than many small ones. Data is buffered on disk for greater reliability, so that it can be recovered even when a crash or other failure occurs at the worst possible time. The main types of buffers used by InnoDB are the buffer pool , the doublewrite buffer , and the change buffer .

See Also buffer pool, change buffer, crash, doublewrite buffer.

buffer pool

The memory area that holds cached InnoDB data for both tables and indexes. For efficiency of high-volume read operations, the buffer pool is divided into pages that can potentially hold multiple rows. For efficiency of cache management, the buffer pool is implemented as a linked list of pages; data that is rarely used is aged out of the cache, using a variation of the LRU algorithm. On systems with large memory, you can improve concurrency by dividing the buffer pool into multiple buffer pool instances .

Several InnoDB status variables, INFORMATION_SCHEMA tables, and performance_schema tables help to monitor the internal workings of the buffer pool. Starting in MySQL 5.6, you can avoid a lengthy warmup period after restarting the server, particularly for instances with large buffer pools, by saving the buffer pool state at server shutdown and restoring the buffer pool to the same state at server startup. See Section 15.8.3.6, “Saving and Restoring the Buffer Pool State”.

See Also buffer pool instance, LRU, page, warm up.

buffer pool instance

Any of the multiple regions into which the buffer pool can be divided, controlled by the innodb_buffer_pool_instances configuration option. The total memory size specified by innodb_buffer_pool_size is divided among all buffer pool instances. Typically, having multiple buffer pool instances is appropriate for systems that allocate multiple gigabytes to the InnoDB buffer pool, with each instance being one gigabyte or larger. On systems loading or looking up large amounts of data in the buffer pool from many concurrent sessions, having multiple buffer pool instances reduces contention for exclusive access to data structures that manage the buffer pool.

See Also buffer pool.

built-in

The built-in InnoDB storage engine within MySQL is the original form of distribution for the storage engine. Contrast with the InnoDB Plugin . Starting with MySQL 5.5, the InnoDB Plugin is merged back into the MySQL code base as the built-in InnoDB storage engine (known as InnoDB 1.1).

This distinction is important mainly in MySQL 5.1, where a feature or bug fix might apply to the InnoDB Plugin but not the built-in InnoDB , or vice versa.

See Also InnoDB.

business rules

The relationships and sequences of actions that form the basis of business software, used to run a commercial company. Sometimes these rules are dictated by law, other times by company policy. Careful planning ensures that the relationships encoded and enforced by the database, and the actions performed through application logic, accurately reflect the real policies of the company and can handle real-life situations.

For example, an employee leaving a company might trigger a sequence of actions from the human resources department. The human resources database might also need the flexibility to represent data about a person who has been hired, but not yet started work. Closing an account at an online service might result in data being removed from a database, or the data might be moved or flagged so that it could be recovered if the account is re-opened. A company might establish policies regarding salary maximums, minimums, and adjustments, in addition to basic sanity checks such as the salary not being a negative number. A retail database might not allow a purchase with the same serial number to be returned more than once, or might not allow credit card purchases above a certain value, while a database used to detect fraud might allow these kinds of things.

See Also relational.

C

.cfg file

A metadata file used with the InnoDB transportable tablespace feature. It is produced by the command FLUSH TABLES ... FOR EXPORT , puts one or more tables in a consistent state that can be copied to another server. The .cfg file is copied along with the corresponding .ibd file , and used to adjust the internal values of the .ibd file, such as the space ID , during the ALTER TABLE ... IMPORT TABLESPACE step.

See Also .ibd file, space ID, transportable tablespace.

C

A programming language that combines portability with performance and access to low-level hardware features, making it a popular choice for writing operating systems, drivers, and other kinds of system software. Many complex applications, languages, and reusable modules feature pieces written in C, tied together with high-level components written in other languages. Its core syntax is familiar to C++ , Java , and C# developers.

See Also C API, C++, C#, Java.

C API

The C API code is distributed with MySQL. It is included in the libmysqlclient library and enables C programs to access a database.

See Also API, C, libmysqlclient.

C#

A programming language combining strong typing and object-oriented features, running within the Microsoft .NET framework or its open-source counterpart Mono . Often used for creating applications with the ASP.net framework. Its syntax is familiar to C , C++ and Java developers.

See Also .NET, ASP.net, C, Connector/NET, C++, Java, Mono.

C++

A programming language with core syntax familiar to C developers. Provides access to low-level operations for performance, combined with higher-level data types, object-oriented features, and garbage collection. To write C++ applications for MySQL, you use the Connector/C++ component.

See Also C, Connector/C++.

cache

The general term for any memory area that stores copies of data for frequent or high-speed retrieval. In InnoDB , the primary kind of cache structure is the buffer pool .

See Also buffer, buffer pool.

cardinality

The number of different values in a table column . When queries refer to columns that have an associated index , the cardinality of each column influences which access method is most efficient. For example, for a column with a unique constraint , the number of different values is equal to the number of rows in the table. If a table has a million rows but only 10 different values for a particular column, each value occurs (on average) 100,000 times. A query such as SELECT c1 FROM t1 WHERE c1 = 50; thus might return 1 row or a huge number of rows, and the database server might process the query differently depending on the cardinality of c1 .

If the values in a column have a very uneven distribution, the cardinality might not be a good way to determine the best query plan. For example, SELECT c1 FROM t1 WHERE c1 = x; might return 1 row when x=50 and a million rows when x=30 . In such a case, you might need to use index hints to pass along advice about which lookup method is more efficient for a particular query.

Cardinality can also apply to the number of distinct values present in multiple columns, as in a composite index .

See Also column, composite index, index, index hint, persistent statistics, random dive, selectivity, unique constraint.

change buffer

A special data structure that records changes to pages in secondary indexes . These values could result from SQL INSERT , UPDATE , or DELETE statements ( DML ). The set of features involving the change buffer is known collectively as change buffering , consisting of insert buffering , delete buffering , and purge buffering .

Changes are only recorded in the change buffer when the relevant page from the secondary index is not in the buffer pool . When the relevant index page is brought into the buffer pool while associated changes are still in the change buffer, the changes for that page are applied in the buffer pool ( merged ) using the data from the change buffer. Periodically, the purge operation that runs during times when the system is mostly idle, or during a slow shutdown, writes the new index pages to disk. The purge operation can write the disk blocks for a series of index values more efficiently than if each value were written to disk immediately.

Physically, the change buffer is part of the system tablespace , so that the index changes remain buffered across database restarts. The changes are only applied ( merged ) when the pages are brought into the buffer pool due to some other read operation.

The kinds and amount of data stored in the change buffer are governed by the innodb_change_buffering and innodb_change_buffer_max_size configuration options. To see information about the current data in the change buffer, issue the SHOW ENGINE INNODB STATUS command.

Formerly known as the insert buffer .

See Also buffer pool, change buffering, delete buffering, DML, insert buffer, insert buffering, merge, page, purge, purge buffering, secondary index, system tablespace.

change buffering

The general term for the features involving the change buffer , consisting of insert buffering , delete buffering , and purge buffering . Index changes resulting from SQL statements, which could normally involve random I/O operations, are held back and performed periodically by a background thread . This sequence of operations can write the disk blocks for a series of index values more efficiently than if each value were written to disk immediately. Controlled by the innodb_change_buffering and innodb_change_buffer_max_size configuration options.

See Also change buffer, delete buffering, insert buffering, purge buffering.

checkpoint

As changes are made to data pages that are cached in the buffer pool , those changes are written to the data files sometime later, a process known as flushing . The checkpoint is a record of the latest changes (represented by an LSN value) that have been successfully written to the data files.

See Also buffer pool, data files, flush, fuzzy checkpointing, LSN.

checksum

In InnoDB , a validation mechanism to detect corruption when a page in a tablespace is read from disk into the InnoDB buffer pool . This feature is controlled by the innodb_checksums configuration option in MySQL 5.5. innodb_checksums is deprecated in MySQL 5.6.3, replaced by innodb_checksum_algorithm .

The innochecksum command helps diagnose corruption problems by testing the checksum values for a specified tablespace file while the MySQL server is shut down.

MySQL also uses checksums for replication purposes. For details, see the configuration options binlog_checksum , source_verify_checksum or master_verify_checksum , and replica_sql_verify_checksum or slave_sql_verify_checksum .

See Also buffer pool, page, tablespace.

child table

In a foreign key relationship, a child table is one whose rows refer (or point) to rows in another table with an identical value for a specific column. This is the table that contains the FOREIGN KEY ... REFERENCES clause and optionally ON UPDATE and ON DELETE clauses. The corresponding row in the parent table must exist before the row can be created in the child table. The values in the child table can prevent delete or update operations on the parent table, or can cause automatic deletion or updates in the child table, based on the ON CASCADE option used when creating the foreign key.

See Also foreign key, parent table.

clean page

A page in the InnoDB buffer pool where all changes made in memory have also been written ( flushed ) to the data files. The opposite of a dirty page .

See Also buffer pool, data files, dirty page, flush, page.

clean shutdown

A shutdown that completes without errors and applies all changes to InnoDB tables before finishing, as opposed to a crash or a fast shutdown . Synonym for slow shutdown .

See Also crash, fast shutdown, shutdown, slow shutdown.

client

A program that runs outside the database server, communicating with the database by sending requests through a Connector , or an API made available through client libraries . It can run on the same physical machine as the database server, or on a remote machine connected over a network. It can be a special-purpose database application, or a general-purpose program like the mysql command-line processor.

See Also API, client libraries, connector, mysql, server.

client libraries

Files containing collections of functions for working with databases. By compiling your program with these libraries, or installing them on the same system as your application, you can run a database application (known as a client ) on a machine that does not have the MySQL server installed; the application accesses the database over a network. With MySQL, you can use the libmysqlclient library from the MySQL server itself.

See Also client, libmysqlclient.

client-side prepared statement

A type of prepared statement where the caching and reuse are managed locally, emulating the functionality of server-side prepared statements . Historically, used by some Connector/J , Connector/ODBC , and Connector/PHP developers to work around issues with server-side stored procedures. With modern MySQL server versions, server-side prepared statements are recommended for performance, scalability, and memory efficiency.

See Also Connector/J, Connector/ODBC, Connector/PHP, prepared statement.

CLOB

An SQL data type ( TINYTEXT , TEXT , MEDIUMTEXT , or LONGTEXT ) for objects containing any kind of character data, of arbitrary size. Used for storing text-based documents, with associated character set and collation order. The techniques for handling CLOBs within a MySQL application vary with each Connector and API . MySQL Connector/ODBC defines TEXT values as LONGVARCHAR . For storing binary data, the equivalent is the BLOB type.

See Also API, BLOB, connector, Connector/ODBC.

clustered index

The InnoDB term for a primary key index. InnoDB table storage is organized based on the values of the primary key columns, to speed up queries and sorts involving the primary key columns. For best performance, choose the primary key columns carefully based on the most performance-critical queries. Because modifying the columns of the clustered index is an expensive operation, choose primary columns that are rarely or never updated.

In the Oracle Database product, this type of table is known as an index-organized table .

See Also index, primary key, secondary index.

cold backup

A backup taken while the database is shut down. For busy applications and websites, this might not be practical, and you might prefer a warm backup or a hot backup .

See Also backup, hot backup, warm backup.

column

A data item within a row , whose storage and semantics are defined by a data type. Each table and index is largely defined by the set of columns it contains.

Each column has a cardinality value. A column can be the primary key for its table, or part of the primary key. A column can be subject to a unique constraint , a NOT NULL constraint , or both. Values in different columns, even across different tables, can be linked by a foreign key relationship.

In discussions of MySQL internal operations, sometimes field is used as a synonym.

See Also cardinality, foreign key, index, NOT NULL constraint, primary key, row, table, unique constraint.

column index

An index on a single column.

See Also composite index, index.

column prefix

When an index is created with a length specification, such as CREATE INDEX idx ON t1 (c1(N)) , only the first N characters of the column value are stored in the index. Keeping the index prefix small makes the index compact, and the memory and disk I/O savings help performance. (Although making the index prefix too small can hinder query optimization by making rows with different values appear to the query optimizer to be duplicates.)

For columns containing binary values or long text strings, where sorting is not a major consideration and storing the entire value in the index would waste space, the index automatically uses the first N (typically 768) characters of the value to do lookups and sorts.

See Also index.

command interceptor

Synonym for statement interceptor . One aspect of the interceptor design pattern available for both Connector/NET and Connector/J . What Connector/NET calls a command, Connector/J refers to as a statement. Contrast with exception interceptor .

See Also Connector/J, Connector/NET, exception interceptor, interceptor, statement interceptor.

commit

A SQL statement that ends a transaction , making permanent any changes made by the transaction. It is the opposite of rollback , which undoes any changes made in the transaction.

InnoDB uses an optimistic mechanism for commits, so that changes can be written to the data files before the commit actually occurs. This technique makes the commit itself faster, with the tradeoff that more work is required in case of a rollback.

By default, MySQL uses the autocommit setting, which automatically issues a commit following each SQL statement.

See Also autocommit, optimistic, rollback, SQL, transaction.

compact row format

A row format for InnoDB tables. It was the default row format from MySQL 5.0.3 to MySQL 5.7.8. In MySQL 8.0, the default row format is defined by the innodb_default_row_format configuration option, which has a default setting of DYNAMIC . The COMPACT row format provides a more compact representation for nulls and variable-length columns than the REDUNDANT row format.

For additional information about InnoDB COMPACT row format, see Section 15.10, “InnoDB Row Formats”.

See Also dynamic row format, file format, redundant row format, row format.

composite index

An index that includes multiple columns.

See Also index.

compressed backup

The compression feature of the MySQL Enterprise Backup product makes a compressed copy of each tablespace, changing the extension from .ibd to .ibz . Compressing backup data allows you to keep more backups on hand, and reduces the time to transfer backups to a different server. The data is uncompressed during the restore operation. When a compressed backup operation processes a table that is already compressed, it skips the compression step for that table, because compressing again would result in little or no space savings.

A set of files produced by the MySQL Enterprise Backup product, where each tablespace is compressed. The compressed files are renamed with a .ibz file extension.

Applying compression at the start of the backup process helps to avoid storage overhead during the compression process, and to avoid network overhead when transferring the backup files to another server. The process of applying the binary log takes longer, and requires uncompressing the backup files.

See Also apply, binary log, compression, hot backup, MySQL Enterprise Backup, tablespace.

compressed row format

A row format that enables data and index compression for InnoDB tables. Large fields are stored away from the page that holds the rest of the row data, as in dynamic row format . Both index pages and the large fields are compressed, yielding memory and disk savings. Depending on the structure of the data, the decrease in memory and disk usage might or might not outweigh the performance overhead of uncompressing the data as it is used. See Section 15.9, “InnoDB Table and Page Compression” for usage details.

For additional information about InnoDB COMPRESSED row format, see DYNAMIC Row Format.

See Also compression, dynamic row format, row format.

compressed table

A table for which the data is stored in compressed form. For InnoDB , it is a table created with ROW_FORMAT=COMPRESSED . See Section 15.9, “InnoDB Table and Page Compression” for more information.

See Also compressed row format, compression.

compression

A feature with wide-ranging benefits from using less disk space, performing less I/O, and using less memory for caching.

InnoDB supports both table-level and page-level compression. InnoDB page compression is also referred to as transparent page compression . For more information about InnoDB compression, see Section 15.9, “InnoDB Table and Page Compression”.

Another type of compression is the compressed backup feature of the MySQL Enterprise Backup product.

See Also buffer pool, compressed backup, compressed row format, DML, transparent page compression.

compression failure

Not actually an error, rather an expensive operation that can occur when using compression in combination with DML operations. It occurs when: updates to a compressed page overflow the area on the page reserved for recording modifications; the page is compressed again, with all changes applied to the table data; the re-compressed data does not fit on the original page, requiring MySQL to split the data into two new pages and compress each one separately. To check the frequency of this condition, query the INFORMATION_SCHEMA.INNODB_CMP table and check how much the value of the COMPRESS_OPS column exceeds the value of the COMPRESS_OPS_OK column. Ideally, compression failures do not occur often; when they do, you can adjust the innodb_compression_level , innodb_compression_failure_threshold_pct , and innodb_compression_pad_pct_max configuration options.

See Also compression, DML, page.

concatenated index

See composite index.

concurrency

The ability of multiple operations (in database terminology, transactions ) to run simultaneously, without interfering with each other. Concurrency is also involved with performance, because ideally the protection for multiple simultaneous transactions works with a minimum of performance overhead, using efficient mechanisms for locking .

See Also ACID, locking, transaction.

configuration file

The file that holds the option values used by MySQL at startup. Traditionally, on Linux and Unix this file is named my.cnf , and on Windows it is named my.ini . You can set a number of options related to InnoDB under the [mysqld] section of the file.

See Section 4.2.2.2, “Using Option Files” for information about where MySQL searches for configuration files.

When you use the MySQL Enterprise Backup product, you typically use two configuration files: one that specifies where the data comes from and how it is structured (which could be the original configuration file for your server), and a stripped-down one containing only a small set of options that specify where the backup data goes and how it is structured. The configuration files used with the MySQL Enterprise Backup product must contain certain options that are typically left out of regular configuration files, so you might need to add options to your existing configuration file for use with MySQL Enterprise Backup .

See Also my.cnf, MySQL Enterprise Backup, option, option file.

connection

The communication channel between an application and a MySQL server. The performance and scalability of a database applications is influenced by on how quickly a database connection can be established, how many can be made simultaneously, and how long they persist. The parameters such as host , port , and so on are represented as a connection string in Connector/NET , and as a DSN in Connector/ODBC . High-traffic systems make use of an optimization known as the connection pool .

See Also connection pool, connection string, Connector/NET, Connector/ODBC, DSN, host, port.

connection pool

A cache area that allows database connections to be reused within the same application or across different applications, rather than setting up and tearing down a new connection for every database operation. This technique is common with J2EE application servers. Java applications using Connector/J can use the connection pool features of Tomcat and other application servers. The reuse is transparent to applications; the application still opens and closes the connection as usual.

See Also connection, Connector/J, J2EE, Tomcat.

connection string

A representation of the parameters for a database connection , encoded as a string literal so that it can be used in program code. The parts of the string represent connection parameters such as host and port . A connection string contains several key-value pairs, separated by semicolons. Each key-value pair is joined with an equal sign. Frequently used with Connector/NET applications; see Creating a Connector/NET Connection String for details.

See Also connection, Connector/NET, host, port.

connector

MySQL Connectors provide connectivity to the MySQL server for client programs. Several programming languages and frameworks each have their own associated Connector. Contrast with the lower-level access provided by an API .

See Also API, client, Connector/C++, Connector/J, Connector/NET, Connector/ODBC.

Connector/C++

Connector/C++ 8.0 can be used to access MySQL servers that implement a document store, or in a traditional way using SQL queries. It enables development of C++ applications using X DevAPI, or plain C applications using X DevAPI for C. It also enables development of C++ applications that use the legacy JDBC-based API from Connector/C++ 1.1. For more information, see MySQL Connector/C++ 8.0 Developer Guide.

See Also client, connector, JDBC.

Connector/J

A JDBC driver that provides connectivity for client applications developed in the Java programming language. MySQL Connector/J is a JDBC Type 4 driver: a pure-Java implementation of the MySQL protocol that does not rely on the MySQL client libraries . For full details, see MySQL Connector/J 8.0 Developer Guide.

See Also client, client libraries, connector, Java, JDBC.

Connector/NET

A MySQL connector for developers writing applications using languages, technologies, and frameworks such as C# , .NET , Mono , Visual Studio , ASP.net , and ADO.net .

See Also ADO.NET, ASP.net, connector, C#, Mono, Visual Studio.

Connector/ODBC

The family of MySQL ODBC drivers that provide access to a MySQL database using the industry standard Open Database Connectivity ( ODBC ) API. Formerly called MyODBC drivers. For full details, see MySQL Connector/ODBC Developer Guide.

See Also connector, ODBC.

Connector/PHP

A version of the mysql and mysqli APIs for PHP optimized for the Windows operating system.

See Also connector, PHP, PHP API.

consistent read

A read operation that uses snapshot information to present query results based on a point in time, regardless of changes performed by other transactions running at the same time. If queried data has been changed by another transaction, the original data is reconstructed based on the contents of the undo log . This technique avoids some of the locking issues that can reduce concurrency by forcing transactions to wait for other transactions to finish.

With REPEATABLE READ isolation level , the snapshot is based on the time when the first read operation is performed. With READ COMMITTED isolation level, the snapshot is reset to the time of each consistent read operation.

Consistent read is the default mode in which InnoDB processes SELECT statements in READ COMMITTED and REPEATABLE READ isolation levels. Because a consistent read does not set any locks on the tables it accesses, other sessions are free to modify those tables while a consistent read is being performed on the table.

For technical details about the applicable isolation levels, see Section 15.7.2.3, “Consistent Nonlocking Reads”.

See Also concurrency, isolation level, locking, READ COMMITTED, REPEATABLE READ, snapshot, transaction, undo log.

constraint

An automatic test that can block database changes to prevent data from becoming inconsistent. (In computer science terms, a kind of assertion related to an invariant condition.) Constraints are a crucial component of the ACID philosophy, to maintain data consistency. Constraints supported by MySQL include FOREIGN KEY constraints and unique constraints .

See Also ACID, foreign key, unique constraint.

counter

A value that is incremented by a particular kind of InnoDB operation. Useful for measuring how busy a server is, troubleshooting the sources of performance issues, and testing whether changes (for example, to configuration settings or indexes used by queries) have the desired low-level effects. Different kinds of counters are available through Performance Schema tables and INFORMATION_SCHEMA tables, particularly INFORMATION_SCHEMA.INNODB_METRICS .

See Also INFORMATION_SCHEMA, metrics counter, Performance Schema.

covering index

An index that includes all the columns retrieved by a query. Instead of using the index values as pointers to find the full table rows, the query returns values from the index structure, saving disk I/O. InnoDB can apply this optimization technique to more indexes than MyISAM can, because InnoDB secondary indexes also include the primary key columns. InnoDB cannot apply this technique for queries against tables modified by a transaction, until that transaction ends.

Any column index or composite index could act as a covering index, given the right query. Design your indexes and queries to take advantage of this optimization technique wherever possible.

See Also column index, composite index, index, primary key, secondary index.

CPU-bound

A type of workload where the primary bottleneck is CPU operations in memory. Typically involves read-intensive operations where the results can all be cached in the buffer pool .

See Also bottleneck, buffer pool, workload.

crash

MySQL uses the term crash to refer generally to any unexpected shutdown operation where the server cannot do its normal cleanup. For example, a crash could happen due to a hardware fault on the database server machine or storage device; a power failure; a potential data mismatch that causes the MySQL server to halt; a fast shutdown initiated by the DBA; or many other reasons. The robust, automatic crash recovery for InnoDB tables ensures that data is made consistent when the server is restarted, without any extra work for the DBA.

See Also crash recovery, fast shutdown, InnoDB, shutdown.

crash recovery

The cleanup activities that occur when MySQL is started again after a crash . For InnoDB tables, changes from incomplete transactions are replayed using data from the redo log . Changes that were committed before the crash, but not yet written into the data files , are reconstructed from the doublewrite buffer . When the database is shut down normally, this type of activity is performed during shutdown by the purge operation.

During normal operation, committed data can be stored in the change buffer for a period of time before being written to the data files. There is always a tradeoff between keeping the data files up-to-date, which introduces performance overhead during normal operation, and buffering the data, which can make shutdown and crash recovery take longer.

See Also change buffer, commit, crash, data files, doublewrite buffer, InnoDB, purge, redo log.

CRUD

Acronym for create, read, update, delete , a common sequence of operations in database applications. Often denotes a class of applications with relatively simple database usage (basic DDL , DML and query statements in SQL ) that can be implemented quickly in any language.

See Also DDL, DML, query, SQL.

cursor

An internal MySQL data structure that represents the result set of an SQL statement. Often used with prepared statements and dynamic SQL . It works like an iterator in other high-level languages, producing each value from the result set as requested.

Although SQL usually handles the processing of cursors for you, you might delve into the inner workings when dealing with performance-critical code.

See Also dynamic SQL, prepared statement, query.

D

data definition language

See DDL.

data dictionary

Metadata that keeps track of database objects such as tables , indexes , and table columns . For the MySQL data dictionary, introduced in MySQL 8.0, metadata is physically located in InnoDB file-per-table tablespace files in the mysql database directory. For the InnoDB data dictionary, metadata is physically located in the InnoDB system tablespace .

Because the MySQL Enterprise Backup product always backs up the InnoDB system tablespace, all backups include the contents of the InnoDB data dictionary.

See Also column, file-per-table, .frm file, index, MySQL Enterprise Backup, system tablespace, table.

data directory

The directory under which each MySQL instance keeps the data files for InnoDB and the directories representing individual databases. Controlled by the datadir configuration option.

See Also data files, instance.

data files

The files that physically contain table and index data.

The InnoDB system tablespace , which holds the InnoDB data dictionary and is capable of holding data for multiple InnoDB tables, is represented by one or more .ibdata data files.

File-per-table tablespaces, which hold data for a single InnoDB table, are represented by a .ibd data file.

General tablespaces (introduced in MySQL 5.7.6), which can hold data for multiple InnoDB tables, are also represented by a .ibd data file.

See Also data dictionary, file-per-table, general tablespace, .ibd file, ibdata file, index, system tablespace, table, tablespace.

data manipulation language

See DML.

data warehouse

A database system or application that primarily runs large queries . The read-only or read-mostly data might be organized in denormalized form for query efficiency. Can benefit from the optimizations for read-only transactions in MySQL 5.6 and higher. Contrast with OLTP .

See Also denormalized, OLTP, query, read-only transaction.

database

Within the MySQL data directory , each database is represented by a separate directory. The InnoDB system tablespace , which can hold table data from multiple databases within a MySQL instance , is kept in data files that reside outside of individual database directories. When file-per-table mode is enabled, the .ibd files representing individual InnoDB tables are stored inside the database directories unless created elsewhere using the DATA DIRECTORY clause. General tablespaces, introduced in MySQL 5.7.6, also hold table data in .ibd files . Unlike file-per-table .ibd files , general tablespace .ibd files can hold table data from multiple databases within a MySQL instance , and can be assigned to directories relative to or independent of the MySQL data directory.

For long-time MySQL users, a database is a familiar notion. Users coming from an Oracle Database background may find that the MySQL meaning of a database is closer to what Oracle Database calls a schema .

See Also data files, file-per-table, .ibd file, instance, schema, system tablespace.

DCL

Data control language, a set of SQL statements for managing privileges. In MySQL, consists of the GRANT and REVOKE statements. Contrast with DDL and DML .

See Also DDL, DML, SQL.

DDEX provider

A feature that lets you use the data design tools within Visual Studio to manipulate the schema and objects within a MySQL database. For MySQL applications using Connector/NET , the MySQL Visual Studio Plugin acts as a DDEX provider with MySQL 5.0 and later.

See Also Visual Studio.

DDL

Data definition language, a set of SQL statements for manipulating the database itself rather than individual table rows. Includes all forms of the CREATE , ALTER , and DROP statements. Also includes the TRUNCATE statement, because it works differently than a DELETE FROM table_name statement, even though the ultimate effect is similar.

DDL statements automatically commit the current transaction ; they cannot be rolled back .

The InnoDB online DDL feature enhances performance for CREATE INDEX , DROP INDEX , and many types of ALTER TABLE operations. See Section 15.12, “InnoDB and Online DDL” for more information. Also, the InnoDB file-per-table setting can affect the behavior of DROP TABLE and TRUNCATE TABLE operations.

Contrast with DML and DCL .

See Also commit, DCL, DML, file-per-table, rollback, SQL, transaction.

deadlock

A situation where different transactions are unable to proceed, because each holds a lock that the other needs. Because both transactions are waiting for a resource to become available, neither one ever releases the locks it holds.

A deadlock can occur when the transactions lock rows in multiple tables (through statements such as UPDATE or SELECT ... FOR UPDATE ), but in the opposite order. A deadlock can also occur when such statements lock ranges of index records and gaps , with each transaction acquiring some locks but not others due to a timing issue.

For background information on how deadlocks are automatically detected and handled, see Section 15.7.5.2, “Deadlock Detection”. For tips on avoiding and recovering from deadlock conditions, see Section 15.7.5.3, “How to Minimize and Handle Deadlocks”.

See Also gap, lock, transaction.

deadlock detection

A mechanism that automatically detects when a deadlock occurs, and automatically rolls back one of the transactions involved (the victim ). Deadlock detection can be disabled using the innodb_deadlock_detect configuration option.

See Also deadlock, rollback, transaction, victim.

delete

When InnoDB processes a DELETE statement, the rows are immediately marked for deletion and no longer are returned by queries. The storage is reclaimed sometime later, during the periodic garbage collection known as the purge operation. For removing large quantities of data, related operations with their own performance characteristics are TRUNCATE and DROP .

See Also drop, purge, truncate.

delete buffering

The technique of storing changes to secondary index pages, resulting from DELETE operations, in the change buffer rather than writing the changes immediately, so that the physical writes can be performed to minimize random I/O. (Because delete operations are a two-step process, this operation buffers the write that normally marks an index record for deletion.) It is one of the types of change buffering ; the others are insert buffering and purge buffering .

See Also change buffer, change buffering, insert buffer, insert buffering, purge buffering.

denormalized

A data storage strategy that duplicates data across different tables, rather than linking the tables with foreign keys and join queries. Typically used in data warehouse applications, where the data is not updated after loading. In such applications, query performance is more important than making it simple to maintain consistent data during updates. Contrast with normalized .

See Also data warehouse, foreign key, join, normalized.

descending index

A type of index where index storage is optimized to process ORDER BY column DESC clauses.

See Also index.

dictionary object cache

The dictionary object cache stores previously accessed data dictionary objects in memory to enable object reuse and minimize disk I/O. An LRU -based eviction strategy is used to evict least recently used objects from memory. The cache is comprised of several partitions that store different object types.

For more information, see Section 14.4, “Dictionary Object Cache”.

See Also data dictionary, LRU.

dirty page

A page in the InnoDB buffer pool that has been updated in memory, where the changes are not yet written ( flushed ) to the data files . The opposite of a clean page .

See Also buffer pool, clean page, data files, flush, page.

dirty read

An operation that retrieves unreliable data, data that was updated by another transaction but not yet committed . It is only possible with the isolation level known as read uncommitted .

This kind of operation does not adhere to the ACID principle of database design. It is considered very risky, because the data could be rolled back , or updated further before being committed; then, the transaction doing the dirty read would be using data that was never confirmed as accurate.

Its opposite is consistent read , where InnoDB ensures that a transaction does not read information updated by another transaction, even if the other transaction commits in the meantime.

See Also ACID, commit, consistent read, isolation level, READ UNCOMMITTED, rollback.

disk-based

A kind of database that primarily organizes data on disk storage (hard drives or equivalent). Data is brought back and forth between disk and memory to be operated upon. It is the opposite of an in-memory database . Although InnoDB is disk-based, it also contains features such as he buffer pool , multiple buffer pool instances, and the adaptive hash index that allow certain kinds of workloads to work primarily from memory.

See Also adaptive hash index, buffer pool, in-memory database.

disk-bound

A type of workload where the primary bottleneck is disk I/O. (Also known as I/O-bound .) Typically involves frequent writes to disk, or random reads of more data than can fit into the buffer pool .

See Also bottleneck, buffer pool, workload.

DML

Data manipulation language, a set of SQL statements for performing INSERT , UPDATE , and DELETE operations. The SELECT statement is sometimes considered as a DML statement, because the SELECT ... FOR UPDATE form is subject to the same considerations for locking as INSERT , UPDATE , and DELETE .

DML statements for an InnoDB table operate in the context of a transaction , so their effects can be committed or rolled back as a single unit.

Contrast with DDL and DCL .

See Also commit, DCL, DDL, locking, rollback, SQL, transaction.

document id

In the InnoDB full-text search feature, a special column in the table containing the FULLTEXT index , to uniquely identify the document associated with each ilist value. Its name is FTS_DOC_ID (uppercase required). The column itself must be of BIGINT UNSIGNED NOT NULL type, with a unique index named FTS_DOC_ID_INDEX . Preferably, you define this column when creating the table. If InnoDB must add the column to the table while creating a FULLTEXT index, the indexing operation is considerably more expensive.

See Also full-text search, FULLTEXT index, ilist.

doublewrite buffer

InnoDB uses a file flush technique called doublewrite. Before writing pages to the data files , InnoDB first writes them to a storage area called the doublewrite buffer. Only after the write and the flush to the doublewrite buffer have completed, does InnoDB write the pages to their proper positions in the data file. If there is an operating system, storage subsystem or mysqld process crash in the middle of a page write, InnoDB can find a good copy of the page from the doublewrite buffer during crash recovery .

Although data is always written twice, the doublewrite buffer does not require twice as much I/O overhead or twice as many I/O operations. Data is written to the buffer itself as a large sequential chunk, with a single fsync() call to the operating system.

See Also crash recovery, data files, page, purge.

drop

A kind of DDL operation that removes a schema object, through a statement such as DROP TABLE or DROP INDEX . It maps internally to an ALTER TABLE statement. From an InnoDB perspective, the performance considerations of such operations involve the time that the data dictionary is locked to ensure that interrelated objects are all updated, and the time to update memory structures such as the buffer pool . For a table , the drop operation has somewhat different characteristics than a truncate operation ( TRUNCATE TABLE statement).

See Also buffer pool, data dictionary, DDL, table, truncate.

DSN

Acronym for Database Source Name . It is the encoding for connection information within Connector/ODBC . See Configuring a Connector/ODBC DSN on Windows for full details. It is the equivalent of the connection string used by Connector/NET .

See Also connection, connection string, Connector/NET, Connector/ODBC.

dynamic cursor

A type of cursor supported by ODBC that can pick up new and changed results when the rows are read again. Whether and how quickly the changes are visible to the cursor depends on the type of table involved (transactional or non-transactional) and the isolation level for transactional tables. Support for dynamic cursors must be explicitly enabled.

See Also cursor, ODBC.

dynamic row format

An InnoDB row format. Because long variable-length column values are stored outside of the page that holds the row data, it is very efficient for rows that include large objects. Since the large fields are typically not accessed to evaluate query conditions, they are not brought into the buffer pool as often, resulting in fewer I/O operations and better utilization of cache memory.

As of MySQL 5.7.9, the default row format is defined by innodb_default_row_format , which has a default value of DYNAMIC .

For additional information about InnoDB DYNAMIC row format, see DYNAMIC Row Format.

See Also buffer pool, file format, row format.

dynamic SQL

A feature that lets you create and execute prepared statements using more robust, secure, and efficient methods to substitute parameter values than the naive technique of concatenating the parts of the statement into a string variable.

See Also prepared statement.

dynamic statement

A prepared statement created and executed through dynamic SQL .

See Also dynamic SQL, prepared statement.

E

early adopter

A stage similar to beta , when a software product is typically evaluated for performance, functionality, and compatibility in a non-mission-critical setting.

See Also beta.

Eiffel

A programming language including many object-oriented features. Some of its concepts are familiar to Java and C# developers. For the open-source Eiffel API for MySQL, see Section 29.13, “MySQL Eiffel Wrapper”.

See Also API, C#, Java.

embedded

The embedded MySQL server library ( libmysqld ) makes it possible to run a full-featured MySQL server inside a client application. The main benefits are increased speed and more simple management for embedded applications.

See Also client, libmysqld.

error log

A type of log showing information about MySQL startup and critical runtime errors and crash information. For details, see Section 5.4.2, “The Error Log”.

See Also crash, log.

eviction

The process of removing an item from a cache or other temporary storage area, such as the InnoDB buffer pool . Often, but not always, uses the LRU algorithm to determine which item to remove. When a dirty page is evicted, its contents are flushed to disk, and any dirty neighbor pages might be flushed also.

See Also buffer pool, dirty page, flush, LRU, neighbor page.

exception interceptor

A type of interceptor for tracing, debugging, or augmenting SQL errors encountered by a database application. For example, the interceptor code could issue a SHOW WARNINGS statement to retrieve additional information, and add descriptive text or even change the type of the exception returned to the application. Because the interceptor code is only called when SQL statements return errors, it does not impose any performance penalty on the application during normal (error-free) operation.

In Java applications using Connector/J , setting up this type of interceptor involves implementing the com.mysql.jdbc.ExceptionInterceptor interface, and adding a exceptionInterceptors property to the connection string .

In Visual Studio applications using Connector/NET , setting up this type of interceptor involves defining a class that inherits from the BaseExceptionInterceptor class and specifying that class name as part of the connection string.

See Also Connector/J, Connector/NET, interceptor, Java, Visual Studio.

exclusive lock

A kind of lock that prevents any other transaction from locking the same row. Depending on the transaction isolation level , this kind of lock might block other transactions from writing to the same row, or might also block other transactions from reading the same row. The default InnoDB isolation level, REPEATABLE READ , enables higher concurrency by allowing transactions to read rows that have exclusive locks, a technique known as consistent read .

See Also concurrency, consistent read, isolation level, lock, REPEATABLE READ, shared lock, transaction.

extent

A group of pages within a tablespace . For the default page size of 16KB, an extent contains 64 pages. In MySQL 5.6, the page size for an InnoDB instance can be 4KB, 8KB, or 16KB, controlled by the innodb_page_size configuration option. For 4KB, 8KB, and 16KB pages sizes, the extent size is always 1MB (or 1048576 bytes).

Support for 32KB and 64KB InnoDB page sizes was added in MySQL 5.7.6. For a 32KB page size, the extent size is 2MB. For a 64KB page size, the extent size is 4MB.

InnoDB features such as segments , read-ahead requests and the doublewrite buffer use I/O operations that read, write, allocate, or free data one extent at a time.

See Also doublewrite buffer, page, page size, read-ahead, segment, tablespace.

F

.frm file

A file containing the metadata, such as the table definition, of a MySQL table. .frm files were removed in MySQL 8.0 but are still used in earlier MySQL releases. In MySQL 8.0, data previously stored in .frm files is stored in data dictionary tables.

See Also data dictionary, MySQL Enterprise Backup, system tablespace.

failover

The ability to automatically switch to a standby server in the event of a failure. In the MySQL context, failover involves a standby database server. Often supported within J2EE environments by the application server or framework.

See Also Connector/J, J2EE.

Fast Index Creation

A capability first introduced in the InnoDB Plugin, now part of MySQL in 5.5 and higher, that speeds up creation of InnoDB secondary indexes by avoiding the need to completely rewrite the associated table. The speedup applies to dropping secondary indexes also.

Because index maintenance can add performance overhead to many data transfer operations, consider doing operations such as ALTER TABLE ... ENGINE=INNODB or INSERT INTO ... SELECT * FROM ... without any secondary indexes in place, and creating the indexes afterward.

In MySQL 5.6, this feature becomes more general. You can read and write to tables while an index is being created, and many more kinds of ALTER TABLE operations can be performed without copying the table, without blocking DML operations, or both. Thus in MySQL 5.6 and higher, this set of features is referred to as online DDL rather than Fast Index Creation.

For related information, see Section 15.12, “InnoDB and Online DDL”.

See Also DML, index, online DDL, secondary index.

fast shutdown

The default shutdown procedure for InnoDB , based on the configuration setting innodb_fast_shutdown=1 . To save time, certain flush operations are skipped. This type of shutdown is safe during normal usage, because the flush operations are performed during the next startup, using the same mechanism as in crash recovery . In cases where the database is being shut down for an upgrade or downgrade, do a slow shutdown instead to ensure that all relevant changes are applied to the data files during the shutdown.

See Also crash recovery, data files, flush, shutdown, slow shutdown.

file format

The file format for InnoDB tables.

See Also file-per-table, .ibd file, ibdata file, row format.

file-per-table

A general name for the setting controlled by the innodb_file_per_table option, which is an important configuration option that affects aspects of InnoDB file storage, availability of features, and I/O characteristics. As of MySQL 5.6.7, innodb_file_per_table is enabled by default.

With the innodb_file_per_table option enabled, you can create a table in its own .ibd file rather than in the shared ibdata files of the system tablespace . When table data is stored in an individual .ibd file , you have more flexibility to choose row formats required for features such as data compression . The TRUNCATE TABLE operation is also faster, and reclaimed space can be used by the operating system rather than remaining reserved for InnoDB .

The MySQL Enterprise Backup product is more flexible for tables that are in their own files. For example, tables can be excluded from a backup, but only if they are in separate files. Thus, this setting is suitable for tables that are backed up less frequently or on a different schedule.

See Also compressed row format, compression, file format, .ibd file, ibdata file, innodb_file_per_table, MySQL Enterprise Backup, row format, system tablespace.

fill factor

In an InnoDB index , the proportion of a page that is taken up by index data before the page is split. The unused space when index data is first divided between pages allows for rows to be updated with longer string values without requiring expensive index maintenance operations. If the fill factor is too low, the index consumes more space than needed, causing extra I/O overhead when reading the index. If the fill factor is too high, any update that increases the length of column values can cause extra I/O overhead for index maintenance. See Section 15.6.2.2, “The Physical Structure of an InnoDB Index” for more information.

See Also index, page.

fixed row format

This row format is used by the MyISAM storage engine, not by InnoDB . If you create an InnoDB table with the option ROW_FORMAT=FIXED in MySQL 5.7.6 or earlier, InnoDB uses the compact row format instead, although the FIXED value might still show up in output such as SHOW TABLE STATUS reports. As of MySQL 5.7.7, InnoDB returns an error if ROW_FORMAT=FIXED is specified.

See Also compact row format, row format.

flush

To write changes to the database files, that had been buffered in a memory area or a temporary disk storage area. The InnoDB storage structures that are periodically flushed include the redo log , the undo log , and the buffer pool .

Flushing can happen because a memory area becomes full and the system needs to free some space, because a commit operation means the changes from a transaction can be finalized, or because a slow shutdown operation means that all outstanding work should be finalized. When it is not critical to flush all the buffered data at once, InnoDB can use a technique called fuzzy checkpointing to flush small batches of pages to spread out the I/O overhead.

See Also buffer pool, commit, fuzzy checkpointing, redo log, slow shutdown, undo log.

flush list

An internal InnoDB data structure that tracks dirty pages in the buffer pool : that is, pages that have been changed and need to be written back out to disk. This data structure is updated frequently by InnoDB internal mini-transactions , and so is protected by its own mutex to allow concurrent access to the buffer pool.

See Also buffer pool, dirty page, LRU, mini-transaction, mutex, page, page cleaner.

foreign key

A type of pointer relationship, between rows in separate InnoDB tables. The foreign key relationship is defined on one column in both the parent table and the child table .

In addition to enabling fast lookup of related information, foreign keys help to enforce referential integrity , by preventing any of these pointers from becoming invalid as data is inserted, updated, and deleted. This enforcement mechanism is a type of constraint . A row that points to another table cannot be inserted if the associated foreign key value does not exist in the other table. If a row is deleted or its foreign key value changed, and rows in another table point to that foreign key value, the foreign key can be set up to prevent the deletion, cause the corresponding column values in the other table to become null , or automatically delete the corresponding rows in the other table.

One of the stages in designing a normalized database is to identify data that is duplicated, separate that data into a new table, and set up a foreign key relationship so that the multiple tables can be queried like a single table, using a join operation.

See Also child table, FOREIGN KEY constraint, join, normalized, NULL, parent table, referential integrity, relational.

FOREIGN KEY constraint

The type of constraint that maintains database consistency through a foreign key relationship. Like other kinds of constraints, it can prevent data from being inserted or updated if data would become inconsistent; in this case, the inconsistency being prevented is between data in multiple tables. Alternatively, when a DML operation is performed, FOREIGN KEY constraints can cause data in child rows to be deleted, changed to different values, or set to null , based on the ON CASCADE option specified when creating the foreign key.

See Also child table, constraint, DML, foreign key, NULL.

FTS

In most contexts, an acronym for full-text search . Sometimes in performance discussions, an acronym for full table scan .

See Also full table scan, full-text search.

full backup

A backup that includes all the tables in each MySQL database , and all the databases in a MySQL instance . Contrast with partial backup .

See Also backup, database, instance, partial backup, table.

full table scan

An operation that requires reading the entire contents of a table, rather than just selected portions using an index . Typically performed either with small lookup tables, or in data warehousing situations with large tables where all available data is aggregated and analyzed. How frequently these operations occur, and the sizes of the tables relative to available memory, have implications for the algorithms used in query optimization and managing the buffer pool .

The purpose of indexes is to allow lookups for specific values or ranges of values within a large table, thus avoiding full table scans when practical.

See Also buffer pool, index.

full-text search

The MySQL feature for finding words, phrases, Boolean combinations of words, and so on within table data, in a faster, more convenient, and more flexible way than using the SQL LIKE operator or writing your own application-level search algorithm. It uses the SQL function MATCH() and FULLTEXT indexes .

See Also FULLTEXT index.

FULLTEXT index

The special kind of index that holds the search index in the MySQL full-text search mechanism. Represents the words from values of a column, omitting any that are specified as stopwords . Originally, only available for MyISAM tables. Starting in MySQL 5.6.4, it is also available for InnoDB tables.

See Also full-text search, index, InnoDB, search index, stopword.

fuzzy checkpointing

A technique that flushes small batches of dirty pages from the buffer pool , rather than flushing all dirty pages at once which would disrupt database processing.

See Also buffer pool, dirty page, flush.

G

GA

Generally available , the stage when a software product leaves beta and is available for sale, official support, and production use.

See Also beta.

GAC

Acronym for Global Assembly Cache . A central area for storing libraries ( assemblies ) on a .NET system. Physically consists of nested folders, treated as a single virtual folder by the .NET CLR.

See Also .NET, assembly.

gap

A place in an InnoDB index data structure where new values could be inserted. When you lock a set of rows with a statement such as SELECT ... FOR UPDATE , InnoDB can create locks that apply to the gaps as well as the actual values in the index. For example, if you select all values greater than 10 for update, a gap lock prevents another transaction from inserting a new value that is greater than 10. The supremum record and infimum record represent the gaps containing all values greater than or less than all the current index values.

See Also concurrency, gap lock, index, infimum record, isolation level, supremum record.

gap lock

A lock on a gap between index records, or a lock on the gap before the first or after the last index record. For example, SELECT c1 FROM t WHERE c1 BETWEEN 10 and 20 FOR UPDATE; prevents other transactions from inserting a value of 15 into the column t.c1 , whether or not there was already any such value in the column, because the gaps between all existing values in the range are locked. Contrast with record lock and next-key lock .

Gap locks are part of the tradeoff between performance and concurrency , and are used in some transaction isolation levels and not others.

See Also gap, infimum record, lock, next-key lock, record lock, supremum record.

general log

See general query log.

general query log

A type of log used for diagnosis and troubleshooting of SQL statements processed by the MySQL server. Can be stored in a file or in a database table. You must enable this feature through the general_log configuration option to use it. You can disable it for a specific connection through the sql_log_off configuration option.

Records a broader range of queries than the slow query log . Unlike the binary log , which is used for replication, the general query log contains SELECT statements and does not maintain strict ordering. For more information, see Section 5.4.3, “The General Query Log”.

See Also binary log, log, slow query log.

general tablespace

A shared InnoDB tablespace created using CREATE TABLESPACE syntax. General tablespaces can be created outside of the MySQL data directory, are capable of holding multiple tables , and support tables of all row formats. General tablespaces were introduced in MySQL 5.7.6.

Tables are added to a general tablespace using CREATE TABLE tbl_name ... TABLESPACE [=] tablespace_name or ALTER TABLE tbl_name TABLESPACE [=] tablespace_name syntax.

Contrast with system tablespace and file-per-table tablespace.

For more information, see Section 15.6.3.3, “General Tablespaces”.

See Also file-per-table, system tablespace, table, tablespace.

generated column

A column whose values are computed from an expression included in the column definition. A generated column can be virtual or stored .

See Also base column, stored generated column, virtual generated column.

generated stored column

See stored generated column.

generated virtual column

See virtual generated column.

Glassfish

See Also J2EE.

global temporary tablespace

A temporary tablespace that stores rollback segments for changes made to user-created temporary tables.

See Also temporary tablespace.

global transaction

A type of transaction involved in XA operations. It consists of several actions that are transactional in themselves, but that all must either complete successfully as a group, or all be rolled back as a group. In essence, this extends ACID properties up a level so that multiple ACID transactions can be executed in concert as components of a global operation that also has ACID properties.

See Also ACID, transaction, XA.

group commit

An InnoDB optimization that performs some low-level I/O operations (log write) once for a set of commit operations, rather than flushing and syncing separately for each commit.

See Also binary log, commit.

GUID

Acronym for globally unique identifier , an ID value that can be used to associate data across different databases, languages, operating systems, and so on. (As an alternative to using sequential integers, where the same values could appear in different tables, databases, and so on referring to different data.) Older MySQL versions represented it as BINARY(16) . Currently, it is represented as CHAR(36) . MySQL has a UUID() function that returns GUID values in character format, and a UUID_SHORT() function that returns GUID values in integer format. Because successive GUID values are not necessarily in ascending sort order, it is not an efficient value to use as a primary key for large InnoDB tables.

H

hash index

A type of index intended for queries that use equality operators, rather than range operators such as greater-than or BETWEEN . It is available for MEMORY tables. Although hash indexes are the default for MEMORY tables for historic reasons, that storage engine also supports B-tree indexes, which are often a better choice for general-purpose queries.

MySQL includes a variant of this index type, the adaptive hash index , that is constructed automatically for InnoDB tables if needed based on runtime conditions.

See Also adaptive hash index, B-tree, index, InnoDB.

HDD

Acronym for hard disk drive . Refers to storage media using spinning platters, usually when comparing and contrasting with SSD . Its performance characteristics can influence the throughput of a disk-based workload.

See Also disk-based, SSD.

heartbeat

A periodic message that is sent to indicate that a system is functioning properly. In a replication context, if the source stops sending such messages, one of the replicas can take its place. Similar techniques can be used between the servers in a cluster environment, to confirm that all of them are operating properly.

See Also replication, source.

high-water mark

A value representing an upper limit, either a hard limit that should not be exceeded at runtime, or a record of the maximum value that was actually reached. Contrast with low-water mark .

See Also low-water mark.

history list

A list of transactions with delete-marked records scheduled to be processed by the InnoDB purge operation. Recorded in the undo log . The length of the history list is reported by the command SHOW ENGINE INNODB STATUS . If the history list grows longer than the value of the innodb_max_purge_lag configuration option, each DML operation is delayed slightly to allow the purge operation to finish flushing the deleted records.

Also known as purge lag .

See Also DML, flush, purge, purge lag, rollback segment, transaction, undo log.

hole punching

Releasing empty blocks from a page. The InnoDB transparent page compression feature relies on hole punching support. For more information, see Section 15.9.2, “InnoDB Page Compression”.

See Also sparse file, transparent page compression.

host

The network name of a database server, used to establish a connection . Often specified in conjunction with a port . In some contexts, the IP address 127.0.0.1 works better than the special name localhost for accessing a database on the same server as the application.

See Also connection, localhost, port.

hot

A condition where a row, table, or internal data structure is accessed so frequently, requiring some form of locking or mutual exclusion, that it results in a performance or scalability issue.

Although hot typically indicates an undesirable condition, a hot backup is the preferred type of backup.

See Also hot backup.

hot backup

A backup taken while the database is running and applications are reading and writing to it. The backup involves more than simply copying data files: it must include any data that was inserted or updated while the backup was in process; it must exclude any data that was deleted while the backup was in process; and it must ignore any changes that were not committed.

The Oracle product that performs hot backups, of InnoDB tables especially but also tables from MyISAM and other storage engines, is known as MySQL Enterprise Backup .

The hot backup process consists of two stages. The initial copying of the data files produces a raw backup . The apply step incorporates any changes to the database that happened while the backup was running. Applying the changes produces a prepared backup; these files are ready to be restored whenever necessary.

See Also apply, MySQL Enterprise Backup, prepared backup, raw backup.

I

.ibd file

The data file for file-per-table tablespaces and general tablespaces. File-per-table tablespace .ibd files contain a single table and associated index data. General tablespace .ibd files may contain table and index data for multiple tables.

The .ibd file extension does not apply to the system tablespace , which consists of one or more ibdata files .

If a file-per-table tablespace or general tablespace is created with the DATA DIRECTORY = clause, the .ibd file is located at the specified path, outside the normal data directory.

When a .ibd file is included in a compressed backup by the MySQL Enterprise Backup product, the compressed equivalent is a .ibz file.

See Also database, file-per-table, general tablespace, ibdata file, .ibz file, innodb_file_per_table, MySQL Enterprise Backup, system tablespace.

.ibz file

When the MySQL Enterprise Backup product performs a compressed backup , it transforms each tablespace file that is created using the file-per-table setting from a .ibd extension to a .ibz extension.

The compression applied during backup is distinct from the compressed row format that keeps table data compressed during normal operation. A compressed backup operation skips the compression step for a tablespace that is already in compressed row format, as compressing a second time would slow down the backup but produce little or no space savings.

See Also compressed backup, compressed row format, file-per-table, .ibd file, MySQL Enterprise Backup, tablespace.

I/O-bound

See disk-bound.

ib-file set

The set of files managed by InnoDB within a MySQL database: the system tablespace , file-per-table tablespace files, and redo log files. Depending on MySQL version and InnoDB configuration, may also include general tablespace , temporary tablespace , and undo tablespace files. This term is sometimes used in detailed discussions of InnoDB file structures and formats to refer to the set of files managed by InnoDB within a MySQL database.

See Also database, file-per-table, general tablespace, redo log, system tablespace, temporary tablespace, undo tablespace.

ibbackup_logfile

A supplemental backup file created by the MySQL Enterprise Backup product during a hot backup operation. It contains information about any data changes that occurred while the backup was running. The initial backup files, including ibbackup_logfile , are known as a raw backup , because the changes that occurred during the backup operation are not yet incorporated. After you perform the apply step to the raw backup files, the resulting files do include those final data changes, and are known as a prepared backup . At this stage, the ibbackup_logfile file is no longer necessary.

See Also apply, hot backup, MySQL Enterprise Backup, prepared backup, raw backup.

ibdata file

A set of files with names such as ibdata1 , ibdata2 , and so on, that make up the InnoDB system tablespace . For information about the structures and data that reside in the system tablespace ibdata files, see Section 15.6.3.1, “The System Tablespace”.

Growth of the ibdata files is influenced by the innodb_autoextend_increment configuration option.

See Also change buffer, data dictionary, doublewrite buffer, file-per-table, .ibd file, innodb_file_per_table, system tablespace, undo log.

ibtmp file

The InnoDB temporary tablespace data file for non-compressed InnoDB temporary tables and related objects. The configuration file option, innodb_temp_data_file_path , allows users to define a relative path for the temporary tablespace data file. If innodb_temp_data_file_path is not specified, the default behavior is to create a single auto-extending 12MB data file named ibtmp1 in the data directory, alongside ibdata1 .

See Also data files, temporary table, temporary tablespace.

ib_logfile

A set of files, typically named ib_logfile0 and ib_logfile1 , that form the redo log . Also sometimes referred to as the log group . These files record statements that attempt to change data in InnoDB tables. These statements are replayed automatically to correct data written by incomplete transactions, on startup following a crash.

This data cannot be used for manual recovery; for that type of operation, use the binary log .

See Also binary log, log group, redo log.

ilist

Within an InnoDB FULLTEXT index , the data structure consisting of a document ID and positional information for a token (that is, a particular word).

See Also FULLTEXT index.

implicit row lock

A row lock that InnoDB acquires to ensure consistency, without you specifically requesting it.

See Also row lock.

in-memory database

A type of database system that maintains data in memory, to avoid overhead due to disk I/O and translation between disk blocks and memory areas. Some in-memory databases sacrifice durability (the D in the ACID design philosophy) and are vulnerable to hardware, power, and other types of failures, making them more suitable for read-only operations. Other in-memory databases do use durability mechanisms such as logging changes to disk or using non-volatile memory.

MySQL features that address the same kinds of memory-intensive processing include the InnoDB buffer pool , adaptive hash index , and read-only transaction optimization, the MEMORY storage engine, the MyISAM key cache, and the MySQL query cache.

See Also ACID, adaptive hash index, buffer pool, disk-based, read-only transaction.

incremental backup

A type of hot backup , performed by the MySQL Enterprise Backup product, that only saves data changed since some point in time. Having a full backup and a succession of incremental backups lets you reconstruct backup data over a long period, without the storage overhead of keeping several full backups on hand. You can restore the full backup and then apply each of the incremental backups in succession, or you can keep the full backup up-to-date by applying each incremental backup to it, then perform a single restore operation.

The granularity of changed data is at the page level. A page might actually cover more than one row. Each changed page is included in the backup.

See Also hot backup, MySQL Enterprise Backup, page.

index

A data structure that provides a fast lookup capability for rows of a table , typically by forming a tree structure ( B-tree) representing all the values of a particular column or set of columns.

InnoDB tables always have a clustered index representing the primary key . They can also have one or more secondary indexes defined on one or more columns. Depending on their structure, secondary indexes can be classified as partial , column , or composite indexes.

Indexes are a crucial aspect of query performance. Database architects design tables, queries, and indexes to allow fast lookups for data needed by applications. The ideal database design uses a covering index where practical; the query results are computed entirely from the index, without reading the actual table data. Each foreign key constraint also requires an index, to efficiently check whether values exist in both the parent and child tables.

Although a B-tree index is the most common, a different kind of data structure is used for hash indexes , as in the MEMORY storage engine and the InnoDB adaptive hash index . R-tree indexes are used for spatial indexing of multi-dimensional information.

See Also adaptive hash index, B-tree, child table, clustered index, column index, composite index, covering index, foreign key, hash index, parent table, partial index, primary key, query, R-tree, row, secondary index, table.

index cache

A memory area that holds the token data for InnoDB full-text search . It buffers the data to minimize disk I/O when data is inserted or updated in columns that are part of a FULLTEXT index . The token data is written to disk when the index cache becomes full. Each InnoDB FULLTEXT index has its own separate index cache, whose size is controlled by the configuration option innodb_ft_cache_size .

See Also full-text search, FULLTEXT index.

index condition pushdown

Index condition pushdown (ICP) is an optimization that pushes part of a WHERE condition down to the storage engine if parts of the condition can be evaluated using fields from the index . ICP can reduce the number of times the storage engine must access the base table and the number of times the MySQL server must access the storage engine. For more information, see Section 8.2.1.6, “Index Condition Pushdown Optimization”.

See Also index, storage engine.

index hint

Extended SQL syntax for overriding the indexes recommended by the optimizer. For example, the FORCE INDEX , USE INDEX , and IGNORE INDEX clauses. Typically used when indexed columns have unevenly distributed values, resulting in inaccurate cardinality estimates.

See Also cardinality, index.

index prefix

In an index that applies to multiple columns (known as a composite index ), the initial or leading columns of the index. A query that references the first 1, 2, 3, and so on columns of a composite index can use the index, even if the query does not reference all the columns in the index.

See Also composite index, index.

index statistics

See statistics.

infimum record

A pseudo-record in an index , representing the gap below the smallest value in that index. If a transaction has a statement such as SELECT ... FROM ... WHERE col < 10 FOR UPDATE; , and the smallest value in the column is 5, it is a lock on the infimum record that prevents other transactions from inserting even smaller values such as 0, -10, and so on.

See Also gap, index, pseudo-record, supremum record.

INFORMATION_SCHEMA

The name of the database that provides a query interface to the MySQL data dictionary . (This name is defined by the ANSI SQL standard.) To examine information (metadata) about the database, you can query tables such as INFORMATION_SCHEMA.TABLES and INFORMATION_SCHEMA.COLUMNS , rather than using SHOW commands that produce unstructured output.

The INFORMATION_SCHEMA database also contains tables specific to InnoDB that provide a query interface to the InnoDB data dictionary. You use these tables not to see how the database is structured, but to get real-time information about the workings of InnoDB tables to help with performance monitoring, tuning, and troubleshooting.

See Also data dictionary, database, InnoDB.

InnoDB

A MySQL component that combines high performance with transactional capability for reliability, robustness, and concurrent access. It embodies the ACID design philosophy. Represented as a storage engine ; it handles tables created or altered with the ENGINE=INNODB clause. See Chapter 15, The InnoDB Storage Engine for architectural details and administration procedures, and Section 8.5, “Optimizing for InnoDB Tables” for performance advice.

In MySQL 5.5 and higher, InnoDB is the default storage engine for new tables and the ENGINE=INNODB clause is not required.

InnoDB tables are ideally suited for hot backups . See Section 30.2, “MySQL Enterprise Backup Overview” for information about the MySQL Enterprise Backup product for backing up MySQL servers without interrupting normal processing.

See Also ACID, hot backup, MySQL Enterprise Backup, storage engine, transaction.

innodb_autoinc_lock_mode

The innodb_autoinc_lock_mode option controls the algorithm used for auto-increment locking . When you have an auto-incrementing primary key , you can use statement-based replication only with the setting innodb_autoinc_lock_mode=1 . This setting is known as consecutive lock mode, because multi-row inserts within a transaction receive consecutive auto-increment values. If you have innodb_autoinc_lock_mode=2 , which allows higher concurrency for insert operations, use row-based replication rather than statement-based replication. This setting is known as interleaved lock mode, because multiple multi-row insert statements running at the same time can receive auto-increment values that are interleaved. The setting innodb_autoinc_lock_mode=0 should not be used except for compatibility purposes.

Consecutive lock mode ( innodb_autoinc_lock_mode=1 ) is the default setting prior to MySQL 8.0.3. As of MySQL 8.0.3, interleaved lock mode ( innodb_autoinc_lock_mode=2 ) is the default, which reflects the change from statement-based to row-based replication as the default replication type.

See Also auto-increment, auto-increment locking, mixed-mode insert, primary key.

innodb_file_per_table

An important configuration option that affects many aspects of InnoDB file storage, availability of features, and I/O characteristics. In MySQL 5.6.7 and higher, it is enabled by default. The innodb_file_per_table option turns on file-per-table mode. With this mode enabled, a newly created InnoDB table and associated indexes can be stored in a file-per-table .ibd file , outside the system tablespace .

This option affects the performance and storage considerations for a number of SQL statements, such as DROP TABLE and TRUNCATE TABLE .

Enabling the innodb_file_per_table option allows you to take advantage of features such as table compression and named-table backups in MySQL Enterprise Backup .

For more information, see innodb_file_per_table , and Section 15.6.3.2, “File-Per-Table Tablespaces”.

See Also compression, file-per-table, .ibd file, MySQL Enterprise Backup, system tablespace.

innodb_lock_wait_timeout

The innodb_lock_wait_timeout option sets the balance between waiting for shared resources to become available, or giving up and handling the error, retrying, or doing alternative processing in your application. Rolls back any InnoDB transaction that waits more than a specified time to acquire a lock . Especially useful if deadlocks are caused by updates to multiple tables controlled by different storage engines; such deadlocks are not detected automatically.

See Also deadlock, deadlock detection, lock, wait.

innodb_strict_mode

The innodb_strict_mode option controls whether InnoDB operates in strict mode , where conditions that are normally treated as warnings, cause errors instead (and the underlying statements fail).

See Also strict mode.

insert

One of the primary DML operations in SQL . The performance of inserts is a key factor in data warehouse systems that load millions of rows into tables, and OLTP systems where many concurrent connections might insert rows into the same table, in arbitrary order. If insert performance is important to you, you should learn about InnoDB features such as the insert buffer used in change buffering , and auto-increment columns.

See Also auto-increment, change buffering, data warehouse, DML, InnoDB, insert buffer, OLTP, SQL.

insert buffer

The former name of the change buffer . In MySQL 5.5, support was added for buffering changes to secondary index pages for DELETE and UPDATE operations. Previously, only changes resulting from INSERT operations were buffered. The preferred term is now change buffer .

See Also change buffer, change buffering.

insert buffering

The technique of storing changes to secondary index pages, resulting from INSERT operations, in the change buffer rather than writing the changes immediately, so that the physical writes can be performed to minimize random I/O. It is one of the types of change buffering ; the others are delete buffering and purge buffering .

Insert buffering is not used if the secondary index is unique , because the uniqueness of new values cannot be verified before the new entries are written out. Other kinds of change buffering do work for unique indexes.

See Also change buffer, change buffering, delete buffering, insert buffer, purge buffering, unique index.

insert intention lock

A type of gap lock that is set by INSERT operations prior to row insertion. This type of lock signals the intent to insert in such a way that multiple transactions inserting into the same index gap need not wait for each other if they are not inserting at the same position within the gap. For more information, see Section 15.7.1, “InnoDB Locking”.

See Also gap lock, lock, next-key lock.

instance

A single mysqld daemon managing a data directory representing one or more databases with a set of tables . It is common in development, testing, and some replication scenarios to have multiple instances on the same server machine, each managing its own data directory and listening on its own port or socket. With one instance running a disk-bound workload, the server might still have extra CPU and memory capacity to run additional instances.

See Also data directory, database, disk-bound, mysqld, replication, server, table.

instrumentation

Modifications at the source code level to collect performance data for tuning and debugging. In MySQL, data collected by instrumentation is exposed through an SQL interface using the INFORMATION_SCHEMA and PERFORMANCE_SCHEMA databases.

See Also INFORMATION_SCHEMA, Performance Schema.

intention exclusive lock

See intention lock.

intention lock

A kind of lock that applies to the table, used to indicate the kind of lock the transaction intends to acquire on rows in the table. Different transactions can acquire different kinds of intention locks on the same table, but the first transaction to acquire an intention exclusive (IX) lock on a table prevents other transactions from acquiring any S or X locks on the table. Conversely, the first transaction to acquire an intention shared (IS) lock on a table prevents other transactions from acquiring any X locks on the table. The two-phase process allows the lock requests to be resolved in order, without blocking locks and corresponding operations that are compatible. For more information about this locking mechanism, see Section 15.7.1, “InnoDB Locking”.

See Also lock, lock mode, locking, transaction.

intention shared lock

See intention lock.

interceptor

Code for instrumenting or debugging some aspect of an application, which can be enabled without recompiling or changing the source of the application itself.

See Also command interceptor, Connector/J, Connector/NET, exception interceptor.

intrinsic temporary table

An optimized internal InnoDB temporary table used by the optimizer .

See Also optimizer.

inverted index

A data structure optimized for document retrieval systems, used in the implementation of InnoDB full-text search . The InnoDB FULLTEXT index , implemented as an inverted index, records the position of each word within a document, rather than the location of a table row. A single column value (a document stored as a text string) is represented by many entries in the inverted index.

See Also full-text search, FULLTEXT index, ilist.

IOPS

Acronym for I/O operations per second . A common measurement for busy systems, particularly OLTP applications. If this value is near the maximum that the storage devices can handle, the application can become disk-bound , limiting scalability .

See Also disk-bound, OLTP, scalability.

isolation level

One of the foundations of database processing. Isolation is the I in the acronym ACID ; the isolation level is the setting that fine-tunes the balance between performance and reliability, consistency, and reproducibility of results when multiple transactions are making changes and performing queries at the same time.

From highest amount of consistency and protection to the least, the isolation levels supported by InnoDB are: SERIALIZABLE , REPEATABLE READ , READ COMMITTED , and READ UNCOMMITTED .

With InnoDB tables, many users can keep the default isolation level ( REPEATABLE READ ) for all operations. Expert users might choose the READ COMMITTED level as they push the boundaries of scalability with OLTP processing, or during data warehousing operations where minor inconsistencies do not affect the aggregate results of large amounts of data. The levels on the edges ( SERIALIZABLE and READ UNCOMMITTED ) change the processing behavior to such an extent that they are rarely used.

See Also ACID, OLTP, READ COMMITTED, READ UNCOMMITTED, REPEATABLE READ, SERIALIZABLE, transaction.

J

J2EE

Java Platform, Enterprise Edition: Oracle's enterprise Java platform. It consists of an API and a runtime environment for enterprise-class Java applications. For full details, see http://www.oracle.com/technetwork/java/javaee/overview/index.html. With MySQL applications, you typically use Connector/J for database access, and an application server such as Tomcat or JBoss to handle the middle-tier work, and optionally a framework such as Spring . Database-related features often offered within a J2EE stack include a connection pool and failover support.

See Also connection pool, Connector/J, failover, Java, JBoss, Spring, Tomcat.

Java

A programming language combining high performance, rich built-in features and data types, object-oriented mechanisms, extensive standard library, and wide range of reusable third-party modules. Enterprise development is supported by many frameworks, application servers, and other technologies. Much of its syntax is familiar to C and C++ developers. To write Java applications with MySQL, you use the JDBC driver known as Connector/J .

See Also C, Connector/J, C++, JDBC.

JBoss

See Also J2EE.

JDBC

Abbreviation for Java Database Connectivity , an API for database access from Java applications. Java developers writing MySQL applications use the Connector/J component as their JDBC driver.

See Also API, Connector/J, J2EE, Java.

JNDI

See Also Java.

join

A query that retrieves data from more than one table, by referencing columns in the tables that hold identical values. Ideally, these columns are part of an InnoDB foreign key relationship, which ensures referential integrity and that the join columns are indexed . Often used to save space and improve query performance by replacing repeated strings with numeric IDs, in a normalized data design.

See Also foreign key, index, normalized, query, referential integrity.

K

KDC

See key distribution center.

key distribution center

In Kerberos, the key distribution center comprises an authentication server (AS) and a ticket-granting server (TGS).

See Also authentication server, ticket-granting ticket.

keystore

See Also SSL.

KEY_BLOCK_SIZE

An option to specify the size of data pages within an InnoDB table that uses compressed row format . The default is 8 kilobytes. Lower values risk hitting internal limits that depend on the combination of row size and compression percentage.

For MyISAM tables, KEY_BLOCK_SIZE optionally specifies the size in bytes to use for index key blocks. The value is treated as a hint; a different size could be used if necessary. A KEY_BLOCK_SIZE value specified for an individual index definition overrides a table-level KEY_BLOCK_SIZE value.

See Also compressed row format.

L

latch

A lightweight structure used by InnoDB to implement a lock for its own internal memory structures, typically held for a brief time measured in milliseconds or microseconds. A general term that includes both mutexes (for exclusive access) and rw-locks (for shared access). Certain latches are the focus of InnoDB performance tuning. Statistics about latch use and contention are available through the Performance Schema interface.

See Also lock, locking, mutex, Performance Schema, rw-lock.

libmysql

Informal name for the libmysqlclient library.

See Also libmysqlclient.

libmysqlclient

The library file, named libmysqlclient.a or libmysqlclient.so , that is typically linked into client programs written in C . Sometimes known informally as libmysql or the mysqlclient library.

See Also client, libmysql, mysqlclient.

libmysqld

This embedded MySQL server library makes it possible to run a full-featured MySQL server inside a client application. The main benefits are increased speed and more simple management for embedded applications. You link with the libmysqld library rather than libmysqlclient . The API is identical between all three of these libraries.

See Also client, embedded, libmysql, libmysqlclient.

lifecycle interceptor

A type of interceptor supported by Connector/J . It involves implementing the interface com.mysql.jdbc.ConnectionLifecycleInterceptor .

See Also Connector/J, interceptor.

list

The InnoDB buffer pool is represented as a list of memory pages . The list is reordered as new pages are accessed and enter the buffer pool, as pages within the buffer pool are accessed again and are considered newer, and as pages that are not accessed for a long time are evicted from the buffer pool. The buffer pool is divided into sublists , and the replacement policy is a variation of the familiar LRU technique.

See Also buffer pool, eviction, LRU, page, sublist.

load balancing

A technique for scaling read-only connections by sending query requests to different slave servers in a replication or Cluster configuration. With Connector/J , load balancing is enabled through the com.mysql.jdbc.ReplicationDriver class and controlled by the configuration property loadBalanceStrategy .

See Also Connector/J, J2EE.

localhost

See Also connection.

lock

The high-level notion of an object that controls access to a resource, such as a table, row, or internal data structure, as part of a locking strategy. For intensive performance tuning, you might delve into the actual structures that implement locks, such as mutexes and latches .

See Also latch, lock mode, locking, mutex.

lock escalation

An operation used in some database systems that converts many row locks into a single table lock , saving memory space but reducing concurrent access to the table. InnoDB uses a space-efficient representation for row locks, so that lock escalation is not needed.

See Also locking, row lock, table lock.

lock mode

A shared (S) lock allows a transaction to read a row. Multiple transactions can acquire an S lock on that same row at the same time.

An exclusive (X) lock allows a transaction to update or delete a row. No other transaction can acquire any kind of lock on that same row at the same time.

Intention locks apply to the table, and are used to indicate what kind of lock the transaction intends to acquire on rows in the table. Different transactions can acquire different kinds of intention locks on the same table, but the first transaction to acquire an intention exclusive (IX) lock on a table prevents other transactions from acquiring any S or X locks on the table. Conversely, the first transaction to acquire an intention shared (IS) lock on a table prevents other transactions from acquiring any X locks on the table. The two-phase process allows the lock requests to be resolved in order, without blocking locks and corresponding operations that are compatible.

See Also intention lock, lock, locking, transaction.

locking

The system of protecting a transaction from seeing or changing data that is being queried or changed by other transactions. The locking strategy must balance reliability and consistency of database operations (the principles of the ACID philosophy) against the performance needed for good concurrency . Fine-tuning the locking strategy often involves choosing an isolation level and ensuring all your database operations are safe and reliable for that isolation level.

See Also ACID, concurrency, isolation level, locking, transaction.

locking read

A SELECT statement that also performs a locking operation on an InnoDB table. Either SELECT ... FOR UPDATE or SELECT ... LOCK IN SHARE MODE . It has the potential to produce a deadlock , depending on the isolation level of the transaction. The opposite of a non-locking read . Not allowed for global tables in a read-only transaction .

SELECT ... FOR SHARE replaces SELECT ... LOCK IN SHARE MODE in MySQL 8.0.1, but LOCK IN SHARE MODE remains available for backward compatibility.

See Section 15.7.2.4, “Locking Reads”.

See Also deadlock, isolation level, locking, non-locking read, read-only transaction.

log

In the InnoDB context, log or log files typically refers to the redo log represented by the ib_logfile N files. Another type of InnoDB log is the undo log , which is a storage area that holds copies of data modified by active transactions.

Other kinds of logs that are important in MySQL are the error log (for diagnosing startup and runtime problems), binary log (for working with replication and performing point-in-time restores), the general query log (for diagnosing application problems), and the slow query log (for diagnosing performance problems).

See Also binary log, error log, general query log, ib_logfile, redo log, slow query log, undo log.

log buffer

The memory area that holds data to be written to the log files that make up the redo log . It is controlled by the innodb_log_buffer_size configuration option.

See Also log file, redo log.

log file

One of the ib_logfile N files that make up the redo log . Data is written to these files from the log buffer memory area.

See Also ib_logfile, log buffer, redo log.

log group

The set of files that make up the redo log , typically named ib_logfile0 and ib_logfile1 . (For that reason, sometimes referred to collectively as ib_logfile .)

See Also ib_logfile, redo log.

logical

A type of operation that involves high-level, abstract aspects such as tables, queries, indexes, and other SQL concepts. Typically, logical aspects are important to make database administration and application development convenient and usable. Contrast with physical .

See Also logical backup, physical.

logical backup

A backup that reproduces table structure and data, without copying the actual data files. For example, the mysqldump command produces a logical backup, because its output contains statements such as CREATE TABLE and INSERT that can re-create the data. Contrast with physical backup . A logical backup offers flexibility (for example, you could edit table definitions or insert statements before restoring), but can take substantially longer to restore than a physical backup.

See Also backup, mysqldump, physical backup, restore.

loose_

A prefix added to InnoDB configuration options after server startup , so any new configuration options not recognized by the current level of MySQL do not cause a startup failure. MySQL processes configuration options that start with this prefix, but gives a warning rather than a failure if the part after the prefix is not a recognized option.

See Also startup.

low-water mark

A value representing a lower limit, typically a threshold value at which some corrective action begins or becomes more aggressive. Contrast with high-water mark .

See Also high-water mark.

LRU

An acronym for least recently used , a common method for managing storage areas. The items that have not been used recently are evicted when space is needed to cache newer items. InnoDB uses the LRU mechanism by default to manage the pages within the buffer pool , but makes exceptions in cases where a page might be read only a single time, such as during a full table scan . This variation of the LRU algorithm is called the midpoint insertion strategy . For more information, see Section 15.5.1, “Buffer Pool”.

See Also buffer pool, eviction, full table scan, midpoint insertion strategy, page.

LSN

Acronym for log sequence number . This arbitrary, ever-increasing value represents a point in time corresponding to operations recorded in the redo log . (This point in time is regardless of transaction boundaries; it can fall in the middle of one or more transactions.) It is used internally by InnoDB during crash recovery and for managing the buffer pool .

Prior to MySQL 5.6.3, the LSN was a 4-byte unsigned integer. The LSN became an 8-byte unsigned integer in MySQL 5.6.3 when the redo log file size limit increased from 4GB to 512GB, as additional bytes were required to store extra size information. Applications built on MySQL 5.6.3 or later that use LSN values should use 64-bit rather than 32-bit variables to store and compare LSN values.

In the MySQL Enterprise Backup product, you can specify an LSN to represent the point in time from which to take an incremental backup . The relevant LSN is displayed by the output of the mysqlbackup command. Once you have the LSN corresponding to the time of a full backup, you can specify that value to take a subsequent incremental backup, whose output contains another LSN for the next incremental backup.

See Also buffer pool, crash recovery, incremental backup, MySQL Enterprise Backup, redo log, transaction.

M

.MRG file

A file containing references to other tables, used by the MERGE storage engine. Files with this extension are always included in backups produced by the mysqlbackup command of the MySQL Enterprise Backup product.

See Also MySQL Enterprise Backup, mysqlbackup command.

.MYD file

A file that MySQL uses to store data for a MyISAM table.

See Also .MYI file, MySQL Enterprise Backup, mysqlbackup command.

.MYI file

A file that MySQL uses to store indexes for a MyISAM table.

See Also .MYD file, MySQL Enterprise Backup, mysqlbackup command.

master

See source.

master thread

An InnoDB thread that performs various tasks in the background. Most of these tasks are I/O related, such as writing changes from the change buffer to the appropriate secondary indexes.

To improve concurrency , sometimes actions are moved from the master thread to separate background threads. For example, in MySQL 5.6 and higher, dirty pages are flushed from the buffer pool by the page cleaner thread rather than the master thread.

See Also buffer pool, change buffer, concurrency, dirty page, flush, page cleaner, thread.

MDL

Acronym for metadata lock .

See Also metadata lock.

medium trust

Synonym for partial trust . Because the range of trust settings is so broad, partial trust is preferred, to avoid the implication that there are only three levels (low, medium, and full).

See Also Connector/NET, partial trust.

memcached

A popular component of many MySQL and NoSQL software stacks, allowing fast reads and writes for single values and caching the results entirely in memory. Traditionally, applications required extra logic to write the same data to a MySQL database for permanent storage, or to read data from a MySQL database when it was not cached yet in memory. Now, applications can use the simple memcached protocol, supported by client libraries for many languages, to communicate directly with MySQL servers using InnoDB or NDB tables. These NoSQL interfaces to MySQL tables allow applications to achieve higher read and write performance than by issuing SQL statements directly, and can simplify application logic and deployment configurations for systems that already incorporate memcached for in-memory caching.

The memcached interface to InnoDB tables is available in MySQL 5.6 and higher; see Section 15.20, “InnoDB memcached Plugin” for details. The memcached interface to NDB tables is available in NDB Cluster 7.2 and later; see http://dev.mysql.com/doc/ndbapi/en/ndbmemcache.html for details.

See Also InnoDB, NoSQL.

merge

To apply changes to data cached in memory, such as when a page is brought into the buffer pool , and any applicable changes recorded in the change buffer are incorporated into the page in the buffer pool. The updated data is eventually written to the tablespace by the flush mechanism.

See Also buffer pool, change buffer, flush, tablespace.

metadata lock

A type of lock that prevents DDL operations on a table that is being used at the same time by another transaction . For details, see Section 8.11.4, “Metadata Locking”.

Enhancements to online operations, particularly in MySQL 5.6 and higher, are focused on reducing the amount of metadata locking. The objective is for DDL operations that do not change the table structure (such as CREATE INDEX and DROP INDEX for InnoDB tables) to proceed while the table is being queried, updated, and so on by other transactions.

See Also DDL, lock, online, transaction.

metrics counter

A feature implemented by the INNODB_METRICS table in the INFORMATION_SCHEMA , in MySQL 5.6 and higher. You can query counts and totals for low-level InnoDB operations, and use the results for performance tuning in combination with data from the Performance Schema .

See Also counter, INFORMATION_SCHEMA, Performance Schema.

midpoint insertion strategy

The technique of initially bringing pages into the InnoDB buffer pool not at the newest end of the list, but instead somewhere in the middle. The exact location of this point can vary, based on the setting of the innodb_old_blocks_pct option. The intent is that pages that are only read once, such as during a full table scan , can be aged out of the buffer pool sooner than with a strict LRU algorithm. For more information, see Section 15.5.1, “Buffer Pool”.

See Also buffer pool, full table scan, LRU, page.

mini-transaction

An internal phase of InnoDB processing, when making changes at the physical level to internal data structures during DML operations. A mini-transaction (mtr) has no notion of rollback ; multiple mini-transactions can occur within a single transaction . Mini-transactions write information to the redo log that is used during crash recovery . A mini-transaction can also happen outside the context of a regular transaction, for example during purge processing by background threads.

See Also commit, crash recovery, DML, physical, purge, redo log, rollback, transaction.

mixed-mode insert

An INSERT statement where auto-increment values are specified for some but not all of the new rows. For example, a multi-value INSERT could specify a value for the auto-increment column in some cases and NULL in other cases. InnoDB generates auto-increment values for the rows where the column value was specified as NULL . Another example is an INSERT ... ON DUPLICATE KEY UPDATE statement, where auto-increment values might be generated but not used, for any duplicate rows that are processed as UPDATE rather than INSERT statements.

Can cause consistency issues between source and replica servers in a replication configuration. Can require adjusting the value of the innodb_autoinc_lock_mode configuration option.

See Also auto-increment, innodb_autoinc_lock_mode, replica, replication, source.

MM.MySQL

An older JDBC driver for MySQL that evolved into Connector/J when it was integrated with the MySQL product.

See Also Connector/J.

Mono

An Open Source framework developed by Novell, that works with Connector/NET and C# applications on Linux platforms.

See Also Connector/NET, C#.

mtr

See mini-transaction.

multi-core

A type of processor that can take advantage of multithreaded programs, such as the MySQL server.

multiversion concurrency control

See MVCC.

mutex

Informal abbreviation for mutex variable . (Mutex itself is short for mutual exclusion .) The low-level object that InnoDB uses to represent and enforce exclusive-access locks to internal in-memory data structures. Once the lock is acquired, any other process, thread, and so on is prevented from acquiring the same lock. Contrast with rw-locks , which InnoDB uses to represent and enforce shared-access locks to internal in-memory data structures. Mutexes and rw-locks are known collectively as latches .

See Also latch, lock, Performance Schema, Pthreads, rw-lock.

MVCC

Acronym for multiversion concurrency control . This technique lets InnoDB transactions with certain isolation levels perform consistent read operations; that is, to query rows that are being updated by other transactions, and see the values from before those updates occurred. This is a powerful technique to increase concurrency , by allowing queries to proceed without waiting due to locks held by the other transactions.

This technique is not universal in the database world. Some other database products, and some other MySQL storage engines, do not support it.

See Also ACID, concurrency, consistent read, isolation level, lock, transaction.

my.cnf

The name, on Unix or Linux systems, of the MySQL option file .

See Also my.ini, option file.

my.ini

The name, on Windows systems, of the MySQL option file .

See Also my.cnf, option file.

MyODBC drivers

Obsolete name for Connector/ODBC .

See Also Connector/ODBC.

mysql

The mysql program is the command-line interpreter for the MySQL database. It processes SQL statements, and also MySQL-specific commands such as SHOW TABLES , by passing requests to the mysqld daemon.

See Also mysqld, SQL.

MySQL Enterprise Backup

A licensed product that performs hot backups of MySQL databases. It offers the most efficiency and flexibility when backing up InnoDB tables, but can also back up MyISAM and other kinds of tables.

See Also hot backup, InnoDB.

mysqlbackup command

A command-line tool of the MySQL Enterprise Backup product. It performs a hot backup operation for InnoDB tables, and a warm backup for MyISAM and other kinds of tables. See Section 30.2, “MySQL Enterprise Backup Overview” for more information about this command.

See Also hot backup, MySQL Enterprise Backup, warm backup.

mysqlclient

The informal name for the library that is implemented by the file libmysqlclient , with extension .a or .so .

See Also libmysqlclient.

mysqld

mysqld , also known as MySQL Server, is a single multithreaded program that does most of the work in a MySQL installation. It does not spawn additional processes. MySQL Server manages access to the MySQL data directory that contains databases, tables, and other information such as log files and status files.

mysqld runs as a Unix daemon or Windows service, constantly waiting for requests and performing maintenance work in the background.

See Also instance, mysql.

MySQLdb

The name of the open-source Python module that forms the basis of the MySQL Python API .

See Also Python, Python API.

mysqldump

A command that performs a logical backup of some combination of databases, tables, and table data. The results are SQL statements that reproduce the original schema objects, data, or both. For substantial amounts of data, a physical backup solution such as MySQL Enterprise Backup is faster, particularly for the restore operation.

See Also logical backup, MySQL Enterprise Backup, physical backup, restore.

N

.NET

See Also ADO.NET, ASP.net, Connector/NET, Mono, Visual Studio.

native C API

Synonym for libmysqlclient .

See Also libmysql.

natural key

An indexed column, typically a primary key , where the values have some real-world significance. Usually advised against because:

  • If the value should ever change, there is potentially a lot of index maintenance to re-sort the clustered index and update the copies of the primary key value that are repeated in each secondary index .

  • Even seemingly stable values can change in unpredictable ways that are difficult to represent correctly in the database. For example, one country can change into two or several, making the original country code obsolete. Or, rules about unique values might have exceptions. For example, even if taxpayer IDs are intended to be unique to a single person, a database might have to handle records that violate that rule, such as in cases of identity theft. Taxpayer IDs and other sensitive ID numbers also make poor primary keys, because they may need to be secured, encrypted, and otherwise treated differently than other columns.

Thus, it is typically better to use arbitrary numeric values to form a synthetic key , for example using an auto-increment column.

See Also auto-increment, clustered index, primary key, secondary index, synthetic key.

neighbor page

Any page in the same extent as a particular page. When a page is selected to be flushed , any neighbor pages that are dirty are typically flushed as well, as an I/O optimization for traditional hard disks. In MySQL 5.6 and up, this behavior can be controlled by the configuration variable innodb_flush_neighbors ; you might turn that setting off for SSD drives, which do not have the same overhead for writing smaller batches of data at random locations.

See Also dirty page, extent, flush, page.

next-key lock

A combination of a record lock on the index record and a gap lock on the gap before the index record.

See Also gap lock, locking, record lock.

non-locking read

A query that does not use the SELECT ... FOR UPDATE or SELECT ... LOCK IN SHARE MODE clauses. The only kind of query allowed for global tables in a read-only transaction . The opposite of a locking read . See Section 15.7.2.3, “Consistent Nonlocking Reads”.

SELECT ... FOR SHARE replaces SELECT ... LOCK IN SHARE MODE in MySQL 8.0.1, but LOCK IN SHARE MODE remains available for backward compatibility.

See Also locking read, query, read-only transaction.

non-repeatable read

The situation when a query retrieves data, and a later query within the same transaction retrieves what should be the same data, but the queries return different results (changed by another transaction committing in the meantime).

This kind of operation goes against the ACID principle of database design. Within a transaction, data should be consistent, with predictable and stable relationships.

Among different isolation levels , non-repeatable reads are prevented by the serializable read and repeatable read levels, and allowed by the consistent read , and read uncommitted levels.

See Also ACID, consistent read, isolation level, READ UNCOMMITTED, REPEATABLE READ, SERIALIZABLE, transaction.

nonblocking I/O

An industry term that means the same as asynchronous I/O .

See Also asynchronous I/O.

normalized

A database design strategy where data is split into multiple tables, and duplicate values condensed into single rows represented by an ID, to avoid storing, querying, and updating redundant or lengthy values. It is typically used in OLTP applications.

For example, an address might be given a unique ID, so that a census database could represent the relationship lives at this address by associating that ID with each member of a family, rather than storing multiple copies of a complex value such as 123 Main Street, Anytown, USA .

For another example, although a simple address book application might store each phone number in the same table as a person's name and address, a phone company database might give each phone number a special ID, and store the numbers and IDs in a separate table. This normalized representation could simplify large-scale updates when area codes split apart.

Normalization is not always recommended. Data that is primarily queried, and only updated by deleting entirely and reloading, is often kept in fewer, larger tables with redundant copies of duplicate values. This data representation is referred to as denormalized , and is frequently found in data warehousing applications.

See Also denormalized, foreign key, OLTP, relational.

NoSQL

A broad term for a set of data access technologies that do not use the SQL language as their primary mechanism for reading and writing data. Some NoSQL technologies act as key-value stores, only accepting single-value reads and writes; some relax the restrictions of the ACID methodology; still others do not require a pre-planned schema . MySQL users can combine NoSQL-style processing for speed and simplicity with SQL operations for flexibility and convenience, by using the memcached API to directly access some kinds of MySQL tables. The memcached interface to InnoDB tables is available in MySQL 5.6 and higher; see Section 15.20, “InnoDB memcached Plugin” for details. The memcached interface to NDB tables is available in NDB Cluster 7.2 and later; see ndbmemcache—Memcache API for NDB Cluster (NO LONGER SUPPORTED).

See Also ACID, InnoDB, memcached, schema, SQL.

NOT NULL constraint

A type of constraint that specifies that a column cannot contain any NULL values. It helps to preserve referential integrity , as the database server can identify data with erroneous missing values. It also helps in the arithmetic involved in query optimization, allowing the optimizer to predict the number of entries in an index on that column.

See Also column, constraint, NULL, primary key, referential integrity.

NULL

A special value in SQL , indicating the absence of data. Any arithmetic operation or equality test involving a NULL value, in turn produces a NULL result. (Thus it is similar to the IEEE floating-point concept of NaN, not a number .) Any aggregate calculation such as AVG() ignores rows with NULL values, when determining how many rows to divide by. The only test that works with NULL values uses the SQL idioms IS NULL or IS NOT NULL .

NULL values play a part in index operations, because for performance a database must minimize the overhead of keeping track of missing data values. Typically, NULL values are not stored in an index, because a query that tests an indexed column using a standard comparison operator could never match a row with a NULL value for that column. For the same reason, unique indexes do not prevent NULL values; those values simply are not represented in the index. Declaring a NOT NULL constraint on a column provides reassurance that there are no rows left out of the index, allowing for better query optimization (accurate counting of rows and estimation of whether to use the index).

Because the primary key must be able to uniquely identify every row in the table, a single-column primary key cannot contain any NULL values, and a multi-column primary key cannot contain any rows with NULL values in all columns.

Although the Oracle database allows a NULL value to be concatenated with a string, InnoDB treats the result of such an operation as NULL .

See Also index, primary key, SQL.

O

.OPT file

A file containing database configuration information. Files with this extension are included in backups produced by the mysqlbackup command of the MySQL Enterprise Backup product.

See Also MySQL Enterprise Backup, mysqlbackup command.

ODBC

Acronym for Open Database Connectivity, an industry-standard API. Typically used with Windows-based servers, or applications that require ODBC to communicate with MySQL. The MySQL ODBC driver is called Connector/ODBC .

See Also Connector/ODBC.

off-page column

A column containing variable-length data (such as BLOB and VARCHAR ) that is too long to fit on a B-tree page. The data is stored in overflow pages . The DYNAMIC row format is more efficient for such storage than the older COMPACT row format.

See Also B-tree, compact row format, dynamic row format, overflow page.

OLTP

Acronym for Online Transaction Processing . A database system, or a database application, that runs a workload with many transactions , with frequent writes as well as reads, typically affecting small amounts of data at a time. For example, an airline reservation system or an application that processes bank deposits. The data might be organized in normalized form for a balance between DML (insert/update/delete) efficiency and query efficiency. Contrast with data warehouse .

With its row-level locking and transactional capability, InnoDB is the ideal storage engine for MySQL tables used in OLTP applications.

See Also data warehouse, DML, InnoDB, query, row lock, transaction.

online

A type of operation that involves no downtime, blocking, or restricted operation for the database. Typically applied to DDL . Operations that shorten the periods of restricted operation, such as fast index creation , have evolved into a wider set of online DDL operations in MySQL 5.6.

In the context of backups, a hot backup is an online operation and a warm backup is partially an online operation.

See Also DDL, Fast Index Creation, hot backup, online DDL, warm backup.

online DDL

A feature that improves the performance, concurrency, and availability of InnoDB tables during DDL (primarily ALTER TABLE ) operations. See Section 15.12, “InnoDB and Online DDL” for details.

The details vary according to the type of operation. In some cases, the table can be modified concurrently while the ALTER TABLE is in progress. The operation might be able to be performed without a table copy, or using a specially optimized type of table copy. DML log space usage for in-place operations is controlled by the innodb_online_alter_log_max_size configuration option.

This feature is an enhancement of the Fast Index Creation feature in MySQL 5.5.

See Also DDL, Fast Index Creation, online.

optimistic

A methodology that guides low-level implementation decisions for a relational database system. The requirements of performance and concurrency in a relational database mean that operations must be started or dispatched quickly. The requirements of consistency and referential integrity mean that any operation could fail: a transaction might be rolled back, a DML operation could violate a constraint, a request for a lock could cause a deadlock, a network error could cause a timeout. An optimistic strategy is one that assumes most requests or attempts succeed, so that relatively little work is done to prepare for the failure case. When this assumption is true, the database does little unnecessary work; when requests do fail, extra work must be done to clean up and undo changes.

InnoDB uses optimistic strategies for operations such as locking and commits . For example, data changed by a transaction can be written to the data files before the commit occurs, making the commit itself very fast, but requiring more work to undo the changes if the transaction is rolled back.

The opposite of an optimistic strategy is a pessimistic one, where a system is optimized to deal with operations that are unreliable and frequently unsuccessful. This methodology is rare in a database system, because so much care goes into choosing reliable hardware, networks, and algorithms.

See Also commit, concurrency, DML, locking, pessimistic, referential integrity.

optimizer

The MySQL component that determines the best indexes and join order to use for a query , based on characteristics and data distribution of the relevant tables .

See Also index, join, query, table.

option

A configuration parameter for MySQL, either stored in the option file or passed on the command line.

For the options that apply to InnoDB tables, each option name starts with the prefix innodb_ .

See Also InnoDB, option, option file.

option file

The file that holds the configuration options for the MySQL instance. Traditionally, on Linux and Unix this file is named my.cnf , and on Windows it is named my.ini .

See Also configuration file, my.cnf, my.ini, option.

overflow page

Separately allocated disk pages that hold variable-length columns (such as BLOB and VARCHAR ) that are too long to fit on a B-tree page. The associated columns are known as off-page columns .

See Also B-tree, off-page column, page.

P

.par file

A file containing partition definitions. Files with this extension are included in backups produced by the mysqlbackup command of the MySQL Enterprise Backup product.

With the introduction of native partitioning support for InnoDB tables in MySQL 5.7.6, .par files are no longer created for partitioned InnoDB tables. Partitioned MyISAM tables continue to use .par files in MySQL 5.7. In MySQL 8.0, partitioning support is only provided by the InnoDB storage engine. As such, .par files are no longer used as of MySQL 8.0.

See Also MySQL Enterprise Backup, mysqlbackup command.

page

A unit representing how much data InnoDB transfers at any one time between disk (the data files ) and memory (the buffer pool ). A page can contain one or more rows , depending on how much data is in each row. If a row does not fit entirely into a single page, InnoDB sets up additional pointer-style data structures so that the information about the row can be stored in one page.

One way to fit more data in each page is to use compressed row format . For tables that use BLOBs or large text fields, compact row format allows those large columns to be stored separately from the rest of the row, reducing I/O overhead and memory usage for queries that do not reference those columns.

When InnoDB reads or writes sets of pages as a batch to increase I/O throughput, it reads or writes an extent at a time.

All the InnoDB disk data structures within a MySQL instance share the same page size .

See Also buffer pool, compact row format, compressed row format, data files, extent, page size, row.

page cleaner

An InnoDB background thread that flushes dirty pages from the buffer pool . Prior to MySQL 5.6, this activity was performed by the master thread . The number of page cleaner threads is controlled by the innodb_page_cleaners configuration option, introduced in MySQL 5.7.4.

See Also buffer pool, dirty page, flush, master thread, thread.

page size

For releases up to and including MySQL 5.5, the size of each InnoDB page is fixed at 16 kilobytes. This value represents a balance: large enough to hold the data for most rows, yet small enough to minimize the performance overhead of transferring unneeded data to memory. Other values are not tested or supported.

Starting in MySQL 5.6, the page size for an InnoDB instance can be either 4KB, 8KB, or 16KB, controlled by the innodb_page_size configuration option. As of MySQL 5.7.6, InnoDB also supports 32KB and 64KB page sizes. For 32KB and 64KB page sizes, ROW_FORMAT=COMPRESSED is not supported and the maximum record size is 16KB.

Page size is set when creating the MySQL instance, and it remains constant afterward. The same page size applies to all InnoDB tablespaces , including the system tablespace , file-per-table tablespaces, and general tablespaces .

Smaller page sizes can help performance with storage devices that use small block sizes, particularly for SSD devices in disk-bound workloads, such as for OLTP applications. As individual rows are updated, less data is copied into memory, written to disk, reorganized, locked, and so on.

See Also disk-bound, file-per-table, general tablespace, instance, OLTP, page, SSD, system tablespace, tablespace.

parent table

The table in a foreign key relationship that holds the initial column values pointed to from the child table . The consequences of deleting, or updating rows in the parent table depend on the ON UPDATE and ON DELETE clauses in the foreign key definition. Rows with corresponding values in the child table could be automatically deleted or updated in turn, or those columns could be set to NULL , or the operation could be prevented.

See Also child table, foreign key.

partial backup

A backup that contains some of the tables in a MySQL database, or some of the databases in a MySQL instance. Contrast with full backup .

See Also backup, full backup, table.

partial index

An index that represents only part of a column value, typically the first N characters (the prefix ) of a long VARCHAR value.

See Also index, index prefix.

partial trust

An execution environment typically used by hosting providers, where applications have some permissions but not others. For example, applications might be able to access a database server over a network, but be sandboxed with regard to reading and writing local files.

See Also Connector/NET.

Performance Schema

The performance_schema schema, in MySQL 5.5 and up, presents a set of tables that you can query to get detailed information about the performance characteristics of many internal parts of the MySQL server. See Chapter 27, MySQL Performance Schema .

See Also INFORMATION_SCHEMA, latch, mutex, rw-lock.

Perl

A programming language with roots in Unix scripting and report generation. Incorporates high-performance regular expressions and file I/O. Large collection of reusable modules available through repositories such as CPAN.

See Also Perl API.

Perl API

An open-source API for MySQL applications written in the Perl language. Implemented through the DBI and DBD::mysql modules. For details, see Section 29.9, “MySQL Perl API”.

See Also API, Perl.

persistent statistics

A feature that stores index statistics for InnoDB tables on disk, providing better plan stability for queries . For more information, see Section 15.8.10.1, “Configuring Persistent Optimizer Statistics Parameters”.

See Also index, optimizer, plan stability, query, table.

pessimistic

A methodology that sacrifices performance or concurrency in favor of safety. It is appropriate if a high proportion of requests or attempts might fail, or if the consequences of a failed request are severe. InnoDB uses what is known as a pessimistic locking strategy, to minimize the chance of deadlocks . At the application level, you might avoid deadlocks by using a pessimistic strategy of acquiring all locks needed by a transaction at the very beginning.

Many built-in database mechanisms use the opposite optimistic methodology.

See Also deadlock, locking, optimistic.

phantom

A row that appears in the result set of a query, but not in the result set of an earlier query. For example, if a query is run twice within a transaction , and in the meantime, another transaction commits after inserting a new row or updating a row so that it matches the WHERE clause of the query.

This occurrence is known as a phantom read. It is harder to guard against than a non-repeatable read , because locking all the rows from the first query result set does not prevent the changes that cause the phantom to appear.

Among different isolation levels , phantom reads are prevented by the serializable read level, and allowed by the repeatable read , consistent read , and read uncommitted levels.

See Also consistent read, isolation level, non-repeatable read, READ UNCOMMITTED, REPEATABLE READ, SERIALIZABLE, transaction.

PHP

A programming language originating with web applications. The code is typically embedded as blocks within the source of a web page, with the output substituted into the page as it is transmitted by the web server. This is in contrast to applications such as CGI scripts that print output in the form of an entire web page. The PHP style of coding is used for highly interactive and dynamic web pages. Modern PHP programs can also be run as command-line or GUI applications.

MySQL applications are written using one of the PHP APIs . Reusable modules can be written in C and called from PHP.

Another technology for writing server-side web pages with MySQL is ASP.net .

See Also ASP.net, C, PHP API.

PHP API

Several APIs are available for writing MySQL applications in the PHP language: the original MySQL API ( Mysql ) the MySQL Improved Extension ( Mysqli ) the MySQL Native Driver ( Mysqlnd ) the MySQL functions ( PDO_MYSQL ), and Connector/PHP. For details, see MySQL and PHP.

See Also API, PHP.

physical

A type of operation that involves hardware-related aspects such as disk blocks, memory pages, files, bits, disk reads, and so on. Typically, physical aspects are important during expert-level performance tuning and problem diagnosis. Contrast with logical .

See Also logical, physical backup.

physical backup

A backup that copies the actual data files. For example, the mysqlbackup command of the MySQL Enterprise Backup product produces a physical backup, because its output contains data files that can be used directly by the mysqld server, resulting in a faster restore operation. Contrast with logical backup .

See Also backup, logical backup, MySQL Enterprise Backup, restore.

PITR

Acronym for point-in-time recovery .

See Also point-in-time recovery.

plan stability

A property of a query execution plan , where the optimizer makes the same choices each time for a given query , so that performance is consistent and predictable.

See Also query, query execution plan.

point-in-time recovery

The process of restoring a backup to recreate the state of the database at a specific date and time. Commonly abbreviated PITR . Because it is unlikely that the specified time corresponds exactly to the time of a backup, this technique usually requires a combination of a physical backup and a logical backup . For example, with the MySQL Enterprise Backup product, you restore the last backup that you took before the specified point in time, then replay changes from the binary log between the time of the backup and the PITR time.

See Also backup, binary log, logical backup, MySQL Enterprise Backup, physical backup.

port

The number of the TCP/IP socket the database server listens on, used to establish a connection . Often specified in conjunction with a host . Depending on your use of network encryption, there might be one port for unencrypted traffic and another port for SSL connections.

See Also connection, host, SSL.

prefix

See index prefix.

prepared backup

A set of backup files, produced by the MySQL Enterprise Backup product, after all the stages of applying binary logs and incremental backups are finished. The resulting files are ready to be restored . Prior to the apply steps, the files are known as a raw backup .

See Also binary log, hot backup, incremental backup, MySQL Enterprise Backup, raw backup, restore.

prepared statement

An SQL statement that is analyzed in advance to determine an efficient execution plan. It can be executed multiple times, without the overhead for parsing and analysis each time. Different values can be substituted for literals in the WHERE clause each time, through the use of placeholders. This substitution technique improves security, protecting against some kinds of SQL injection attacks. You can also reduce the overhead for converting and copying return values to program variables.

Although you can use prepared statements directly through SQL syntax, the various Connectors have programming interfaces for manipulating prepared statements, and these APIs are more efficient than going through SQL.

See Also client-side prepared statement, connector, server-side prepared statement.

primary key

A set of columns—and by implication, the index based on this set of columns—that can uniquely identify every row in a table. As such, it must be a unique index that does not contain any NULL values.

InnoDB requires that every table has such an index (also called the clustered index or cluster index ), and organizes the table storage based on the column values of the primary key.

When choosing primary key values, consider using arbitrary values (a synthetic key ) rather than relying on values derived from some other source (a natural key ).

See Also clustered index, index, natural key, synthetic key.

principal

The Kerberos term for a named entity, such as a user or server.

See Also service principal name, user principal name.

process

An instance of an executing program. The operating system switches between multiple running processes, allowing for a certain degree of concurrency . On most operating systems, processes can contain multiple threads of execution that share resources. Context-switching between threads is faster than the equivalent switching between processes.

See Also concurrency, thread.

pseudo-record

An artificial record in an index, used for locking key values or ranges that do not currently exist.

See Also infimum record, locking, supremum record.

Pthreads

The POSIX threads standard, which defines an API for threading and locking operations on Unix and Linux systems. On Unix and Linux systems, InnoDB uses this implementation for mutexes .

See Also mutex.

purge

A type of garbage collection performed by one or more separate background threads (controlled by innodb_purge_threads ) that runs on a periodic schedule. Purge parses and processes undo log pages from the history list for the purpose of removing clustered and secondary index records that were marked for deletion (by previous DELETE statements) and are no longer required for MVCC or rollback . Purge frees undo log pages from the history list after processing them.

See Also history list, MVCC, rollback, undo log.

purge buffering

The technique of storing changes to secondary index pages, resulting from DELETE operations, in the change buffer rather than writing the changes immediately, so that the physical writes can be performed to minimize random I/O. (Because delete operations are a two-step process, this operation buffers the write that normally purges an index record that was previously marked for deletion.) It is one of the types of change buffering ; the others are insert buffering and delete buffering .

See Also change buffer, change buffering, delete buffering, insert buffer, insert buffering.

purge lag

Another name for the InnoDB history list . Related to the innodb_max_purge_lag configuration option.

See Also history list, purge.

purge thread

A thread within the InnoDB process that is dedicated to performing the periodic purge operation. In MySQL 5.6 and higher, multiple purge threads are enabled by the innodb_purge_threads configuration option.

See Also purge, thread.

Python

A programming language used in a broad range of fields, from Unix scripting to large-scale applications. Includes runtime typing, built-in high-level data types, object-oriented features, and an extensive standard library. Often used as a glue language between components written in other languages. The MySQL Python API is the open-source MySQLdb module.

See Also MySQLdb, Python API.

Python API

See Also API, Python.

Q

query

In SQL , an operation that reads information from one or more tables . Depending on the organization of data and the parameters of the query, the lookup might be optimized by consulting an index . If multiple tables are involved, the query is known as a join .

For historical reasons, sometimes discussions of internal processing for statements use query in a broader sense, including other types of MySQL statements such as DDL and DML statements.

See Also DDL, DML, index, join, SQL, table.

query execution plan

The set of decisions made by the optimizer about how to perform a query most efficiently, including which index or indexes to use, and the order in which to join tables. Plan stability involves the same choices being made consistently for a given query.

See Also index, join, plan stability, query.

query log

See general query log.

quiesce

To reduce the amount of database activity, often in preparation for an operation such as an ALTER TABLE , a backup , or a shutdown . Might or might not involve doing as much flushing as possible, so that InnoDB does not continue doing background I/O.

In MySQL 5.6 and higher, the syntax FLUSH TABLES ... FOR EXPORT writes some data to disk for InnoDB tables that make it simpler to back up those tables by copying the data files.

See Also backup, flush, InnoDB, shutdown.

R

R-tree

A tree data structure used for spatial indexing of multi-dimensional data such as geographical coordinates, rectangles or polygons.

See Also B-tree.

RAID

Acronym for Redundant Array of Inexpensive Drives . Spreading I/O operations across multiple drives enables greater concurrency at the hardware level, and improves the efficiency of low-level write operations that otherwise would be performed in sequence.

See Also concurrency.

random dive

A technique for quickly estimating the number of different values in a column (the column's cardinality ). InnoDB samples pages at random from the index and uses that data to estimate the number of different values.

See Also cardinality.

raw backup

The initial set of backup files produced by the MySQL Enterprise Backup product, before the changes reflected in the binary log and any incremental backups are applied. At this stage, the files are not ready to restore . After these changes are applied, the files are known as a prepared backup .

See Also binary log, hot backup, ibbackup_logfile, incremental backup, MySQL Enterprise Backup, prepared backup, restore.

READ COMMITTED

An isolation level that uses a locking strategy that relaxes some of the protection between transactions , in the interest of performance. Transactions cannot see uncommitted data from other transactions, but they can see data that is committed by another transaction after the current transaction started. Thus, a transaction never sees any bad data, but the data that it does see may depend to some extent on the timing of other transactions.

When a transaction with this isolation level performs UPDATE ... WHERE or DELETE ... WHERE operations, other transactions might have to wait. The transaction can perform SELECT ... FOR UPDATE , and LOCK IN SHARE MODE operations without making other transactions wait.

SELECT ... FOR SHARE replaces SELECT ... LOCK IN SHARE MODE in MySQL 8.0.1, but LOCK IN SHARE MODE remains available for backward compatibility.

See Also ACID, isolation level, locking, REPEATABLE READ, SERIALIZABLE, transaction.

read phenomena

Phenomena such as dirty reads , non-repeatable reads , and phantom reads which can occur when a transaction reads data that another transaction has modified.

See Also dirty read, non-repeatable read, phantom.

READ UNCOMMITTED

The isolation level that provides the least amount of protection between transactions. Queries employ a locking strategy that allows them to proceed in situations where they would normally wait for another transaction. However, this extra performance comes at the cost of less reliable results, including data that has been changed by other transactions and not committed yet (known as dirty read ). Use this isolation level with great caution, and be aware that the results might not be consistent or reproducible, depending on what other transactions are doing at the same time. Typically, transactions with this isolation level only do queries, not insert, update, or delete operations.

See Also ACID, dirty read, isolation level, locking, transaction.

read view

An internal snapshot used by the MVCC mechanism of InnoDB . Certain transactions , depending on their isolation level , see the data values as they were at the time the transaction (or in some cases, the statement) started. Isolation levels that use a read view are REPEATABLE READ , READ COMMITTED , and READ UNCOMMITTED .

See Also isolation level, MVCC, READ COMMITTED, READ UNCOMMITTED, REPEATABLE READ, transaction.

read-ahead

A type of I/O request that prefetches a group of pages (an entire extent ) into the buffer pool asynchronously, in case these pages are needed soon. The linear read-ahead technique prefetches all the pages of one extent based on access patterns for pages in the preceding extent. The random read-ahead technique prefetches all the pages for an extent once a certain number of pages from the same extent are in the buffer pool. Random read-ahead is not part of MySQL 5.5, but is re-introduced in MySQL 5.6 under the control of the innodb_random_read_ahead configuration option.

See Also buffer pool, extent, page.

read-only transaction

A type of transaction that can be optimized for InnoDB tables by eliminating some of the bookkeeping involved with creating a read view for each transaction. Can only perform non-locking read queries. It can be started explicitly with the syntax START TRANSACTION READ ONLY , or automatically under certain conditions. See Section 8.5.3, “Optimizing InnoDB Read-Only Transactions” for details.

See Also non-locking read, read view, transaction.

record lock

A lock on an index record. For example, SELECT c1 FROM t WHERE c1 = 10 FOR UPDATE; prevents any other transaction from inserting, updating, or deleting rows where the value of t.c1 is 10. Contrast with gap lock and next-key lock .

See Also gap lock, lock, next-key lock.

redo

The data, in units of records, recorded in the redo log when DML statements make changes to InnoDB tables. It is used during crash recovery to correct data written by incomplete transactions . The ever-increasing LSN value represents the cumulative amount of redo data that has passed through the redo log.

See Also crash recovery, DML, LSN, redo log, transaction.

redo log

A disk-based data structure used during crash recovery , to correct data written by incomplete transactions . During normal operation, it encodes requests to change InnoDB table data, which result from SQL statements or low-level API calls. Modifications that did not finish updating the data files before an unexpected shutdown are replayed automatically.

The redo log is physically represented on disk as a set of redo log files. Redo log data is encoded in terms of records affected; this data is collectively referred to as redo . The passage of data through the redo log is represented by an ever-increasing LSN value.

For more information, see Section 15.6.5, “Redo Log”

See Also crash recovery, data files, ib_logfile, log buffer, LSN, redo, shutdown, transaction.

redo log archiving

An InnoDB feature that, when enabled, sequentially writes redo log records to an archive file to avoid potential loss of data than can occur when a backup utility fails to keep pace with redo log generation while a backup operation is in progress. For more information, see Redo Log Archiving.

See Also redo log.

redundant row format

The oldest InnoDB row format . Prior to MySQL 5.0.3, it was the only row format available in InnoDB . From MySQL 5.0.3 to MySQL 5.7.8, the default row format is COMPACT . As of MySQL 5.7.9, the default row format is defined by the innodb_default_row_format configuration option, which has a default setting of DYNAMIC . You can still specify the REDUNDANT row format for compatibility with older InnoDB tables.

For more information, see Section 15.10, “InnoDB Row Formats”.

See Also compact row format, dynamic row format, row format.

referential integrity

The technique of maintaining data always in a consistent format, part of the ACID philosophy. In particular, data in different tables is kept consistent through the use of foreign key constraints , which can prevent changes from happening or automatically propagate those changes to all related tables. Related mechanisms include the unique constraint , which prevents duplicate values from being inserted by mistake, and the NOT NULL constraint , which prevents blank values from being inserted by mistake.

See Also ACID, FOREIGN KEY constraint, NOT NULL constraint, unique constraint.

relational

An important aspect of modern database systems. The database server encodes and enforces relationships such as one-to-one, one-to-many, many-to-one, and uniqueness. For example, a person might have zero, one, or many phone numbers in an address database; a single phone number might be associated with several family members. In a financial database, a person might be required to have exactly one taxpayer ID, and any taxpayer ID could only be associated with one person.

The database server can use these relationships to prevent bad data from being inserted, and to find efficient ways to look up information. For example, if a value is declared to be unique, the server can stop searching as soon as the first match is found, and it can reject attempts to insert a second copy of the same value.

At the database level, these relationships are expressed through SQL features such as columns within a table, unique and NOT NULL constraints , foreign keys , and different kinds of join operations. Complex relationships typically involve data split between more than one table. Often, the data is normalized , so that duplicate values in one-to-many relationships are stored only once.

In a mathematical context, the relations within a database are derived from set theory. For example, the OR and AND operators of a WHERE clause represent the notions of union and intersection.

See Also ACID, column, constraint, foreign key, normalized.

relevance

In the full-text search feature, a number signifying the similarity between the search string and the data in the FULLTEXT index . For example, when you search for a single word, that word is typically more relevant for a row where it occurs several times in the text than a row where it appears only once.

See Also full-text search, FULLTEXT index.

REPEATABLE READ

The default isolation level for InnoDB . It prevents any rows that are queried from being changed by other transactions , thus blocking non-repeatable reads but not phantom reads. It uses a moderately strict locking strategy so that all queries within a transaction see data from the same snapshot, that is, the data as it was at the time the transaction started.

When a transaction with this isolation level performs UPDATE ... WHERE , DELETE ... WHERE , SELECT ... FOR UPDATE , and LOCK IN SHARE MODE operations, other transactions might have to wait.

SELECT ... FOR SHARE replaces SELECT ... LOCK IN SHARE MODE in MySQL 8.0.1, but LOCK IN SHARE MODE remains available for backward compatibility.

See Also ACID, consistent read, isolation level, locking, phantom, transaction.

repertoire

Repertoire is a term applied to character sets. A character set repertoire is the collection of characters in the set. See Section 10.2.1, “Character Set Repertoire”.

replica

A database server machine in a replication topology that receives changes from another server (the source ) and applies those same changes. Thus it maintains the same contents as the source, although it might lag somewhat behind.

In MySQL, replicas are commonly used in disaster recovery, to take the place of a source that fails. They are also commonly used for testing software upgrades and new settings, to ensure that database configuration changes do not cause problems with performance or reliability.

Replicas typically have high workloads, because they process all the DML (write) operations relayed from the source, as well as user queries. To ensure that replicas can apply changes from the source fast enough, they frequently have fast I/O devices and sufficient CPU and memory to run multiple database instances on the same server. For example, the source might use hard drive storage while the replicas use SSD s.

See Also DML, replication, server, source, SSD.

replication

The practice of sending changes from a source , to one or more replicas , so that all databases have the same data. This technique has a wide range of uses, such as load-balancing for better scalability, disaster recovery, and testing software upgrades and configuration changes. The changes can be sent between the databases by methods called row-based replication and statement-based replication .

See Also replica, row-based replication, source, statement-based replication.

restore

The process of putting a set of backup files from the MySQL Enterprise Backup product in place for use by MySQL. This operation can be performed to fix a corrupted database, to return to some earlier point in time, or (in a replication context) to set up a new replica . In the MySQL Enterprise Backup product, this operation is performed by the copy-back option of the mysqlbackup command.

See Also hot backup, MySQL Enterprise Backup, mysqlbackup command, prepared backup, replica, replication.

rollback

A SQL statement that ends a transaction , undoing any changes made by the transaction. It is the opposite of commit , which makes permanent any changes made in the transaction.

By default, MySQL uses the autocommit setting, which automatically issues a commit following each SQL statement. You must change this setting before you can use the rollback technique.

See Also ACID, autocommit, commit, SQL, transaction.

rollback segment

The storage area containing the undo logs . Rollback segments have traditionally resided in the system tablespace . As of MySQL 5.6, rollback segments can reside in undo tablespaces . As of MySQL 5.7, rollback segments are also allocated to the global temporary tablespace .

See Also global temporary tablespace, system tablespace, undo log, undo tablespace.

row

The logical data structure defined by a set of columns . A set of rows makes up a table . Within InnoDB data files , each page can contain one or more rows.

Although InnoDB uses the term row format for consistency with MySQL syntax, the row format is a property of each table and applies to all rows in that table.

See Also column, data files, page, row format, table.

row format

The disk storage format for rows of an InnoDB table . As InnoDB gains new capabilities such as compression , new row formats are introduced to support the resulting improvements in storage efficiency and performance.

The row format of an InnoDB table is specified by the ROW_FORMAT option or by the innodb_default_row_format configuration option (introduced in MySQL 5.7.9). Row formats include REDUNDANT , COMPACT , COMPRESSED , and DYNAMIC . To view the row format of an InnoDB table, issue the SHOW TABLE STATUS statement or query InnoDB table metadata in the INFORMATION_SCHEMA .

See Also compact row format, compressed row format, compression, dynamic row format, redundant row format, row, table.

row lock

A lock that prevents a row from being accessed in an incompatible way by another transaction . Other rows in the same table can be freely written to by other transactions. This is the type of locking done by DML operations on InnoDB tables.

Contrast with table locks used by MyISAM , or during DDL operations on InnoDB tables that cannot be done with online DDL ; those locks block concurrent access to the table.

See Also DDL, DML, InnoDB, lock, locking, online DDL, table lock, transaction.

row-based replication

A form of replication where events are propagated from the source specifying how to change individual rows on the replica . It is safe to use for all settings of the innodb_autoinc_lock_mode option.

See Also auto-increment locking, innodb_autoinc_lock_mode, replica, replication, source, statement-based replication.

row-level locking

The locking mechanism used for InnoDB tables, relying on row locks rather than table locks . Multiple transactions can modify the same table concurrently. Only if two transactions try to modify the same row does one of the transactions wait for the other to complete (and release its row locks).

See Also InnoDB, locking, row lock, table lock, transaction.

Ruby

A programming language that emphasizes dynamic typing and object-oriented programming. Some syntax is familiar to Perl developers.

See Also API, Perl, Ruby API.

Ruby API

mysql2 , based based on the libmysqlclient API library, is available for Ruby programmers developing MySQL applications. For more information, see Section 29.11, “MySQL Ruby APIs”.

See Also libmysql, Ruby.

rw-lock

The low-level object that InnoDB uses to represent and enforce shared-access locks to internal in-memory data structures following certain rules. Contrast with mutexes , which InnoDB uses to represent and enforce exclusive access to internal in-memory data structures. Mutexes and rw-locks are known collectively as latches .

rw-lock types include s-locks (shared locks), x-locks (exclusive locks), and sx-locks (shared-exclusive locks).

  • An s-lock provides read access to a common resource.

  • An x-lock provides write access to a common resource while not permitting inconsistent reads by other threads.

  • An sx-lock provides write access to a common resource while permitting inconsistent reads by other threads. sx-locks were introduced in MySQL 5.7 to optimize concurrency and improve scalability for read-write workloads.

The following matrix summarizes rw-lock type compatibility.

S SX X
S Compatible Compatible Conflict
SX Compatible Conflict Conflict
X Conflict Conflict Conflict

See Also latch, lock, mutex, Performance Schema.

S

savepoint

Savepoints help to implement nested transactions . They can be used to provide scope to operations on tables that are part of a larger transaction. For example, scheduling a trip in a reservation system might involve booking several different flights; if a desired flight is unavailable, you might roll back the changes involved in booking that one leg, without rolling back the earlier flights that were successfully booked.

See Also rollback, transaction.

scalability

The ability to add more work and issue more simultaneous requests to a system, without a sudden drop in performance due to exceeding the limits of system capacity. Software architecture, hardware configuration, application coding, and type of workload all play a part in scalability. When the system reaches its maximum capacity, popular techniques for increasing scalability are scale up (increasing the capacity of existing hardware or software) and scale out (adding new servers and more instances of MySQL). Often paired with availability as critical aspects of a large-scale deployment.

See Also availability, scale out, scale up.

scale out

A technique for increasing scalability by adding new servers and more instances of MySQL. For example, setting up replication, NDB Cluster, connection pooling, or other features that spread work across a group of servers. Contrast with scale up .

See Also scalability, scale up.

scale up

A technique for increasing scalability by increasing the capacity of existing hardware or software. For example, increasing the memory on a server and adjusting memory-related parameters such as innodb_buffer_pool_size and innodb_buffer_pool_instances . Contrast with scale out .

See Also scalability, scale out.

schema

Conceptually, a schema is a set of interrelated database objects, such as tables, table columns, data types of the columns, indexes, foreign keys, and so on. These objects are connected through SQL syntax, because the columns make up the tables, the foreign keys refer to tables and columns, and so on. Ideally, they are also connected logically, working together as part of a unified application or flexible framework. For example, the INFORMATION_SCHEMA and performance_schema databases use schema in their names to emphasize the close relationships between the tables and columns they contain.

In MySQL, physically, a schema is synonymous with a database . You can substitute the keyword SCHEMA instead of DATABASE in MySQL SQL syntax, for example using CREATE SCHEMA instead of CREATE DATABASE .

Some other database products draw a distinction. For example, in the Oracle Database product, a schema represents only a part of a database: the tables and other objects owned by a single user.

See Also database, INFORMATION_SCHEMA, Performance Schema.

SDI

Acronym for serialized dictionary information .

See Also serialized dictionary information (SDI).

search index

In MySQL, full-text search queries use a special kind of index, the FULLTEXT index . In MySQL 5.6.4 and up, InnoDB and MyISAM tables both support FULLTEXT indexes; formerly, these indexes were only available for MyISAM tables.

See Also full-text search, FULLTEXT index.

secondary index

A type of InnoDB index that represents a subset of table columns. An InnoDB table can have zero, one, or many secondary indexes. (Contrast with the clustered index , which is required for each InnoDB table, and stores the data for all the table columns.)

A secondary index can be used to satisfy queries that only require values from the indexed columns. For more complex queries, it can be used to identify the relevant rows in the table, which are then retrieved through lookups using the clustered index.

Creating and dropping secondary indexes has traditionally involved significant overhead from copying all the data in the InnoDB table. The fast index creation feature makes both CREATE INDEX and DROP INDEX statements much faster for InnoDB secondary indexes.

See Also clustered index, Fast Index Creation, index.

segment

A division within an InnoDB tablespace . If a tablespace is analogous to a directory, the segments are analogous to files within that directory. A segment can grow. New segments can be created.

For example, within a file-per-table tablespace, table data is in one segment and each associated index is in its own segment. The system tablespace contains many different segments, because it can hold many tables and their associated indexes. Prior to MySQL 8.0, the system tablespace also includes one or more rollback segments used for undo logs .

Segments grow and shrink as data is inserted and deleted. When a segment needs more room, it is extended by one extent (1 megabyte) at a time. Similarly, a segment releases one extent's worth of space when all the data in that extent is no longer needed.

See Also extent, file-per-table, rollback segment, system tablespace, tablespace, undo log.

selectivity

A property of data distribution, the number of distinct values in a column (its cardinality ) divided by the number of records in the table. High selectivity means that the column values are relatively unique, and can retrieved efficiently through an index. If you (or the query optimizer) can predict that a test in a WHERE clause only matches a small number (or proportion) of rows in a table, the overall query tends to be efficient if it evaluates that test first, using an index.

See Also cardinality, query.

semi-consistent read

A type of read operation used for UPDATE statements, that is a combination of READ COMMITTED and consistent read . When an UPDATE statement examines a row that is already locked, InnoDB returns the latest committed version to MySQL so that MySQL can determine whether the row matches the WHERE condition of the UPDATE . If the row matches (must be updated), MySQL reads the row again, and this time InnoDB either locks it or waits for a lock on it. This type of read operation can only happen when the transaction has the READ COMMITTED isolation level .

See Also consistent read, isolation level, READ COMMITTED.

SERIALIZABLE

The isolation level that uses the most conservative locking strategy, to prevent any other transactions from inserting or changing data that was read by this transaction, until it is finished. This way, the same query can be run over and over within a transaction, and be certain to retrieve the same set of results each time. Any attempt to change data that was committed by another transaction since the start of the current transaction, cause the current transaction to wait.

This is the default isolation level specified by the SQL standard. In practice, this degree of strictness is rarely needed, so the default isolation level for InnoDB is the next most strict, REPEATABLE READ .

See Also ACID, consistent read, isolation level, locking, REPEATABLE READ, transaction.

serialized dictionary information (SDI)

Dictionary object metadata in serialized form. SDI is stored in JSON format.

As of MySQL 8.0.3, SDI is present in all InnoDB tablespace files except for temporary tablespace and undo tablespace files. The presence of SDI in tablespace files provides metadata redundancy. For example, dictionary object metadata can be extracted from tablespace files using the ibd2sdi utility if the data dictionary becomes unavailable.

For a MyISAM table, SDI is stored in a .sdi metadata file in the schema directory. An SDI metadata file is required to perform an IMPORT TABLE operation.

See Also file-per-table, general tablespace, system tablespace, tablespace.

server

A type of program that runs continuously, waiting to receive and act upon requests from another program (the client ). Because often an entire computer is dedicated to running one or more server programs (such as a database server, a web server, an application server, or some combination of these), the term server can also refer to the computer that runs the server software.

See Also client, mysqld.

server-side prepared statement

A prepared statement managed by the MySQL server. Historically, issues with server-side prepared statements led Connector/J and Connector/PHP developers to sometimes use client-side prepared statements instead. With modern MySQL server versions, server-side prepared statements are recommended for performance, scalability, and memory efficiency.

See Also client-side prepared statement, Connector/J, Connector/PHP, prepared statement.

service principal name

The name for a Kerberos named entity that represents a service.

See Also principal.

service ticket

A Kerberos ticket that provides access to an application service, such as the service provided by a web or database server.

servlet

See Also Connector/J.

session temporary tablespace

A temporary tablespace that stores user-created temporary tables and internal temporary tables created by the optimizer when InnoDB is configured as the on-disk storage engine for internal temporary tables.

See Also optimizer, temporary table, temporary tablespace.

shared lock

A kind of lock that allows other transactions to read the locked object, and to also acquire other shared locks on it, but not to write to it. The opposite of exclusive lock .

See Also exclusive lock, lock, transaction.

shared tablespace

Another way of referring to the system tablespace or a general tablespace . General tablespaces were introduced in MySQL 5.7. More than one table can reside in a shared tablespace. Only a single table can reside in a file-per-table tablespace.

See Also general tablespace, system tablespace.

sharp checkpoint

The process of flushing to disk all dirty buffer pool pages whose redo entries are contained in certain portion of the redo log . Occurs before InnoDB reuses a portion of a log file; the log files are used in a circular fashion. Typically occurs with write-intensive workloads .

See Also dirty page, flush, redo log, workload.

shutdown

The process of stopping the MySQL server. By default, this process cleans up operations for InnoDB tables, so InnoDB can be slow to shut down, but fast to start up later. If you skip the cleanup operations, it is fast to shut down but the cleanup must be performed during the next restart.

The shutdown mode for InnoDB is controlled by the innodb_fast_shutdown option.

See Also fast shutdown, InnoDB, slow shutdown, startup.

slave

See replica.

slow query log

A type of log used for performance tuning of SQL statements processed by the MySQL server. The log information is stored in a file. You must enable this feature to use it. You control which categories of slow SQL statements are logged. For more information, see Section 5.4.5, “The Slow Query Log”.

See Also general query log, log.

slow shutdown

A type of shutdown that does additional InnoDB flushing operations before completing. Also known as a clean shutdown . Specified by the configuration parameter innodb_fast_shutdown=0 or the command SET GLOBAL innodb_fast_shutdown=0; . Although the shutdown itself can take longer, that time should be saved on the subsequent startup.

See Also clean shutdown, fast shutdown, shutdown.

snapshot

A representation of data at a particular time, which remains the same even as changes are committed by other transactions . Used by certain isolation levels to allow consistent reads .

See Also commit, consistent read, isolation level, transaction.

sort buffer

The buffer used for sorting data during creation of an InnoDB index. Sort buffer size is configured using the innodb_sort_buffer_size configuration option.

source

A database server machine in a replication scenario that processes the initial insert, update, and delete requests for data. These changes are propagated to, and repeated on, other servers known as replicas .

See Also replica, replication.

space ID

An identifier used to uniquely identify an InnoDB tablespace within a MySQL instance. The space ID for the system tablespace is always zero; this same ID applies to all tables within the system tablespace or within a general tablespace. Each file-per-table tablespace and general tablespace has its own space ID.

Prior to MySQL 5.6, this hardcoded value presented difficulties in moving InnoDB tablespace files between MySQL instances. Starting in MySQL 5.6, you can copy tablespace files between instances by using the transportable tablespace feature involving the statements FLUSH TABLES ... FOR EXPORT , ALTER TABLE ... DISCARD TABLESPACE , and ALTER TABLE ... IMPORT TABLESPACE . The information needed to adjust the space ID is conveyed in the .cfg file which you copy along with the tablespace. See Section 15.6.1.3, “Importing InnoDB Tables” for details.

See Also .cfg file, file-per-table, general tablespace, .ibd file, system tablespace, tablespace, transportable tablespace.

sparse file

A type of file that uses file system space more efficiently by writing metadata representing empty blocks to disk instead of writing the actual empty space. The InnoDB transparent page compression feature relies on sparse file support. For more information, see Section 15.9.2, “InnoDB Page Compression”.

See Also hole punching, transparent page compression.

spin

A type of wait operation that continuously tests whether a resource becomes available. This technique is used for resources that are typically held only for brief periods, where it is more efficient to wait in a busy loop than to put the thread to sleep and perform a context switch. If the resource does not become available within a short time, the spin loop ceases and another wait technique is used.

See Also latch, lock, mutex, wait.

SPN

See service principal name.

Spring

A Java-based application framework designed for assisting in application design by providing a way to configure components.

See Also J2EE.

SQL

The Structured Query Language that is standard for performing database operations. Often divided into the categories DDL , DML , and queries . MySQL includes some additional statement categories such as replication . See Chapter 9, Language Structure for the building blocks of SQL syntax, Chapter 11, Data Types for the data types to use for MySQL table columns, Chapter 13, SQL Statements for details about SQL statements and their associated categories, and Chapter 12, Functions and Operators for standard and MySQL-specific functions to use in queries.

See Also DDL, DML, query, replication.

SQLState

An error code defined by the JDBC standard, for exception handling by applications using Connector/J .

See Also Connector/J, JDBC.

SSD

Acronym for solid-state drive . A type of storage device with different performance characteristics than a traditional hard disk drive ( HDD ): smaller storage capacity, faster for random reads, no moving parts, and with a number of considerations affecting write performance. Its performance characteristics can influence the throughput of a disk-bound workload.

See Also disk-bound, HDD.

SSL

Acronym for secure sockets layer . Provides the encryption layer for network communication between an application and a MySQL database server.

See Also keystore, truststore.

ST

See service ticket.

startup

The process of starting the MySQL server. Typically done by one of the programs listed in Section 4.3, “Server and Server-Startup Programs”. The opposite of shutdown .

See Also shutdown.

statement interceptor

A type of interceptor for tracing, debugging, or augmenting SQL statements issued by a database application. Sometimes also known as a command interceptor .

In Java applications using Connector/J , setting up this type of interceptor involves implementing the com.mysql.jdbc.StatementInterceptorV2 interface, and adding a statementInterceptors property to the connection string .

In Visual Studio applications using Connector/NET , setting up this type of interceptor involves defining a class that inherits from the BaseCommandInterceptor class and specifying that class name as part of the connection string.

See Also command interceptor, connection string, Connector/J, Connector/NET, interceptor, Java, Visual Studio.

statement-based replication

A form of replication where SQL statements are sent from the source and replayed on the replica . It requires some care with the setting for the innodb_autoinc_lock_mode option, to avoid potential timing problems with auto-increment locking .

See Also auto-increment locking, innodb_autoinc_lock_mode, replica, replication, row-based replication, source.

statistics

Estimated values relating to each InnoDB table and index , used to construct an efficient query execution plan . The main values are the cardinality (number of distinct values) and the total number of table rows or index entries. The statistics for the table represent the data in its primary key index. The statistics for a secondary index represent the rows covered by that index.

The values are estimated rather than counted precisely because at any moment, different transactions can be inserting and deleting rows from the same table. To keep the values from being recalculated frequently, you can enable persistent statistics , where the values are stored in InnoDB system tables, and refreshed only when you issue an ANALYZE TABLE statement.

You can control how NULL values are treated when calculating statistics through the innodb_stats_method configuration option.

Other types of statistics are available for database objects and database activity through the INFORMATION_SCHEMA and PERFORMANCE_SCHEMA tables.

See Also cardinality, index, INFORMATION_SCHEMA, NULL, Performance Schema, persistent statistics, primary key, query execution plan, secondary index, table, transaction.

stemming

The ability to search for different variations of a word based on a common root word, such as singular and plural, or past, present, and future verb tense. This feature is currently supported in MyISAM full-text search feature but not in FULLTEXT indexes for InnoDB tables.

See Also full-text search, FULLTEXT index.

stopword

In a FULLTEXT index , a word that is considered common or trivial enough that it is omitted from the search index and ignored in search queries. Different configuration settings control stopword processing for InnoDB and MyISAM tables. See Section 12.10.4, “Full-Text Stopwords” for details.

See Also FULLTEXT index, search index.

storage engine

A component of the MySQL database that performs the low-level work of storing, updating, and querying data. In MySQL 5.5 and higher, InnoDB is the default storage engine for new tables, superceding MyISAM . Different storage engines are designed with different tradeoffs between factors such as memory usage versus disk usage, read speed versus write speed, and speed versus robustness. Each storage engine manages specific tables, so we refer to InnoDB tables, MyISAM tables, and so on.

The MySQL Enterprise Backup product is optimized for backing up InnoDB tables. It can also back up tables handled by MyISAM and other storage engines.

See Also InnoDB, MySQL Enterprise Backup, table type.

stored generated column

A column whose values are computed from an expression included in the column definition. Column values are evaluated and stored when rows are inserted or updated. A stored generated column requires storage space and can be indexed.

Contrast with virtual generated column .

See Also base column, generated column, virtual generated column.

stored object

A stored program or view.

stored program

A stored routine (procedure or function), trigger, or Event Scheduler event.

stored routine

A stored procedure or function.

strict mode

The general name for the setting controlled by the innodb_strict_mode option. Turning on this setting causes certain conditions that are normally treated as warnings, to be considered errors. For example, certain invalid combinations of options related to file format and row format , that normally produce a warning and continue with default values, now cause the CREATE TABLE operation to fail. innodb_strict_mode is enabled by default in MySQL 5.7.

MySQL also has something called strict mode. See Section 5.1.11, “Server SQL Modes”.

See Also file format, innodb_strict_mode, row format.

sublist

Within the list structure that represents the buffer pool , pages that are relatively old and relatively new are represented by different portions of the list . A set of parameters control the size of these portions and the dividing point between the new and old pages.

See Also buffer pool, eviction, list, LRU.

supremum record

A pseudo-record in an index, representing the gap above the largest value in that index. If a transaction has a statement such as SELECT ... FROM ... WHERE col > 10 FOR UPDATE; , and the largest value in the column is 20, it is a lock on the supremum record that prevents other transactions from inserting even larger values such as 50, 100, and so on.

See Also gap, infimum record, pseudo-record.

surrogate key

Synonym name for synthetic key .

See Also synthetic key.

synthetic key

An indexed column, typically a primary key , where the values are assigned arbitrarily. Often done using an auto-increment column. By treating the value as completely arbitrary, you can avoid overly restrictive rules and faulty application assumptions. For example, a numeric sequence representing employee numbers might have a gap if an employee was approved for hiring but never actually joined. Or employee number 100 might have a later hiring date than employee number 500, if they left the company and later rejoined. Numeric values also produce shorter values of predictable length. For example, storing numeric codes meaning Road , Boulevard , Expressway , and so on is more space-efficient than repeating those strings over and over.

Also known as a surrogate key . Contrast with natural key .

See Also auto-increment, natural key, primary key, surrogate key.

system tablespace

One or more data files ( ibdata files ) containing the metadata for InnoDB -related objects, and the storage areas for the change buffer , and the doublewrite buffer . It may also contain table and index data for InnoDB tables if tables were created in the system tablespace instead of file-per-table or general tablespaces . The data and metadata in the system tablespace apply to all databases in a MySQL instance .

Prior to MySQL 5.6.7, the default was to keep all InnoDB tables and indexes inside the system tablespace, often causing this file to become very large. Because the system tablespace never shrinks, storage problems could arise if large amounts of temporary data were loaded and then deleted. In MySQL 8.0, the default is file-per-table mode, where each table and its associated indexes are stored in a separate .ibd file . This default makes it easier to use InnoDB features that rely on DYNAMIC and COMPRESSED row formats, such as table compression , efficient storage of off-page columns , and large index key prefixes.

Keeping all table data in the system tablespace or in separate .ibd files has implications for storage management in general. The MySQL Enterprise Backup product might back up a small set of large files, or many smaller files. On systems with thousands of tables, the file system operations to process thousands of .ibd files can cause bottlenecks.

InnoDB introduced general tablespaces in MySQL 5.7.6, which are also represented by .ibd files. General tablespaces are shared tablespaces created using CREATE TABLESPACE syntax. They can be created outside of the data directory, are capable of holding multiple tables, and support tables of all row formats.

See Also change buffer, compression, data dictionary, database, doublewrite buffer, dynamic row format, file-per-table, general tablespace, .ibd file, ibdata file, innodb_file_per_table, instance, MySQL Enterprise Backup, off-page column, tablespace, undo log.

T

table

Each MySQL table is associated with a particular storage engine . InnoDB tables have particular physical and logical characteristics that affect performance, scalability , backup , administration, and application development.

In terms of file storage, an InnoDB table belongs to one of the following tablespace types:

  • The shared InnoDB system tablespace , which is comprised of one or more ibdata files .

  • A file-per-table tablespace, comprised of an individual .ibd file .

  • A shared general tablespace , comprised of an individual .ibd file. General tablespaces were introduced in MySQL 5.7.6.

.ibd data files contain both table and index data.

InnoDB tables created in file-per-table tablespaces can use DYNAMIC or COMPRESSED row format. These row formats enable InnoDB features such as compression , efficient storage of off-page columns , and large index key prefixes. General tablespaces support all row formats.

The system tablespace supports tables that use REDUNDANT , COMPACT , and DYNAMIC row formats. System tablespace support for the DYNAMIC row format was added in MySQL 5.7.6.

The rows of an InnoDB table are organized into an index structure known as the clustered index , with entries sorted based on the primary key columns of the table. Data access is optimized for queries that filter and sort on the primary key columns, and each index contains a copy of the associated primary key columns for each entry. Modifying values for any of the primary key columns is an expensive operation. Thus an important aspect of InnoDB table design is choosing a primary key with columns that are used in the most important queries, and keeping the primary key short, with rarely changing values.

See Also backup, clustered index, compact row format, compressed row format, compression, dynamic row format, Fast Index Creation, file-per-table, .ibd file, index, off-page column, primary key, redundant row format, row, system tablespace, tablespace.

table lock

A lock that prevents any other transaction from accessing a table. InnoDB makes considerable effort to make such locks unnecessary, by using techniques such as online DDL , row locks and consistent reads for processing DML statements and queries . You can create such a lock through SQL using the LOCK TABLE statement; one of the steps in migrating from other database systems or MySQL storage engines is to remove such statements wherever practical.

See Also consistent read, DML, lock, locking, online DDL, query, row lock, table, transaction.

table scan

See full table scan.

table statistics

See statistics.

table type

Obsolete synonym for storage engine . We refer to InnoDB tables, MyISAM tables, and so on.

See Also InnoDB, storage engine.

tablespace

A data file that can hold data for one or more InnoDB tables and associated indexes .

The system tablespace contains the InnoDB data dictionary , and prior to MySQL 5.6 holds all other InnoDB tables by default.

The innodb_file_per_table option, enabled by default in MySQL 5.6 and higher, allows tables to be created in their own tablespaces. File-per-table tablespaces support features such as efficient storage of off-page columns , table compression, and transportable tablespaces. See Section 15.6.3.2, “File-Per-Table Tablespaces” for details.

InnoDB introduced general tablespaces in MySQL 5.7.6. General tablespaces are shared tablespaces created using CREATE TABLESPACE syntax. They can be created outside of the MySQL data directory, are capable of holding multiple tables, and support tables of all row formats.

MySQL NDB Cluster also groups its tables into tablespaces. See Section 23.6.11.1, “NDB Cluster Disk Data Objects” for details.

See Also compressed row format, data dictionary, data files, file-per-table, general tablespace, index, innodb_file_per_table, system tablespace, table.

Tcl

A programming language originating in the Unix scripting world. Sometimes extended by code written in C , C++ , or Java . For the open-source Tcl API for MySQL, see Section 29.12, “MySQL Tcl API”.

See Also API.

temporary table

A table whose data does not need to be truly permanent. For example, temporary tables might be used as storage areas for intermediate results in complicated calculations or transformations; this intermediate data would not need to be recovered after a crash. Database products can take various shortcuts to improve the performance of operations on temporary tables, by being less scrupulous about writing data to disk and other measures to protect the data across restarts.

Sometimes, the data itself is removed automatically at a set time, such as when the transaction ends or when the session ends. With some database products, the table itself is removed automatically too.

See Also table.

temporary tablespace

InnoDB uses two types of temporary tablespace. Session temporary tablespaces store user-created temporary tables and internal temporary tables created by the optimizer. The global temporary tablespace stores rollback segments for changes made to user-created temporary tables.

See Also global temporary tablespace, session temporary tablespace, temporary table.

text collection

The set of columns included in a FULLTEXT index .

See Also FULLTEXT index.

TGS

A Kerberos ticket-granting server. TGS can also refer to the ticket-granting service provided by a ticket-granting server.

See Also ticket-granting server.

TGT

See ticket-granting ticket.

thread

A unit of processing that is typically more lightweight than a process , allowing for greater concurrency .

See Also concurrency, master thread, process, Pthreads.

ticket-granting server

In Kerberos, a server that provides tickets. The ticket-granting server (TGS) combined with an authentication server (AS) make up a key distribution center (KDC).

TGS can also refer to the ticket-granting service provided by the ticket-granting server.

See Also authentication server, key distribution center.

ticket-granting ticket

In Kerberos, a ticket-granting ticket is presented to the ticket-granting server (TGS) to obtain service tickets for service access.

See Also ticket-granting server.

Tomcat

An open source J2EE application server, implementing the Java Servlet and JavaServer Pages programming technologies. Consists of a web server and Java servlet container. With MySQL, typically used in conjunction with Connector/J .

See Also J2EE.

torn page

An error condition that can occur due to a combination of I/O device configuration and hardware failure. If data is written out in chunks smaller than the InnoDB page size (by default, 16KB), a hardware failure while writing could result in only part of a page being stored to disk. The InnoDB doublewrite buffer guards against this possibility.

See Also doublewrite buffer.

TPS

Acronym for transactions per second , a unit of measurement sometimes used in benchmarks. Its value depends on the workload represented by a particular benchmark test, combined with factors that you control such as the hardware capacity and database configuration.

See Also transaction, workload.

transaction

Transactions are atomic units of work that can be committed or rolled back . When a transaction makes multiple changes to the database, either all the changes succeed when the transaction is committed, or all the changes are undone when the transaction is rolled back.

Database transactions, as implemented by InnoDB , have properties that are collectively known by the acronym ACID , for atomicity, consistency, isolation, and durability.

See Also ACID, commit, isolation level, lock, rollback.

transaction ID

An internal field associated with each row . This field is physically changed by INSERT , UPDATE , and DELETE operations to record which transaction has locked the row.

See Also implicit row lock, row, transaction.

transparent page compression

A feature added in MySQL 5.7.8 that permits page-level compression for InnoDB tables that reside in file-per-table tablespaces. Page compression is enabled by specifying the COMPRESSION attribute with CREATE TABLE or ALTER TABLE . For more information, see Section 15.9.2, “InnoDB Page Compression”.

See Also file-per-table, hole punching, sparse file.

transportable tablespace

A feature that allows a tablespace to be moved from one instance to another. Traditionally, this has not been possible for InnoDB tablespaces because all table data was part of the system tablespace . In MySQL 5.6 and higher, the FLUSH TABLES ... FOR EXPORT syntax prepares an InnoDB table for copying to another server; running ALTER TABLE ... DISCARD TABLESPACE and ALTER TABLE ... IMPORT TABLESPACE on the other server brings the copied data file into the other instance. A separate .cfg file , copied along with the .ibd file , is used to update the table metadata (for example the space ID ) as the tablespace is imported. See Section 15.6.1.3, “Importing InnoDB Tables” for usage information.

See Also .cfg file, .ibd file, space ID, system tablespace, tablespace.

troubleshooting

The process of determining the source of a problem. Some of the resources for troubleshooting MySQL problems include:

  • Section 2.10.2.1, “Troubleshooting Problems Starting the MySQL Server”

  • Section 6.2.22, “Troubleshooting Problems Connecting to MySQL”

  • Section B.3.3.2, “How to Reset the Root Password”

  • Section B.3.2, “Common Errors When Using MySQL Programs”

  • Section 15.21, “InnoDB Troubleshooting”.

truncate

A DDL operation that removes the entire contents of a table, while leaving the table and related indexes intact. Contrast with drop . Although conceptually it has the same result as a DELETE statement with no WHERE clause, it operates differently behind the scenes: InnoDB creates a new empty table, drops the old table, then renames the new table to take the place of the old one. Because this is a DDL operation, it cannot be rolled back .

If the table being truncated contains foreign keys that reference another table, the truncation operation uses a slower method of operation, deleting one row at a time so that corresponding rows in the referenced table can be deleted as needed by any ON DELETE CASCADE clause. (MySQL 5.5 and higher do not allow this slower form of truncate, and return an error instead if foreign keys are involved. In this case, use a DELETE statement instead.

See Also DDL, drop, foreign key, rollback.

truststore

See Also SSL.

tuple

A technical term designating an ordered set of elements. It is an abstract notion, used in formal discussions of database theory. In the database field, tuples are usually represented by the columns of a table row. They could also be represented by the result sets of queries, for example, queries that retrieved only some columns of a table, or columns from joined tables.

See Also cursor.

two-phase commit

An operation that is part of a distributed transaction , under the XA specification. (Sometimes abbreviated as 2PC.) When multiple databases participate in the transaction, either all databases commit the changes, or all databases roll back the changes.

See Also commit, rollback, transaction, XA.

U

undo

Data that is maintained throughout the life of a transaction , recording all changes so that they can be undone in case of a rollback operation. It is stored in undo logs either within the system tablespace (in MySQL 5.7 or earlier) or in separate undo tablespaces . As of MySQL 8.0, undo logs reside in undo tablespaces by default.

See Also rollback, rollback segment, system tablespace, transaction, undo log, undo tablespace.

undo buffer

See undo log.

undo log

A storage area that holds copies of data modified by active transactions . If another transaction needs to see the original data (as part of a consistent read operation), the unmodified data is retrieved from this storage area.

In MySQL 5.6 and MySQL 5.7, you can use the innodb_undo_tablespaces variable have undo logs reside in undo tablespaces , which can be placed on another storage device such as an SSD . In MySQL 8.0, undo logs reside in two default undo tablespaces that are created when MySQL is initialized, and additional undo tablespaces can be created using CREATE UNDO TABLESPACE syntax.

The undo log is split into separate portions, the insert undo buffer and the update undo buffer .

See Also consistent read, rollback segment, SSD, system tablespace, transaction, undo tablespace.

undo log segment

A collection of undo logs . Undo log segments exists within rollback segments . An undo log segment might contain undo logs from multiple transactions. An undo log segment can only be used by one transaction at a time but can be reused after it is released at transaction commit or rollback . May also be referred to as an undo segment .

See Also commit, rollback, rollback segment, undo log.

undo tablespace

An undo tablespace contains undo logs . Undo logs exist within undo log segments , which are contained within rollback segments . Rollback segments have traditionally resided in the system tablespace. As of MySQL 5.6, rollback segments can reside in undo tablespaces. In MySQL 5.6 and MySQL 5.7, the number of undo tablespaces is controlled by the innodb_undo_tablespaces configuration option. In MySQL 8.0, two default undo tablespaces are created when the MySQL instance is initialized, and additional undo tablespaces can be created using CREATE UNDO TABLESPACE syntax.

For more information, see Section 15.6.3.4, “Undo Tablespaces”.

See Also rollback segment, system tablespace, undo log, undo log segment.

Unicode

A system for supporting national characters, character sets, code pages, and other internationalization aspects in a flexible and standardized way.

Unicode support is an important aspect of the ODBC standard. Connector/ODBC 5.1 is a Unicode driver, as opposed to Connector/ODBC 3.51, which is an ANSI driver.

See Also ANSI, Connector/ODBC, ODBC.

unique constraint

A kind of constraint that asserts that a column cannot contain any duplicate values. In terms of relational algebra, it is used to specify 1-to-1 relationships. For efficiency in checking whether a value can be inserted (that is, the value does not already exist in the column), a unique constraint is supported by an underlying unique index .

See Also constraint, relational, unique index.

unique index

An index on a column or set of columns that have a unique constraint . Because the index is known not to contain any duplicate values, certain kinds of lookups and count operations are more efficient than in the normal kind of index. Most of the lookups against this type of index are simply to determine if a certain value exists or not. The number of values in the index is the same as the number of rows in the table, or at least the number of rows with non-null values for the associated columns.

Change buffering optimization does not apply to unique indexes. As a workaround, you can temporarily set unique_checks=0 while doing a bulk data load into an InnoDB table.

See Also cardinality, change buffering, unique constraint, unique key.

unique key

The set of columns (one or more) comprising a unique index . When you can define a WHERE condition that matches exactly one row, and the query can use an associated unique index, the lookup and error handling can be performed very efficiently.

See Also cardinality, unique constraint, unique index.

UPN

See user principal name.

user principal name

The name for a Kerberos named entity that represents a user.

See Also principal.

V

variable-length type

A data type of variable length. VARCHAR , VARBINARY , and BLOB and TEXT types are variable-length types.

InnoDB treats fixed-length fields greater than or equal to 768 bytes in length as variable-length fields, which can be stored off-page . For example, a CHAR(255) column can exceed 768 bytes if the maximum byte length of the character set is greater than 3, as it is with utf8mb4 .

See Also off-page column, overflow page.

victim

The transaction that is automatically chosen to be rolled back when a deadlock is detected. InnoDB rolls back the transaction that has updated the fewest rows.

Deadlock detection can be disabled using the innodb_deadlock_detect configuration option.

See Also deadlock, deadlock detection, innodb_lock_wait_timeout, transaction.

view

A stored query that when invoked produces a result set. A view acts as a virtual table.

virtual column

See virtual generated column.

virtual generated column

A column whose values are computed from an expression included in the column definition. Column values are not stored, but are evaluated when rows are read, immediately after any BEFORE triggers. A virtual generated column takes no storage. InnoDB supports secondary indexes on virtual generated columns.

Contrast with stored generated column .

See Also base column, generated column, stored generated column.

virtual index

A virtual index is a secondary index on one or more virtual generated columns or on a combination of virtual generated columns and regular columns or stored generated columns. For more information, see Section 13.1.20.9, “Secondary Indexes and Generated Columns”.

See Also secondary index, stored generated column, virtual generated column.

Visual Studio

For supported versions of Visual Studio, see the following references:

  • Connector/NET: Connector/NET Versions

  • Connector/C++ 8.0: Platform Support and Prerequisites

See Also Connector/C++, Connector/NET.

W

wait

When an operation, such as acquiring a lock , mutex , or latch , cannot be completed immediately, InnoDB pauses and tries again. The mechanism for pausing is elaborate enough that this operation has its own name, the wait . Individual threads are paused using a combination of internal InnoDB scheduling, operating system wait() calls, and short-duration spin loops.

On systems with heavy load and many transactions, you might use the output from the SHOW INNODB STATUS command or Performance Schema to determine whether threads are spending too much time waiting, and if so, how you can improve concurrency .

See Also concurrency, latch, lock, mutex, Performance Schema, spin.

warm backup

A backup taken while the database is running, but that restricts some database operations during the backup process. For example, tables might become read-only. For busy applications and websites, you might prefer a hot backup .

See Also backup, cold backup, hot backup.

warm up

To run a system under a typical workload for some time after startup, so that the buffer pool and other memory regions are filled as they would be under normal conditions. This process happens naturally over time when a MySQL server is restarted or subjected to a new workload.

Typically, you run a workload for some time to warm up the buffer pool before running performance tests, to ensure consistent results across multiple runs; otherwise, performance might be artificially low during the first run.

In MySQL 5.6, you can speed up the warmup process by enabling the innodb_buffer_pool_dump_at_shutdown and innodb_buffer_pool_load_at_startup configuration options, to bring the contents of the buffer pool back into memory after a restart. These options are enabled by default in MySQL 5.7. See Section 15.8.3.6, “Saving and Restoring the Buffer Pool State”.

See Also buffer pool, workload.

workload

The combination and volume of SQL and other database operations, performed by a database application during typical or peak usage. You can subject the database to a particular workload during performance testing to identify bottlenecks , or during capacity planning.

See Also bottleneck, CPU-bound, disk-bound, SQL.

write combining

An optimization technique that reduces write operations when dirty pages are flushed from the InnoDB buffer pool . If a row in a page is updated multiple times, or multiple rows on the same page are updated, all of those changes are stored to the data files in a single write operation rather than one write for each change.

See Also buffer pool, dirty page, flush.

X

XA

A standard interface for coordinating distributed transactions , allowing multiple databases to participate in a transaction while maintaining ACID compliance. For full details, see Section 13.3.8, “XA Transactions”.

XA Distributed Transaction support is enabled by default.

See Also ACID, binary log, commit, transaction, two-phase commit.

Y

young

A characteristic of a page in the InnoDB buffer pool meaning that it has been accessed recently, and so is moved within the buffer pool data structure, so that it is not flushed too soon by the LRU algorithm. This term is used in some INFORMATION_SCHEMA column names of tables related to the buffer pool.

See Also buffer pool, flush, INFORMATION_SCHEMA, LRU, page.


Read article
MySQL :: MySQL 8.0 Reference Manual :: C Indexes

Appendix C Indexes

Table of Contents

General Index
C Function Index
Command Index
Function Index
INFORMATION_SCHEMA Index
Join Types Index
Operator Index
Option Index
Privileges Index
SQL Modes Index
Statement/Syntax Index
Status Variable Index
System Variable Index
Transaction Isolation Level Index


Read article
MySQL :: MySQL 8.0 Reference Manual :: Transaction Isolation Level Index

Transaction Isolation Level Index

R | S

R

[index top]

READ COMMITTED

Section 15.7.2.3, “Consistent Nonlocking Reads”
Section 23.4.3.6, “Defining NDB Cluster Data Nodes”
Section 23.2.6.1, “Differences Between the NDB and InnoDB Storage Engines”
Section 18.3.2, “Group Replication Limitations”
Section 15.7.5.3, “How to Minimize and Handle Deadlocks”
Section 15.7.1, “InnoDB Locking”
Section 15.14, “InnoDB Startup Options and System Variables”
Section 23.2.7.3, “Limits Relating to Transaction Handling in NDB Cluster”
Section 15.7.3, “Locks Set by Different SQL Statements in InnoDB”
Section A.1, “MySQL 8.0 FAQ: General”
Section A.10, “MySQL 8.0 FAQ: NDB Cluster”
Section 23.2.6.3, “NDB and InnoDB Feature Usage Summary”
Section 8.5.2, “Optimizing InnoDB Transaction Management”
Section 13.3.7, “SET TRANSACTION Statement”
Section 5.4.4.2, “Setting The Binary Log Format”
Section 27.12.7.1, “The events_transactions_current Table”
Section 15.7.2.1, “Transaction Isolation Levels”
Section 1.3, “What Is New in MySQL 8.0”
Section 23.2.4, “What is New in NDB Cluster”

READ UNCOMMITTED

Section 15.7.2.3, “Consistent Nonlocking Reads”
Section 15.8.10.1.4, “Including Delete-marked Records in Persistent Statistics Calculations”
Section 15.20.2, “InnoDB memcached Architecture”
Section 15.14, “InnoDB Startup Options and System Variables”
Section 23.2.7.3, “Limits Relating to Transaction Handling in NDB Cluster”
Section 15.20.6.6, “Performing DML and DDL Statements on the Underlying InnoDB Table”
Section 13.3.7, “SET TRANSACTION Statement”
Section 5.4.4.2, “Setting The Binary Log Format”
Section 27.12.7.1, “The events_transactions_current Table”
Section 15.7.2.1, “Transaction Isolation Levels”

READ-COMMITTED

Section 5.1.7, “Server Command Options”
Section 13.3.7, “SET TRANSACTION Statement”

READ-UNCOMMITTED

Section 5.1.7, “Server Command Options”
Section 13.3.7, “SET TRANSACTION Statement”

REPEATABLE READ

Section 15.7.2.3, “Consistent Nonlocking Reads”
Section 15.20.6.4, “Controlling Transactional Behavior of the InnoDB memcached Plugin”
Section 18.3.2, “Group Replication Limitations”
Section 15.7.1, “InnoDB Locking”
Section 15.14, “InnoDB Startup Options and System Variables”
Section 23.2.7.3, “Limits Relating to Transaction Handling in NDB Cluster”
Section 5.4.4.3, “Mixed Binary Logging Format”
Section 4.5.4, “mysqldump — A Database Backup Program”
Section 4.5.6, “mysqlpump — A Database Backup Program”
Section 8.5.2, “Optimizing InnoDB Transaction Management”
Section 27.12.7, “Performance Schema Transaction Tables”
Section 13.3.7, “SET TRANSACTION Statement”
Section 13.3.1, “START TRANSACTION, COMMIT, and ROLLBACK Statements”
Section 27.12.7.1, “The events_transactions_current Table”
Section 15.7.2.1, “Transaction Isolation Levels”
Section 1.3, “What Is New in MySQL 8.0”
Section 13.3.8, “XA Transactions”

REPEATABLE-READ

Section 5.1.7, “Server Command Options”
Section 5.1.8, “Server System Variables”
Section 13.3.7, “SET TRANSACTION Statement”

S

[index top]

SERIALIZABLE

Section 18.3.2, “Group Replication Limitations”
Section 15.7.1, “InnoDB Locking”
Section 15.14, “InnoDB Startup Options and System Variables”
Section 23.2.7.3, “Limits Relating to Transaction Handling in NDB Cluster”
Section 15.7.3, “Locks Set by Different SQL Statements in InnoDB”
Section 5.4.4.3, “Mixed Binary Logging Format”
Section 27.12.7, “Performance Schema Transaction Tables”
Section 5.1.7, “Server Command Options”
Section 13.3.7, “SET TRANSACTION Statement”
Section 13.3.1, “START TRANSACTION, COMMIT, and ROLLBACK Statements”
Section 27.12.7.1, “The events_transactions_current Table”
Section 15.7.2.1, “Transaction Isolation Levels”
Section 13.3.8, “XA Transactions”

Read article
MySQL :: MySQL 8.0 Reference Manual :: System Variable Index

System Variable Index

A | B | C | D | E | F | G | H | I | J | K | L | M | N | O | P | Q | R | S | T | U | V | W | X

A

[index top]

activate_all_roles_on_login

Section 13.1.17, “CREATE PROCEDURE and CREATE FUNCTION Statements”
Section 17.3.3, “Replication Privilege Checks”
Section 5.1.8, “Server System Variables”
Section 13.7.1.11, “SET ROLE Statement”
Section 13.7.7.21, “SHOW GRANTS Statement”
Section 25.6, “Stored Object Access Control”
Section 6.2.10, “Using Roles”

admin_address

Section 5.1.12.2, “Administrative Connection Management”
Section 5.1.14, “Network Namespace Support”
Section 18.5.4.1.1, “Selecting addresses for distributed recovery endpoints”
Section 5.1.8, “Server System Variables”

admin_port

Section 5.1.12.2, “Administrative Connection Management”
Section 18.9, “Group Replication System Variables”
Section 18.5.4.1.1, “Selecting addresses for distributed recovery endpoints”
Section 5.1.8, “Server System Variables”

admin_ssl_ca

Section 5.1.8, “Server System Variables”

admin_ssl_capath

Section 5.1.8, “Server System Variables”

admin_ssl_cert

Section 5.1.7, “Server Command Options”
Section 5.1.8, “Server System Variables”

admin_ssl_cipher

Section 5.1.8, “Server System Variables”

admin_ssl_crl

Section 5.1.8, “Server System Variables”

admin_ssl_crlpath

Section 5.1.8, “Server System Variables”

admin_ssl_key

Section 5.1.7, “Server Command Options”
Section 5.1.8, “Server System Variables”

admin_tls_ciphersuites

Section 5.1.8, “Server System Variables”

admin_tls_version

Section 5.1.12.2, “Administrative Connection Management”
Section 6.3.2, “Encrypted Connection TLS Protocols and Ciphers”
Section 5.1.7, “Server Command Options”
Section 5.1.8, “Server System Variables”

audit_log_buffer_size

Section 6.4.5.11, “Audit Log Reference”
Section 6.4.5.5, “Configuring Audit Logging Characteristics”

audit_log_compression

Section 6.4.5.11, “Audit Log Reference”
Section 6.4.5.5, “Configuring Audit Logging Characteristics”

audit_log_connection_policy

Section 6.4.5.11, “Audit Log Reference”
Section 6.4.5.10, “Legacy Mode Audit Log Filtering”
Section 6.4.5.8, “Writing Audit Log Filter Definitions”

audit_log_current_session

Section 6.4.5.11, “Audit Log Reference”

audit_log_disable

Section 6.4.5.11, “Audit Log Reference”
Section 6.4.5.9, “Disabling Audit Logging”

audit_log_encryption

Section 6.4.5.11, “Audit Log Reference”
Section 6.4.5.5, “Configuring Audit Logging Characteristics”

audit_log_exclude_accounts

Section 6.4.5.11, “Audit Log Reference”
Section 6.4.5.10, “Legacy Mode Audit Log Filtering”
Section 6.4.5.8, “Writing Audit Log Filter Definitions”

audit_log_file

Section 6.4.5.4, “Audit Log File Formats”
Section 6.4.5.11, “Audit Log Reference”
Section 6.4.5.5, “Configuring Audit Logging Characteristics”
Section 2.5.6.2, “More Topics on Deploying MySQL Server with Docker”
Section 6.4.5, “MySQL Enterprise Audit”
Section 6.4.5.3, “MySQL Enterprise Audit Security Considerations”
Section 6.4.5.6, “Reading Audit Log Files”

audit_log_filter_id

Section 6.4.5.7, “Audit Log Filtering”
Section 6.4.5.11, “Audit Log Reference”
Section 6.4.5.8, “Writing Audit Log Filter Definitions”

audit_log_flush

Section 6.4.5.11, “Audit Log Reference”
Section 6.4.5.5, “Configuring Audit Logging Characteristics”

audit_log_format

Section 6.4.5.4, “Audit Log File Formats”
Section 6.4.5.11, “Audit Log Reference”
Section 6.4.5.5, “Configuring Audit Logging Characteristics”
Section 6.4.5, “MySQL Enterprise Audit”
Section 6.4.6, “The Audit Message Component”

audit_log_format_unix_timestamp

Section 6.4.5.4, “Audit Log File Formats”
Section 6.4.5.11, “Audit Log Reference”
Section 6.4.5.5, “Configuring Audit Logging Characteristics”

audit_log_include_accounts

Section 6.4.5.11, “Audit Log Reference”
Section 6.4.5.10, “Legacy Mode Audit Log Filtering”
Section 6.4.5.8, “Writing Audit Log Filter Definitions”

audit_log_max_size

Section 6.4.5.11, “Audit Log Reference”
Section 6.4.5.5, “Configuring Audit Logging Characteristics”

audit_log_password_history_keep_days

Section 6.4.5.11, “Audit Log Reference”
Section 6.4.5.5, “Configuring Audit Logging Characteristics”

audit_log_policy

Section 6.4.5.11, “Audit Log Reference”
Section 6.4.5.10, “Legacy Mode Audit Log Filtering”
Section 5.1.9, “Using System Variables”
Section 6.4.5.8, “Writing Audit Log Filter Definitions”

audit_log_prune_seconds

Section 6.4.5.11, “Audit Log Reference”
Section 6.4.5.5, “Configuring Audit Logging Characteristics”

audit_log_read_buffer_size

Section 6.4.5.11, “Audit Log Reference”
Section 6.4.5.6, “Reading Audit Log Files”

audit_log_rotate_on_size

Section 6.4.5.11, “Audit Log Reference”
Section 6.4.5.5, “Configuring Audit Logging Characteristics”

audit_log_statement_policy

Section 6.4.5.11, “Audit Log Reference”
Section 6.4.5.10, “Legacy Mode Audit Log Filtering”
Section 6.4.5.8, “Writing Audit Log Filter Definitions”

audit_log_strategy

Section 6.4.5.11, “Audit Log Reference”
Section 6.4.5.5, “Configuring Audit Logging Characteristics”

authentication_fido_rp_id

Section 6.4.1.11, “FIDO Pluggable Authentication”
Section 4.5.1.1, “mysql Client Options”
Section 6.4.1.13, “Pluggable Authentication System Variables”

authentication_kerberos_service_key_tab

Section 6.4.1.8, “Kerberos Pluggable Authentication”
Section 6.4.1.13, “Pluggable Authentication System Variables”

authentication_kerberos_service_principal

Section 6.4.1.8, “Kerberos Pluggable Authentication”
Section 6.4.1.13, “Pluggable Authentication System Variables”

authentication_ldap_sasl_auth_method_name

Section 6.4.1.7, “LDAP Pluggable Authentication”
Section 6.4.1.13, “Pluggable Authentication System Variables”

authentication_ldap_sasl_bind_base_dn

Section 6.4.1.7, “LDAP Pluggable Authentication”
Section 6.4.1.13, “Pluggable Authentication System Variables”

authentication_ldap_sasl_bind_root_dn

Section 6.4.1.7, “LDAP Pluggable Authentication”
Section 6.4.1.13, “Pluggable Authentication System Variables”

authentication_ldap_sasl_bind_root_pwd

Section 6.4.1.7, “LDAP Pluggable Authentication”
Section 6.4.1.13, “Pluggable Authentication System Variables”

authentication_ldap_sasl_ca_path

Section 6.4.1.7, “LDAP Pluggable Authentication”
Section 6.4.1.13, “Pluggable Authentication System Variables”

authentication_ldap_sasl_group_search_attr

Section 6.4.1.7, “LDAP Pluggable Authentication”
Section 6.4.1.13, “Pluggable Authentication System Variables”

authentication_ldap_sasl_group_search_filter

Section 6.4.1.13, “Pluggable Authentication System Variables”

authentication_ldap_sasl_init_pool_size

Section 6.4.1.13, “Pluggable Authentication System Variables”

authentication_ldap_sasl_log_status

Section 6.4.1.13, “Pluggable Authentication System Variables”

authentication_ldap_sasl_max_pool_size

Section 6.4.1.13, “Pluggable Authentication System Variables”

authentication_ldap_sasl_referral

Section 6.4.1.7, “LDAP Pluggable Authentication”
Section 6.4.1.13, “Pluggable Authentication System Variables”

authentication_ldap_sasl_server_host

Section 6.4.1.7, “LDAP Pluggable Authentication”
Section 6.4.1.13, “Pluggable Authentication System Variables”

authentication_ldap_sasl_server_port

Section 6.4.1.7, “LDAP Pluggable Authentication”
Section 6.4.1.13, “Pluggable Authentication System Variables”

authentication_ldap_sasl_tls

Section 6.4.1.7, “LDAP Pluggable Authentication”
Section 6.4.1.13, “Pluggable Authentication System Variables”

authentication_ldap_sasl_user_search_attr

Section 6.4.1.7, “LDAP Pluggable Authentication”
Section 6.4.1.13, “Pluggable Authentication System Variables”

authentication_ldap_simple_auth_method_name

Section 6.4.1.7, “LDAP Pluggable Authentication”
Section 6.4.1.13, “Pluggable Authentication System Variables”

authentication_ldap_simple_bind_base_dn

Section 6.4.1.13, “Pluggable Authentication System Variables”

authentication_ldap_simple_bind_root_dn

Section 6.4.1.13, “Pluggable Authentication System Variables”

authentication_ldap_simple_bind_root_pwd

Section 6.4.1.13, “Pluggable Authentication System Variables”

authentication_ldap_simple_ca_path

Section 6.4.1.7, “LDAP Pluggable Authentication”
Section 6.4.1.13, “Pluggable Authentication System Variables”

authentication_ldap_simple_group_search_attr

Section 6.4.1.7, “LDAP Pluggable Authentication”
Section 6.4.1.13, “Pluggable Authentication System Variables”

authentication_ldap_simple_group_search_filter

Section 6.4.1.13, “Pluggable Authentication System Variables”

authentication_ldap_simple_init_pool_size

Section 6.4.1.13, “Pluggable Authentication System Variables”

authentication_ldap_simple_log_status

Section 6.4.1.13, “Pluggable Authentication System Variables”

authentication_ldap_simple_max_pool_size

Section 6.4.1.13, “Pluggable Authentication System Variables”

authentication_ldap_simple_referral

Section 6.4.1.7, “LDAP Pluggable Authentication”
Section 6.4.1.13, “Pluggable Authentication System Variables”

authentication_ldap_simple_server_host

Section 6.4.1.13, “Pluggable Authentication System Variables”

authentication_ldap_simple_server_port

Section 6.4.1.13, “Pluggable Authentication System Variables”

authentication_ldap_simple_tls

Section 6.4.1.7, “LDAP Pluggable Authentication”
Section 6.4.1.13, “Pluggable Authentication System Variables”

authentication_ldap_simple_user_search_attr

Section 6.4.1.7, “LDAP Pluggable Authentication”
Section 6.4.1.13, “Pluggable Authentication System Variables”

authentication_policy

Section 13.7.1.1, “ALTER USER Statement”
Section 13.7.1.3, “CREATE USER Statement”
Section 6.4.1.11, “FIDO Pluggable Authentication”
Section 6.2.18, “Multifactor Authentication”
Section 6.2.17, “Pluggable Authentication”
Section 6.2.2, “Privileges Provided by MySQL”
Section 5.1.8, “Server System Variables”
Section 1.3, “What Is New in MySQL 8.0”

authentication_windows_log_level

Section 5.1.8, “Server System Variables”
Section 6.4.1.6, “Windows Pluggable Authentication”

authentication_windows_use_principal_name

Section 5.1.8, “Server System Variables”
Section 6.4.1.6, “Windows Pluggable Authentication”

auto_generate_certs

Section 6.3.3.1, “Creating SSL and RSA Certificates and Keys using MySQL”
Section 5.1.8, “Server System Variables”

auto_increment_increment

Section 15.6.1.6, “AUTO_INCREMENT Handling in InnoDB”
Section 18.10, “Frequently Asked Questions”
Section 18.9, “Group Replication System Variables”
Section 5.4.4.3, “Mixed Binary Logging Format”
Section A.1, “MySQL 8.0 FAQ: General”
Section 23.5.13, “ndb_import — Import CSV Data Into NDB”
Section 17.5.1.39, “Replication and Variables”
Section 17.1.6.2, “Replication Source Options and Variables”
Section 3.6.9, “Using AUTO_INCREMENT”

auto_increment_offset

Section 15.6.1.6, “AUTO_INCREMENT Handling in InnoDB”
Section 18.10, “Frequently Asked Questions”
Section 18.9, “Group Replication System Variables”
Section 5.4.4.3, “Mixed Binary Logging Format”
Section A.1, “MySQL 8.0 FAQ: General”
Section 23.5.13, “ndb_import — Import CSV Data Into NDB”
Section 17.5.1.39, “Replication and Variables”
Section 17.1.6.2, “Replication Source Options and Variables”
Section 3.6.9, “Using AUTO_INCREMENT”

AUTOCOMMIT

Section 17.5.1.35, “Replication and Transactions”

autocommit

Section 13.1.10, “ALTER TABLESPACE Statement”
Section 15.7.2.2, “autocommit, Commit, and Rollback”
Section 15.6.1.5, “Converting Tables from MyISAM to InnoDB”
Section 15.7.5.2, “Deadlock Detection”
Section 13.2.2, “DELETE Statement”
Section 15.6.3.3, “General Tablespaces”
Section 15.2, “InnoDB and the ACID Model”
Section 15.7, “InnoDB Locking and Transaction Model”
Section 15.14, “InnoDB Startup Options and System Variables”
Section 13.3.6, “LOCK TABLES and UNLOCK TABLES Statements”
Section 15.7.2.4, “Locking Reads”
Section 15.7.3, “Locks Set by Different SQL Statements in InnoDB”
Section 15.6.1.4, “Moving or Copying InnoDB Tables”
Section 23.4.3.9.2, “NDB Cluster System Variables”
Section 8.5.3, “Optimizing InnoDB Read-Only Transactions”
Section 27.12.7, “Performance Schema Transaction Tables”
Section 15.8.9, “Purge Configuration”
Section 17.5.1.31, “Replication and Temporary Tables”
Section 17.5.1.35, “Replication and Transactions”
Section 17.1.3.7, “Restrictions on Replication with GTIDs”
Section 5.1.8, “Server System Variables”
Section 13.3.1, “START TRANSACTION, COMMIT, and ROLLBACK Statements”
Section 26.4.28, “The INFORMATION_SCHEMA INNODB_TRX Table”
Section 5.6.3.3, “Thread Pool Operation”
Section 15.7.2.1, “Transaction Isolation Levels”

automatic_sp_privileges

Section 13.1.7, “ALTER PROCEDURE Statement”
Section 13.1.17, “CREATE PROCEDURE and CREATE FUNCTION Statements”
Section 5.1.7, “Server Command Options”
Section 5.1.8, “Server System Variables”
Section 25.2.2, “Stored Routines and MySQL Privileges”

avoid_temporal_upgrade

Section 13.7.3.2, “CHECK TABLE Statement”
Section 13.7.3.5, “REPAIR TABLE Statement”
Section 5.1.8, “Server System Variables”

B

[index top]

back_log

Section 2.11.4, “Changes in MySQL 8.0”
Section 5.1.8, “Server System Variables”

basedir

Section 13.7.4.4, “INSTALL PLUGIN Statement”
Section 2.4.3, “Installing and Using the MySQL Launch Daemon”
Section 5.1.7, “Server Command Options”
Section 5.1.8, “Server System Variables”

big_tables

Section 8.4.4, “Internal Temporary Table Use in MySQL”
Section 5.1.8, “Server System Variables”

bind_address

Section B.3.2.2, “Can't connect to [local] MySQL server”
Section 18.6.1, “Communication Stack for Connection Security Management”
Section 5.1.13.2, “Configuring the MySQL Server to Permit IPv6 Connections”
Section 5.1.13.4, “Connecting Using IPv6 Nonlocal Host Addresses”
Section 5.1.13.3, “Connecting Using the IPv6 Local Host Address”
Section 18.6.4, “Group Replication IP Address Permissions”
Section 18.9, “Group Replication System Variables”
Section 5.1.13, “IPv6 Support”
Section 4.3.4, “mysqld_multi — Manage Multiple MySQL Servers”
Section 5.1.14, “Network Namespace Support”
Section 5.1.9.4, “Nonpersistible and Persist-Restricted System Variables”
Section 5.1.13.5, “Obtaining an IPv6 Address from a Broker”
Section 5.8, “Running Multiple MySQL Instances on One Machine”
Section 18.5.4.1.1, “Selecting addresses for distributed recovery endpoints”
Section 5.1.8, “Server System Variables”
Section 18.5.5, “Support For IPv6 And For Mixed IPv6 And IPv4 Groups”
Section 23.6.16.50, “The ndbinfo processes Table”
Section 6.2.22, “Troubleshooting Problems Connecting to MySQL”
Section 20.5.6.2, “X Plugin Options and System Variables”

binlog

Section 4.6.9, “mysqlbinlog — Utility for Processing Binary Log Files”

binlog_cache_size

Section 17.1.6.4, “Binary Logging Options and Variables”
Section 5.1.10, “Server Status Variables”
Section 5.4.4, “The Binary Log”

binlog_checksum

Section 17.1.6.4, “Binary Logging Options and Variables”
Section 18.3.2, “Group Replication Limitations”
Section 18.3.1, “Group Replication Requirements”
MySQL Glossary
Section 17.5.1.35, “Replication and Transactions”
Section 5.4.4, “The Binary Log”

binlog_direct_non_transactional_updates

Section 17.1.6.4, “Binary Logging Options and Variables”
Section 17.5.1.35, “Replication and Transactions”

binlog_encryption

Section 13.1.5, “ALTER INSTANCE Statement”
Section 17.3.2.3, “Binary Log Master Key Rotation”
Section 17.1.6.4, “Binary Logging Options and Variables”
Section 17.3.2, “Encrypting Binary Log Files and Relay Log Files”
Section 6.1.3, “Making MySQL Secure Against Attackers”
Section 4.6.9, “mysqlbinlog — Utility for Processing Binary Log Files”
Section 6.2.2, “Privileges Provided by MySQL”
Section 17.3, “Replication Security”
Section 13.7.7.1, “SHOW BINARY LOGS Statement”
Section 5.4.4, “The Binary Log”

binlog_error_action

Section 17.1.6.4, “Binary Logging Options and Variables”
Section 17.1.6.5, “Global Transaction ID System Variables”
Section 17.1.3.1, “GTID Format and Storage”
Section 5.4.4, “The Binary Log”

binlog_expire_logs_auto_purge

Section 17.1.6.4, “Binary Logging Options and Variables”
Section 1.3, “What Is New in MySQL 8.0”

binlog_expire_logs_seconds

Section 17.1.6.4, “Binary Logging Options and Variables”
Section 17.1.3.3, “GTID Auto-Positioning”
Section 13.4.1.1, “PURGE BINARY LOGS Statement”
Section 5.4.6, “Server Log Maintenance”
Section 1.3, “What Is New in MySQL 8.0”

binlog_format

Section 17.1.6.4, “Binary Logging Options and Variables”
Section 11.6, “Data Type Default Values”
Section 12.7, “Date and Time Functions”
Section 17.2.1.3, “Determination of Safe and Unsafe Statements in Binary Logging”
Section 17.2.5.1, “Evaluation of Database-Level Replication and Binary Logging Options”
Section 17.2.5.2, “Evaluation of Table-Level Replication Options”
Section 6.2.3, “Grant Tables”
Section 18.3.1, “Group Replication Requirements”
Section 17.1.3.2, “GTID Life Cycle”
Section 12.16, “Information Functions”
Section 17.2.5.3, “Interactions Between Replication Filtering Options”
Section 13.2.9, “LOAD DATA Statement”
Section 12.15, “Locking Functions”
Section 5.4.4.4, “Logging Format for Changes to mysql Database Tables”
Section 12.6.2, “Mathematical Functions”
Section 12.24, “Miscellaneous Functions”
Section 5.4.4.3, “Mixed Binary Logging Format”
Section A.14, “MySQL 8.0 FAQ: Replication”
Section 4.6.9, “mysqlbinlog — Utility for Processing Binary Log Files”
Section 24.3.5, “Obtaining Information About Partitions”
Section 17.3.3.1, “Privileges For The Replication PRIVILEGE_CHECKS_USER Account”
Section 6.2.2, “Privileges Provided by MySQL”
Section 17.1.6.3, “Replica Server Options and Variables”
Section 17.5.1.2, “Replication and BLACKHOLE Tables”
Section 17.5.1.19, “Replication and LOAD DATA”
Section 17.5.1.21, “Replication and MEMORY Tables”
Section 17.5.1.31, “Replication and Temporary Tables”
Section 17.5.1.35, “Replication and Transactions”
Section 17.2.1, “Replication Formats”
Section 17.5.1.22, “Replication of the mysql System Schema”
Section 17.3.3, “Replication Privilege Checks”
Section 17.1.3.7, “Restrictions on Replication with GTIDs”
Section 13.3.8.3, “Restrictions on XA Transactions”
Section 17.3.2.1, “Scope of Binary Log Encryption”
Section 5.4.4.2, “Setting The Binary Log Format”
Section 25.7, “Stored Program Binary Logging”
Section 5.1.9.1, “System Variable Privileges”
Section 16.6, “The BLACKHOLE Storage Engine”
Section 5.4.3, “The General Query Log”
Section 15.20.7, “The InnoDB memcached Plugin and Replication”
Section 5.4.5, “The Slow Query Log”
Section 15.7.2.1, “Transaction Isolation Levels”
Section 17.5.3, “Upgrading a Replication Topology”
Section 17.2.1.2, “Usage of Row-Based Logging and Replication”
Section 1.3, “What Is New in MySQL 8.0”

binlog_group_commit_sync_delay

Section 17.1.6.4, “Binary Logging Options and Variables”

binlog_group_commit_sync_no_delay_count

Section 17.1.6.4, “Binary Logging Options and Variables”

binlog_gtid_simple_recovery

Section 17.1.6.5, “Global Transaction ID System Variables”
Section 17.1.3.2, “GTID Life Cycle”

binlog_max_flush_queue_time

Section 17.1.6.4, “Binary Logging Options and Variables”

binlog_order_commits

Section 17.1.6.4, “Binary Logging Options and Variables”

binlog_rotate_encryption_master_key_at_startup

Section 17.3.2.3, “Binary Log Master Key Rotation”
Section 17.1.6.4, “Binary Logging Options and Variables”
Section 6.2.2, “Privileges Provided by MySQL”

binlog_row_event_max_size

Section 17.1.6.4, “Binary Logging Options and Variables”
Section 5.4.4.2, “Setting The Binary Log Format”

binlog_row_image

Section 17.2.1.1, “Advantages and Disadvantages of Statement-Based and Row-Based Replication”
Section 17.1.6.4, “Binary Logging Options and Variables”
Section 13.1.20.10, “Invisible Columns”
Section 8.5.8, “Optimizing InnoDB Disk I/O”

binlog_row_metadata

Section 17.1.6.4, “Binary Logging Options and Variables”

binlog_row_value_options

Section 17.1.6.4, “Binary Logging Options and Variables”
Section 17.5.1.17, “Replication of JSON Documents”
Section 11.5, “The JSON Data Type”
Section 1.3, “What Is New in MySQL 8.0”

binlog_rows_query_log_events

Section 17.2.1.1, “Advantages and Disadvantages of Statement-Based and Row-Based Replication”
Section 17.4.3, “Monitoring Row-based Replication”
Section 4.6.9.2, “mysqlbinlog Row Event Display”
Section 4.6.9, “mysqlbinlog — Utility for Processing Binary Log Files”

binlog_stmt_cache_size

Section 17.1.6.4, “Binary Logging Options and Variables”
Section 5.1.10, “Server Status Variables”

binlog_transaction_compression

Section 5.4.4.5, “Binary Log Transaction Compression”
Section 17.1.6.4, “Binary Logging Options and Variables”
Section 13.4.2.1, “CHANGE MASTER TO Statement”
Section 13.4.2.3, “CHANGE REPLICATION SOURCE TO Statement”
Section 5.4.4.5.2, “Combining Compressed and Uncompressed Transaction Payloads”
Section 18.7.4, “Message Compression”
Section 4.6.9, “mysqlbinlog — Utility for Processing Binary Log Files”
Section 17.1.6.3, “Replica Server Options and Variables”
Section 27.12.11.16, “The binary_log_transaction_compression_stats Table”
Section 23.2.4, “What is New in NDB Cluster”

binlog_transaction_compression_level_zstd

Section 5.4.4.5, “Binary Log Transaction Compression”
Section 17.1.6.4, “Binary Logging Options and Variables”
Section 23.2.4, “What is New in NDB Cluster”

binlog_transaction_dependency_history_size

Section 17.1.6.4, “Binary Logging Options and Variables”
Section 8.12.3.1, “How MySQL Uses Memory”

binlog_transaction_dependency_tracking

Section 17.1.6.4, “Binary Logging Options and Variables”
Section 18.3.1, “Group Replication Requirements”
Section 17.1.6.3, “Replica Server Options and Variables”

block_encryption_mode

Section 12.14, “Encryption and Compression Functions”
Section 5.1.8, “Server System Variables”

build_id

Section 2.9.7, “MySQL Source-Configuration Options”
Section 5.1.8, “Server System Variables”
Section 1.3, “What Is New in MySQL 8.0”

bulk_insert_buffer_size

Section 16.2.1, “MyISAM Startup Options”
Section 8.2.5.1, “Optimizing INSERT Statements”
Section 5.1.8, “Server System Variables”

C

[index top]

caching_sha

Section 6.4.1.2, “Caching SHA-2 Pluggable Authentication”
Section 6.3.3.1, “Creating SSL and RSA Certificates and Keys using MySQL”
Section 5.1.10, “Server Status Variables”
Section 5.1.8, “Server System Variables”

character_set_client

Section 10.15, “Character Set Configuration”
Section 10.4, “Connection Character Sets and Collations”
Section 13.2.9, “LOAD DATA Statement”
Section 5.4.4.3, “Mixed Binary Logging Format”
Section A.11, “MySQL 8.0 FAQ: MySQL Chinese, Japanese, and Korean Character Sets”
Section 9.6, “Query Attributes”
Section 17.5.1.39, “Replication and Variables”
Section 5.1.8, “Server System Variables”
Section 13.7.6.2, “SET CHARACTER SET Statement”
Section 13.7.6.3, “SET NAMES Statement”
Section 13.7.7.7, “SHOW CREATE EVENT Statement”
Section 13.7.7.9, “SHOW CREATE PROCEDURE Statement”
Section 13.7.7.11, “SHOW CREATE TRIGGER Statement”
Section 13.7.7.13, “SHOW CREATE VIEW Statement”
Section 13.7.7.18, “SHOW EVENTS Statement”
Section 13.7.7.28, “SHOW PROCEDURE STATUS Statement”
Section 13.7.7.40, “SHOW TRIGGERS Statement”
Section 5.4.4, “The Binary Log”
Section 26.3.14, “The INFORMATION_SCHEMA EVENTS Table”
Section 26.3.30, “The INFORMATION_SCHEMA ROUTINES Table”
Section 26.3.45, “The INFORMATION_SCHEMA TRIGGERS Table”
Section 26.3.48, “The INFORMATION_SCHEMA VIEWS Table”
Section 5.6.4.2, “Using the Rewriter Query Rewrite Plugin”

character_set_connection

Section 12.11, “Cast Functions and Operators”
Section 12.8.3, “Character Set and Collation of Function Results”
Section 10.3.8, “Character Set Introducers”
Section 10.2.1, “Character Set Repertoire”
Section 10.3.6, “Character String Literal Character Set and Collation”
Section 10.8.4, “Collation Coercibility in Expressions”
Section 10.4, “Connection Character Sets and Collations”
Section 12.7, “Date and Time Functions”
Section 12.14, “Encryption and Compression Functions”
Section 5.4.4.3, “Mixed Binary Logging Format”
Section A.11, “MySQL 8.0 FAQ: MySQL Chinese, Japanese, and Korean Character Sets”
Section 10.16, “MySQL Server Locale Support”
Section 17.5.1.39, “Replication and Variables”
Section 5.1.8, “Server System Variables”
Section 13.7.6.2, “SET CHARACTER SET Statement”
Section 13.7.6.3, “SET NAMES Statement”
Section 9.1.1, “String Literals”
Section 12.3, “Type Conversion in Expression Evaluation”

character_set_database

Section 13.1.9, “ALTER TABLE Statement”
Section 2.11.4, “Changes in MySQL 8.0”
Section 10.4, “Connection Character Sets and Collations”
Section 13.1.17, “CREATE PROCEDURE and CREATE FUNCTION Statements”
Section 10.3.3, “Database Character Set and Collation”
Section 13.2.9, “LOAD DATA Statement”
Section 5.4.4.3, “Mixed Binary Logging Format”
Section 17.5.1.39, “Replication and Variables”
Section 5.1.8, “Server System Variables”
Section 13.7.6.2, “SET CHARACTER SET Statement”
Section 23.2.4, “What is New in NDB Cluster”

character_set_filesystem

Section 13.2.9, “LOAD DATA Statement”
Section 13.2.13.1, “SELECT ... INTO Statement”
Section 5.1.8, “Server System Variables”
Section 12.8, “String Functions and Operators”

character_set_results

Section 10.4, “Connection Character Sets and Collations”
Section 10.6, “Error Message Character Set”
Section A.11, “MySQL 8.0 FAQ: MySQL Chinese, Japanese, and Korean Character Sets”
Section 5.1.8, “Server System Variables”
Section 13.7.6.2, “SET CHARACTER SET Statement”
Section 13.7.6.3, “SET NAMES Statement”
Section 10.2.2, “UTF-8 for Metadata”

character_set_server

Section 2.11.4, “Changes in MySQL 8.0”
Section 10.15, “Character Set Configuration”
Section 10.4, “Connection Character Sets and Collations”
Section 10.3.3, “Database Character Set and Collation”
Section 12.10.4, “Full-Text Stopwords”
Section 5.4.4.3, “Mixed Binary Logging Format”
Section 17.5.1.3, “Replication and Character Sets”
Section 17.5.1.39, “Replication and Variables”
Section 10.3.2, “Server Character Set and Collation”
Section 5.1.8, “Server System Variables”

character_set_system

Section 10.15, “Character Set Configuration”
Section 5.1.8, “Server System Variables”
Section 10.2.2, “UTF-8 for Metadata”

character_sets_dir

Section 10.14.3, “Adding a Simple Collation to an 8-Bit Character Set”
Section 10.14.4.1, “Defining a UCA Collation Using LDML Syntax”
Section 5.1.8, “Server System Variables”

check_proxy_users

Section 6.2.19, “Proxy Users”
Section 5.1.8, “Server System Variables”

clone_autotune_concurrency

Section 5.6.7.13, “Clone System Variables”
Section 5.6.7.10, “Monitoring Cloning Operations”

clone_block_ddl

Section 2.11.4, “Changes in MySQL 8.0”
Section 5.6.7.14, “Clone Plugin Limitations”
Section 5.6.7.13, “Clone System Variables”
Section 5.6.7.4, “Cloning and Concurrent DDL”
Section 5.6.7.9, “Remote Cloning Operation Failure Handling”
Section 1.3, “What Is New in MySQL 8.0”

clone_buffer_size

Section 5.6.7.13, “Clone System Variables”

clone_ddl_timeout

Section 5.6.7.13, “Clone System Variables”
Section 5.6.7.4, “Cloning and Concurrent DDL”
Section 5.6.7.9, “Remote Cloning Operation Failure Handling”

clone_delay_after_data_drop

Section 5.6.7.13, “Clone System Variables”
Section 1.3, “What Is New in MySQL 8.0”

clone_donor_timeout_after_network_failure

Section 5.6.7.13, “Clone System Variables”
Section 5.6.7.9, “Remote Cloning Operation Failure Handling”

clone_enable_compression

Section 5.6.7.13, “Clone System Variables”
Section 18.5.4.1.2, “Compression for Distributed Recovery”
Section 18.9, “Group Replication System Variables”
Section 18.5.4.2.1, “Prerequisites for Cloning”

clone_max_concurrency

Section 5.6.7.13, “Clone System Variables”
Section 5.6.7.10, “Monitoring Cloning Operations”

clone_max_data_bandwidth

Section 5.6.7.13, “Clone System Variables”
Section 27.12.19.2, “The clone_progress Table”

clone_max_network_bandwidth

Section 5.6.7.13, “Clone System Variables”

clone_ssl_ca

Section 5.6.7.13, “Clone System Variables”
Section 5.6.7.3, “Cloning Remote Data”
Section 18.9, “Group Replication System Variables”
Section 18.5.4.2.1, “Prerequisites for Cloning”
Section 18.6.3.2, “Secure Socket Layer (SSL) Connections for Distributed Recovery”
Section 18.5.4.1.4, “SSL and Authentication for Distributed Recovery”

clone_ssl_cert

Section 5.6.7.13, “Clone System Variables”
Section 5.6.7.3, “Cloning Remote Data”
Section 18.9, “Group Replication System Variables”
Section 18.5.4.2.1, “Prerequisites for Cloning”
Section 18.6.3.2, “Secure Socket Layer (SSL) Connections for Distributed Recovery”
Section 18.5.4.1.4, “SSL and Authentication for Distributed Recovery”

clone_ssl_key

Section 5.6.7.13, “Clone System Variables”
Section 5.6.7.3, “Cloning Remote Data”
Section 18.9, “Group Replication System Variables”
Section 18.5.4.2.1, “Prerequisites for Cloning”
Section 18.5.4.1.4, “SSL and Authentication for Distributed Recovery”

clone_valid_donor_list

Section 5.6.7.13, “Clone System Variables”
Section 5.6.7.3, “Cloning Remote Data”
Section 18.5.4.2.1, “Prerequisites for Cloning”

collation_connection

Section 12.11, “Cast Functions and Operators”
Section 12.8.3, “Character Set and Collation of Function Results”
Section 10.3.8, “Character Set Introducers”
Section 10.3.6, “Character String Literal Character Set and Collation”
Section 10.8.4, “Collation Coercibility in Expressions”
Section 10.4, “Connection Character Sets and Collations”
Section 12.7, “Date and Time Functions”
Section 12.14, “Encryption and Compression Functions”
Section 5.4.4.3, “Mixed Binary Logging Format”
Section 13.5.1, “PREPARE Statement”
Section 17.5.1.39, “Replication and Variables”
Section 5.1.8, “Server System Variables”
Section 13.7.6.3, “SET NAMES Statement”
Section 13.7.7.7, “SHOW CREATE EVENT Statement”
Section 13.7.7.9, “SHOW CREATE PROCEDURE Statement”
Section 13.7.7.11, “SHOW CREATE TRIGGER Statement”
Section 13.7.7.13, “SHOW CREATE VIEW Statement”
Section 13.7.7.18, “SHOW EVENTS Statement”
Section 13.7.7.28, “SHOW PROCEDURE STATUS Statement”
Section 13.7.7.40, “SHOW TRIGGERS Statement”
Section 5.4.4, “The Binary Log”
Section 26.3.14, “The INFORMATION_SCHEMA EVENTS Table”
Section 26.3.30, “The INFORMATION_SCHEMA ROUTINES Table”
Section 26.3.45, “The INFORMATION_SCHEMA TRIGGERS Table”
Section 26.3.48, “The INFORMATION_SCHEMA VIEWS Table”
Section 12.3, “Type Conversion in Expression Evaluation”

collation_database

Section 2.11.4, “Changes in MySQL 8.0”
Section 10.4, “Connection Character Sets and Collations”
Section 13.1.17, “CREATE PROCEDURE and CREATE FUNCTION Statements”
Section 10.3.3, “Database Character Set and Collation”
Section 5.4.4.3, “Mixed Binary Logging Format”
Section 17.5.1.39, “Replication and Variables”
Section 5.1.8, “Server System Variables”
Section 5.4.4, “The Binary Log”
Section 23.2.4, “What is New in NDB Cluster”

collation_server

Section 2.11.4, “Changes in MySQL 8.0”
Section 10.4, “Connection Character Sets and Collations”
Section 10.3.3, “Database Character Set and Collation”
Section 12.10.4, “Full-Text Stopwords”
Section 5.4.4.3, “Mixed Binary Logging Format”
Section 17.5.1.39, “Replication and Variables”
Section 10.3.2, “Server Character Set and Collation”
Section 5.1.8, “Server System Variables”
Section 5.4.4, “The Binary Log”

completion_type

Section 5.1.8, “Server System Variables”
Section 13.3.1, “START TRANSACTION, COMMIT, and ROLLBACK Statements”

concurrent_insert

Section 8.11.3, “Concurrent Inserts”
Section 8.11.1, “Internal Locking Methods”
Section 8.6.1, “Optimizing MyISAM Queries”
Section 5.1.7, “Server Command Options”
Section 5.1.8, “Server System Variables”

connect_timeout

Section B.3.2.9, “Communication Errors and Aborted Connections”
Section B.3.2.3, “Lost connection to MySQL server”
Section 5.1.8, “Server System Variables”
Section 20.5.6.2, “X Plugin Options and System Variables”

connection_control_failed_connections_threshold

Section 6.4.2.1, “Connection-Control Plugin Installation”
Section 6.4.2.2, “Connection-Control System and Status Variables”
Section 26.6.2, “The INFORMATION_SCHEMA CONNECTION_CONTROL_FAILED_LOGIN_ATTEMPTS Table”

connection_control_max_connection_delay

Section 6.4.2.1, “Connection-Control Plugin Installation”
Section 6.4.2.2, “Connection-Control System and Status Variables”

connection_control_min_connection_delay

Section 6.4.2.1, “Connection-Control Plugin Installation”
Section 6.4.2.2, “Connection-Control System and Status Variables”

connection_memory_chunk_size

Section 5.1.10, “Server Status Variables”
Section 5.1.8, “Server System Variables”
Section 1.3, “What Is New in MySQL 8.0”

connection_memory_limit

Section 5.1.8, “Server System Variables”
Section 1.3, “What Is New in MySQL 8.0”

core_file

Section 15.8.3.7, “Excluding Buffer Pool Pages from Core Files”
Section 15.14, “InnoDB Startup Options and System Variables”
Section 5.1.8, “Server System Variables”
Section 1.3, “What Is New in MySQL 8.0”

create_admin_listener_thread

Section 5.1.12.2, “Administrative Connection Management”
Section 5.1.8, “Server System Variables”

cte_max_recursion_depth

Section 5.1.8, “Server System Variables”
Section 13.2.20, “WITH (Common Table Expressions)”

D

[index top]

daemon_memcached_enable_binlog

Section 15.14, “InnoDB Startup Options and System Variables”

daemon_memcached_engine_lib_name

Section 15.14, “InnoDB Startup Options and System Variables”
Section 15.20.3, “Setting Up the InnoDB memcached Plugin”

daemon_memcached_engine_lib_path

Section 15.14, “InnoDB Startup Options and System Variables”
Section 15.20.3, “Setting Up the InnoDB memcached Plugin”

daemon_memcached_option

Section 15.20.2, “InnoDB memcached Architecture”
Section 15.14, “InnoDB Startup Options and System Variables”
Section 15.20.5, “Security Considerations for the InnoDB memcached Plugin”
Section 15.20.3, “Setting Up the InnoDB memcached Plugin”
Section 15.20.9, “Troubleshooting the InnoDB memcached Plugin”

daemon_memcached_r_batch_size

Section 15.20.2, “InnoDB memcached Architecture”
Section 15.14, “InnoDB Startup Options and System Variables”
Section 15.20.6.6, “Performing DML and DDL Statements on the Underlying InnoDB Table”
Section 15.20.3, “Setting Up the InnoDB memcached Plugin”
Section 15.20.7, “The InnoDB memcached Plugin and Replication”
Section 15.20.6.3, “Tuning InnoDB memcached Plugin Performance”

daemon_memcached_w_batch_size

Section 15.20.6.4, “Controlling Transactional Behavior of the InnoDB memcached Plugin”
Section 15.20.2, “InnoDB memcached Architecture”
Section 15.14, “InnoDB Startup Options and System Variables”
Section 15.20.6.6, “Performing DML and DDL Statements on the Underlying InnoDB Table”
Section 15.20.3, “Setting Up the InnoDB memcached Plugin”
Section 15.20.7, “The InnoDB memcached Plugin and Replication”
Section 15.20.6.3, “Tuning InnoDB memcached Plugin Performance”

datadir

Section 2.11.4, “Changes in MySQL 8.0”
Section 15.6.1.2, “Creating Tables Externally”
Section 15.6.3.3, “General Tablespaces”
Section 15.18.2, “InnoDB Recovery”
Section 15.8.1, “InnoDB Startup Configuration”
Section 15.14, “InnoDB Startup Options and System Variables”
Section 2.4.3, “Installing and Using the MySQL Launch Daemon”
Section 2.3, “Installing MySQL on Microsoft Windows”
Section 15.6.3.6, “Moving Tablespace Files While the Server is Offline”
MySQL Glossary
Section 15.6.5, “Redo Log”
Section 5.1.7, “Server Command Options”
Section 5.1.8, “Server System Variables”
Section 26.3.15, “The INFORMATION_SCHEMA FILES Table”
Section 13.1.37, “TRUNCATE TABLE Statement”
Section 15.6.3.4, “Undo Tablespaces”
Section 1.3, “What Is New in MySQL 8.0”

debug

Section 5.1.8, “Server System Variables”
Section 5.9.4, “The DBUG Package”

debug_sync

Section 27.12.14.2, “Performance Schema variables_info Table”
Section 5.1.8, “Server System Variables”

default

Section 16.1, “Setting the Storage Engine”
Section 15.1.4, “Testing and Benchmarking with InnoDB”

default_authentication_plugin

Section 6.4.1.2, “Caching SHA-2 Pluggable Authentication”
Section 2.11.4, “Changes in MySQL 8.0”
Section 2.4.2, “Installing MySQL on macOS Using Native Packages”
Section 6.2.17, “Pluggable Authentication”
Section 5.1.8, “Server System Variables”
Section 6.4.1.3, “SHA-256 Pluggable Authentication”
Section 1.3, “What Is New in MySQL 8.0”

default_collation_for_utf

Section 5.1.8, “Server System Variables”

default_password_lifetime

Section 13.7.1.1, “ALTER USER Statement”
Section 13.7.1.3, “CREATE USER Statement”
Section 6.2.3, “Grant Tables”
Section 6.2.15, “Password Management”
Section 5.1.8, “Server System Variables”

default_storage_engine

Section 13.1.16, “CREATE LOGFILE GROUP Statement”
Section 13.1.20, “CREATE TABLE Statement”
Section 13.1.21, “CREATE TABLESPACE Statement”
Section 13.1.33, “DROP TABLESPACE Statement”
Section 15.6.3.3, “General Tablespaces”
Section 5.6.1, “Installing and Uninstalling Plugins”
Section 24.2.2, “LIST Partitioning”
Section 24.1, “Overview of Partitioning in MySQL”
Section 17.5.1.39, “Replication and Variables”
Section 5.1.8, “Server System Variables”
Section 16.1, “Setting the Storage Engine”
Section 17.4.4, “Using Replication with Different Source and Replica Storage Engines”

default_table_encryption

Section 13.1.2, “ALTER DATABASE Statement”
Section 13.1.10, “ALTER TABLESPACE Statement”
Section 13.1.12, “CREATE DATABASE Statement”
Section 13.1.21, “CREATE TABLESPACE Statement”
Section 18.3.1, “Group Replication Requirements”
Section 18.9, “Group Replication System Variables”
Section 15.13, “InnoDB Data-at-Rest Encryption”
Section 17.3.3.1, “Privileges For The Replication PRIVILEGE_CHECKS_USER Account”
Section 5.1.8, “Server System Variables”
Section 5.1.9.1, “System Variable Privileges”
Section 1.3, “What Is New in MySQL 8.0”

default_tmp_storage_engine

Section 5.6.1, “Installing and Uninstalling Plugins”
Section 5.1.8, “Server System Variables”
Section 16.1, “Setting the Storage Engine”

default_week_format

Section 12.7, “Date and Time Functions”
Section 24.6.3, “Partitioning Limitations Relating to Functions”
Section 5.1.8, “Server System Variables”

delay_key_write

Section 13.1.20, “CREATE TABLE Statement”
Section 8.11.5, “External Locking”
Section A.14, “MySQL 8.0 FAQ: Replication”
Section 5.1.7, “Server Command Options”
Section 5.1.8, “Server System Variables”
Section B.3.3.3, “What to Do If MySQL Keeps Crashing”

delayed_insert_limit

Section 5.1.8, “Server System Variables”

delayed_insert_timeout

Section 5.1.8, “Server System Variables”

delayed_queue_size

Section 5.1.8, “Server System Variables”

disabled_storage_engines

Section 18.2.1.2, “Configuring an Instance for Group Replication”
Section 18.3.1, “Group Replication Requirements”
Section A.2, “MySQL 8.0 FAQ: Storage Engines”
Section 4.4.5, “mysql_upgrade — Check and Upgrade MySQL Tables”
Section 5.1.7, “Server Command Options”
Section 5.1.8, “Server System Variables”

disconnect_on_expired_password

Section 6.2.16, “Server Handling of Expired Passwords”
Section 5.1.8, “Server System Variables”

div_precision_increment

Section 12.6.1, “Arithmetic Operators”
Section 5.1.8, “Server System Variables”

dragnet

Section 5.5.3, “Error Log Components”
Section 5.5, “MySQL Components”
Section 5.4.2.6, “Rule-Based Error Log Filtering (log_filter_dragnet)”
Section 5.1.10, “Server Status Variables”
Section 5.1.8, “Server System Variables”
Section 5.4.2.4, “Types of Error Log Filtering”
Section 5.1.9, “Using System Variables”

E

[index top]

end_markers_in_json

Section 5.1.8, “Server System Variables”

enforce_gtid_consistency

Section 17.1.4.3, “Disabling GTID Transactions Online”
Section 17.1.6.5, “Global Transaction ID System Variables”
Section 18.3.1, “Group Replication Requirements”
Section 18.4.1, “GTIDs and Group Replication”
Section 17.5.1.31, “Replication and Temporary Tables”
Section 17.1.4.1, “Replication Mode Concepts”
Section 17.1.3.7, “Restrictions on Replication with GTIDs”
Section 17.1.3.4, “Setting Up Replication Using GTIDs”

enterprise_encryption

Section 6.6.2, “Configuring MySQL Enterprise Encryption”
Section 6.6.5, “MySQL Enterprise Encryption Component Function Descriptions”
Section 6.6.1, “MySQL Enterprise Encryption Installation and Upgrading”
Section 5.1.8, “Server System Variables”

eq_range_index_dive_limit

Section 8.2.1.2, “Range Optimization”
Section 5.1.8, “Server System Variables”

error_count

Section B.2, “Error Information Interfaces”
Section 13.5, “Prepared Statements”
Section 5.1.8, “Server System Variables”
Section 13.7.7.17, “SHOW ERRORS Statement”
Section 13.6.7.7, “The MySQL Diagnostics Area”

event

Section 15.8.2, “Configuring InnoDB for Read-Only Operation”

event_scheduler

Section 17.1.2.8, “Adding Replicas to a Replication Environment”
Section 2.11.4, “Changes in MySQL 8.0”
Section 25.4.2, “Event Scheduler Configuration”
Section 5.1.8, “Server System Variables”
Section 17.1.2.6.2, “Setting Up Replication with Existing Data”
Section 25.4.6, “The Event Scheduler and MySQL Privileges”

expire_logs_days

Section 17.1.6.4, “Binary Logging Options and Variables”
Section 2.11.4, “Changes in MySQL 8.0”

explain_format

Section 13.8.2, “EXPLAIN Statement”
Section 5.1.8, “Server System Variables”
Section 1.3, “What Is New in MySQL 8.0”

explicit_defaults_for_timestamp

Section 11.2.5, “Automatic Initialization and Updating for TIMESTAMP and DATETIME”
Section 2.11.4, “Changes in MySQL 8.0”
Section 13.1.20.8, “CREATE TABLE and Generated Columns”
Section 11.6, “Data Type Default Values”
Section 11.2.1, “Date and Time Data Type Syntax”
Section B.3.4.3, “Problems with NULL Values”
Section 5.1.8, “Server System Variables”

external_user

Section 6.4.5.4, “Audit Log File Formats”
Section 6.2.19, “Proxy Users”
Section 5.1.8, “Server System Variables”

F

[index top]

flush

Section 5.1.8, “Server System Variables”

flush_time

Section 5.1.7, “Server Command Options”
Section 5.1.8, “Server System Variables”

foreign_key_checks

Section 13.1.9, “ALTER TABLE Statement”
Section 13.1.20.5, “FOREIGN KEY Constraints”
Section 23.6.9, “Importing Data Into MySQL Cluster”
Section 15.6.1.3, “Importing InnoDB Tables”
Section 5.4.4.3, “Mixed Binary Logging Format”
Section 23.4.3.9.2, “NDB Cluster System Variables”
Section 15.12.1, “Online DDL Operations”
Section 17.5.1.39, “Replication and Variables”
Section 5.1.11, “Server SQL Modes”
Section 5.1.8, “Server System Variables”
Section 5.4.4, “The Binary Log”

ft_boolean_syntax

Section 12.10.2, “Boolean Full-Text Searches”
Section 12.10.6, “Fine-Tuning MySQL Full-Text Search”
Section 5.1.8, “Server System Variables”

ft_max_word_len

Section 12.10.2, “Boolean Full-Text Searches”
Section 17.1.2.5.2, “Creating a Data Snapshot Using Raw Data Files”
Section 12.10.6, “Fine-Tuning MySQL Full-Text Search”
Section 12.10.8, “ngram Full-Text Parser”
Section 5.1.8, “Server System Variables”

ft_min_word_len

Section 12.10.2, “Boolean Full-Text Searches”
Section 17.1.2.5.2, “Creating a Data Snapshot Using Raw Data Files”
Section 12.10.6, “Fine-Tuning MySQL Full-Text Search”
Section 12.10.9, “MeCab Full-Text Parser Plugin”
Section 12.10.1, “Natural Language Full-Text Searches”
Section 12.10.8, “ngram Full-Text Parser”
Section 5.1.8, “Server System Variables”

ft_query_expansion_limit

Section 5.1.8, “Server System Variables”

ft_stopword_file

Section 12.10.2, “Boolean Full-Text Searches”
Section 17.1.2.5.2, “Creating a Data Snapshot Using Raw Data Files”
Section 12.10.6, “Fine-Tuning MySQL Full-Text Search”
Section 12.10.4, “Full-Text Stopwords”
Section 12.10.1, “Natural Language Full-Text Searches”
Section 5.1.8, “Server System Variables”

G

[index top]

general_log

MySQL Glossary
Section 5.4.1, “Selecting General Query Log and Slow Query Log Output Destinations”
Section 5.1.8, “Server System Variables”
Section 5.4.3, “The General Query Log”

general_log_file

Section 5.4.1, “Selecting General Query Log and Slow Query Log Output Destinations”
Section 5.1.8, “Server System Variables”
Section 5.4.3, “The General Query Log”
Section 1.3, “What Is New in MySQL 8.0”

generated_random_password_length

Section 6.2.15, “Password Management”
Section 5.1.8, “Server System Variables”

global_connection_memory_limit

Section 5.1.8, “Server System Variables”
Section 1.3, “What Is New in MySQL 8.0”

global_connection_memory_tracking

Section 5.1.10, “Server Status Variables”
Section 5.1.8, “Server System Variables”
Section 1.3, “What Is New in MySQL 8.0”

group_concat_max_len

Section 12.20.1, “Aggregate Function Descriptions”
Section 5.1.8, “Server System Variables”

group_replication_advertise_recovery_endpoints

Section 18.5.4.1, “Connections for Distributed Recovery”
Section 18.9, “Group Replication System Variables”
Section 18.5.4.1.1, “Selecting addresses for distributed recovery endpoints”
Section 18.5.5, “Support For IPv6 And For Mixed IPv6 And IPv4 Groups”

group_replication_allow_local_lower_version_join

Section 18.9, “Group Replication System Variables”
Section 18.8.1.1, “Member Versions During Upgrades”

group_replication_auto_increment_increment

Section 18.10, “Frequently Asked Questions”
Section 18.9, “Group Replication System Variables”
Section 17.1.6.2, “Replication Source Options and Variables”

group_replication_autorejoin_tries

Section 18.7.7.3, “Auto-Rejoin”
Section 2.11.4, “Changes in MySQL 8.0”
Section 18.7.7.4, “Exit Action”
Section 18.7.7.1, “Expel Timeout”
Section 18.10, “Frequently Asked Questions”
Section 18.9, “Group Replication System Variables”
Section 18.7.7.2, “Unreachable Majority Timeout”

group_replication_bootstrap_group

Section 18.2.1.6.1, “Adding a Second Instance”
Section 18.2.1.5, “Bootstrapping the Group”
Section 18.6.1, “Communication Stack for Connection Security Management”
Section 18.2.1.2, “Configuring an Instance for Group Replication”
Section 18.9, “Group Replication System Variables”
Section 18.1.3, “Multi-Primary and Single-Primary Modes”
Section 18.5.2, “Restarting a Group”

group_replication_clone_threshold

Section 18.5.4.2, “Cloning for Distributed Recovery”
Section 18.9, “Group Replication System Variables”
Section 18.5.4.5, “How Distributed Recovery Works”
Section 18.5.4.2.2, “Threshold for Cloning”

group_replication_communication_debug_options

Section 18.9, “Group Replication System Variables”

group_replication_communication_max_message_size

Section 18.3.2, “Group Replication Limitations”
Section 18.9, “Group Replication System Variables”
Section 18.7.5, “Message Fragmentation”

group_replication_communication_stack

Section 18.6.1, “Communication Stack for Connection Security Management”
Section 18.6.4, “Group Replication IP Address Permissions”
Section 18.9, “Group Replication System Variables”
Section 6.2.2, “Privileges Provided by MySQL”
Section 18.6.3.1.2, “Replication User With SSL”
Section 18.6.3.2, “Secure Socket Layer (SSL) Connections for Distributed Recovery”
Section 18.6.3.1, “Secure User Credentials for Distributed Recovery”
Section 18.6.3, “Securing Distributed Recovery Connections”
Section 18.6.2, “Securing Group Communication Connections with Secure Socket Layer (SSL)”

group_replication_components_stop_timeout

Section 18.9, “Group Replication System Variables”
Section 13.4.3.2, “STOP GROUP_REPLICATION Statement”

group_replication_compression_threshold

Section 18.3.2, “Group Replication Limitations”
Section 18.9, “Group Replication System Variables”
Section 18.7.4, “Message Compression”
Section 5.4.4.5.3, “Monitoring Binary Log Transaction Compression”

group_replication_consistency

Section 18.5.3.2, “Configuring Transaction Consistency Guarantees”
Section 18.9, “Group Replication System Variables”
Section 18.1.3.2, “Multi-Primary Mode”
Section 6.2.2, “Privileges Provided by MySQL”
Section 18.1.3.1, “Single-Primary Mode”
Section 18.5.3.1, “Understanding Transaction Consistency Guarantees”

group_replication_enforce_update_everywhere_checks

Section 18.5.1.2, “Changing a Group's Mode”
Section 13.4.3.4, “Functions which Configure the Group Replication Mode”
Section 18.3.2, “Group Replication Limitations”
Section 18.9, “Group Replication System Variables”
Section 18.1.3.1, “Single-Primary Mode”
Section 18.1.3.2.1, “Transaction Checks”

group_replication_exit_state_action

Section 18.7.7.3, “Auto-Rejoin”
Section 2.11.4, “Changes in MySQL 8.0”
Section 18.5.1.5, “Configuring Member Actions”
Section 18.7.7.4, “Exit Action”
Section 18.7.7.1, “Expel Timeout”
Section 18.5.4.4, “Fault Tolerance for Distributed Recovery”
Section 18.4.2, “Group Replication Server States”
Section 18.9, “Group Replication System Variables”
Section 27.12.11.13, “The replication_group_member_actions Table”
Section 18.7.7.2, “Unreachable Majority Timeout”

group_replication_flow_control_applier_threshold

Section 18.9, “Group Replication System Variables”

group_replication_flow_control_certifier_threshold

Section 18.9, “Group Replication System Variables”

group_replication_flow_control_hold_percent

Section 18.9, “Group Replication System Variables”

group_replication_flow_control_max_commit_quota

Section 18.9, “Group Replication System Variables”

group_replication_flow_control_member_quota_percent

Section 18.9, “Group Replication System Variables”

group_replication_flow_control_min_quota

Section 18.9, “Group Replication System Variables”

group_replication_flow_control_min_recovery_quota

Section 18.9, “Group Replication System Variables”

group_replication_flow_control_mode

Section 18.9, “Group Replication System Variables”

group_replication_flow_control_period

Section 18.9, “Group Replication System Variables”
Section 18.4.4, “The replication_group_member_stats Table”

group_replication_flow_control_release_percent

Section 18.9, “Group Replication System Variables”

group_replication_force_members

Section 18.9, “Group Replication System Variables”
Section 18.7.8, “Handling a Network Partition and Loss of Quorum”

group_replication_group_name

Section 17.4.9.1, “Asynchronous Connection Failover for Sources”
Section 18.2.1.2, “Configuring an Instance for Group Replication”
Section 13.4.2.12, “Functions which Configure the Source List”
Section 18.9, “Group Replication System Variables”
Section 18.4.1, “GTIDs and Group Replication”
Section 27.12.11.3, “The replication_asynchronous_connection_failover Table”
Section 27.12.11.4, “The replication_asynchronous_connection_failover_managed Table”

group_replication_group_seeds

Section 18.6.1, “Communication Stack for Connection Security Management”
Section 18.2.1.2, “Configuring an Instance for Group Replication”
Section 18.5.4.1, “Connections for Distributed Recovery”
Section 18.2.2, “Deploying Group Replication Locally”
Section 18.6.4, “Group Replication IP Address Permissions”
Section 18.9, “Group Replication System Variables”
Section 18.5.5, “Support For IPv6 And For Mixed IPv6 And IPv4 Groups”

group_replication_gtid_assignment_block_size

Section 18.9, “Group Replication System Variables”
Section 18.4.1, “GTIDs and Group Replication”

group_replication_ip_allowlist

Section 18.6.1, “Communication Stack for Connection Security Management”
Section 18.6.4, “Group Replication IP Address Permissions”
Section 18.9, “Group Replication System Variables”
Section 18.5.4.1.1, “Selecting addresses for distributed recovery endpoints”
Section 18.5.5, “Support For IPv6 And For Mixed IPv6 And IPv4 Groups”

group_replication_ip_whitelist

Section 18.6.1, “Communication Stack for Connection Security Management”
Section 18.6.4, “Group Replication IP Address Permissions”
Section 18.9, “Group Replication System Variables”
Section 18.5.4.1.1, “Selecting addresses for distributed recovery endpoints”
Section 18.5.5, “Support For IPv6 And For Mixed IPv6 And IPv4 Groups”

group_replication_local_address

Section 18.6.1, “Communication Stack for Connection Security Management”
Section 18.2.1.2, “Configuring an Instance for Group Replication”
Section 18.5.4.1, “Connections for Distributed Recovery”
Section 18.2.2, “Deploying Group Replication Locally”
Section 18.10, “Frequently Asked Questions”
Section 18.6.4, “Group Replication IP Address Permissions”
Section 18.9, “Group Replication System Variables”
Section 18.5.4.1.1, “Selecting addresses for distributed recovery endpoints”
Section 6.7.5.2, “Setting the TCP Port Context for MySQL Features”
Section 18.5.5, “Support For IPv6 And For Mixed IPv6 And IPv4 Groups”
Section 27.12.11.11, “The replication_group_members Table”

group_replication_member_expel_timeout

Section 2.11.4, “Changes in MySQL 8.0”
Section 18.7.7.4, “Exit Action”
Section 18.7.7.1, “Expel Timeout”
Section 18.1.4.2, “Failure Detection”
Section 18.10, “Frequently Asked Questions”
Section 18.1.4.1, “Group Membership”
Section 18.3.2, “Group Replication Limitations”
Section 18.9, “Group Replication System Variables”
Section 18.7.6.1, “Increasing the cache size”
Section 18.7.5, “Message Fragmentation”
Section 18.7.7, “Responses to Failure Detection and Network Partitioning”
Section 18.7.6, “XCom Cache Management”

group_replication_member_weight

Section 18.9, “Group Replication System Variables”
Section 18.1.3.1.1, “Primary Election Algorithm”

group_replication_message_cache_size

Section 18.7.7.1, “Expel Timeout”
Section 18.9, “Group Replication System Variables”
Section 18.7.6.1, “Increasing the cache size”
Section 18.7.6.2, “Reducing the cache size”
Section 18.7.6, “XCom Cache Management”

group_replication_paxos_single_leader

Section 13.4.3.6, “Functions to Inspect and Set the Group Replication Communication Protocol Version”
Section 18.9, “Group Replication System Variables”
Section 18.5.1.4, “Setting a Group's Communication Protocol Version”
Section 18.7.3, “Single Consensus Leader”
Section 27.12.11.15, “The replication_group_communication_information Table”

group_replication_poll_spin_loops

Section 18.7.1, “Fine Tuning the Group Communication Thread”
Section 18.9, “Group Replication System Variables”

group_replication_recovery_complete_at

Section 18.5.4.3, “Configuring Distributed Recovery”
Section 18.9, “Group Replication System Variables”

group_replication_recovery_compression_algorithms

Section 18.5.4.1.2, “Compression for Distributed Recovery”
Section 4.2.8, “Connection Compression Control”
Section 18.9, “Group Replication System Variables”
Section 18.7.4, “Message Compression”
Section 5.4.4.5.3, “Monitoring Binary Log Transaction Compression”

group_replication_recovery_get_public_key

Section 6.4.1.2, “Caching SHA-2 Pluggable Authentication”
Section 18.9, “Group Replication System Variables”
Section 18.6.3.1.1, “Replication User With The Caching SHA-2 Authentication Plugin”
Section 6.4.1.3, “SHA-256 Pluggable Authentication”
Section 18.5.4.1.4, “SSL and Authentication for Distributed Recovery”

group_replication_recovery_public_key_path

Section 6.4.1.2, “Caching SHA-2 Pluggable Authentication”
Section 18.9, “Group Replication System Variables”
Section 18.6.3.1.1, “Replication User With The Caching SHA-2 Authentication Plugin”
Section 18.5.4.1.4, “SSL and Authentication for Distributed Recovery”

group_replication_recovery_reconnect_interval

Section 18.5.4.3, “Configuring Distributed Recovery”
Section 18.9, “Group Replication System Variables”

group_replication_recovery_retry_count

Section 18.5.4.3, “Configuring Distributed Recovery”
Section 18.5.4.4, “Fault Tolerance for Distributed Recovery”
Section 18.9, “Group Replication System Variables”

group_replication_recovery_ssl_ca

Section 18.9, “Group Replication System Variables”
Section 18.5.4.2.1, “Prerequisites for Cloning”
Section 18.6.3.2, “Secure Socket Layer (SSL) Connections for Distributed Recovery”
Section 18.5.4.1.4, “SSL and Authentication for Distributed Recovery”

group_replication_recovery_ssl_capath

Section 18.9, “Group Replication System Variables”
Section 18.6.3.2, “Secure Socket Layer (SSL) Connections for Distributed Recovery”

group_replication_recovery_ssl_cert

Section 18.9, “Group Replication System Variables”
Section 18.5.4.2.1, “Prerequisites for Cloning”
Section 18.6.3.2, “Secure Socket Layer (SSL) Connections for Distributed Recovery”
Section 18.5.4.1.4, “SSL and Authentication for Distributed Recovery”

group_replication_recovery_ssl_cipher

Section 6.3.2, “Encrypted Connection TLS Protocols and Ciphers”
Section 18.9, “Group Replication System Variables”
Section 18.6.3.2, “Secure Socket Layer (SSL) Connections for Distributed Recovery”

group_replication_recovery_ssl_crl

Section 18.9, “Group Replication System Variables”
Section 18.6.3.2, “Secure Socket Layer (SSL) Connections for Distributed Recovery”

group_replication_recovery_ssl_crlpath

Section 18.9, “Group Replication System Variables”
Section 18.6.3.2, “Secure Socket Layer (SSL) Connections for Distributed Recovery”

group_replication_recovery_ssl_key

Section 18.9, “Group Replication System Variables”
Section 18.5.4.2.1, “Prerequisites for Cloning”
Section 18.6.3.2, “Secure Socket Layer (SSL) Connections for Distributed Recovery”
Section 18.5.4.1.4, “SSL and Authentication for Distributed Recovery”

group_replication_recovery_ssl_verify_server_cert

Section 18.9, “Group Replication System Variables”
Section 18.6.3.2, “Secure Socket Layer (SSL) Connections for Distributed Recovery”

group_replication_recovery_tls_ciphersuites

Section 6.3.2, “Encrypted Connection TLS Protocols and Ciphers”
Section 18.3.2, “Group Replication Limitations”
Section 18.9, “Group Replication System Variables”
Section 18.6.3.2, “Secure Socket Layer (SSL) Connections for Distributed Recovery”
Section 18.6.2, “Securing Group Communication Connections with Secure Socket Layer (SSL)”

group_replication_recovery_tls_version

Section 6.3.2, “Encrypted Connection TLS Protocols and Ciphers”
Section 18.3.2, “Group Replication Limitations”
Section 18.9, “Group Replication System Variables”
Section 18.6.3.2, “Secure Socket Layer (SSL) Connections for Distributed Recovery”
Section 18.6.2, “Securing Group Communication Connections with Secure Socket Layer (SSL)”

group_replication_recovery_use_ssl

Section 18.6.1, “Communication Stack for Connection Security Management”
Section 18.9, “Group Replication System Variables”
Section 18.5.4.2.1, “Prerequisites for Cloning”
Section 18.6.3.2, “Secure Socket Layer (SSL) Connections for Distributed Recovery”
Section 18.5.4.1.4, “SSL and Authentication for Distributed Recovery”

group_replication_recovery_zstd_compression_level

Section 18.5.4.1.2, “Compression for Distributed Recovery”
Section 4.2.8, “Connection Compression Control”
Section 18.9, “Group Replication System Variables”
Section 18.7.4, “Message Compression”
Section 5.4.4.5.3, “Monitoring Binary Log Transaction Compression”

group_replication_single_primary_mode

Section 18.3.2, “Group Replication Limitations”
Section 18.9, “Group Replication System Variables”
Section 18.1.3, “Multi-Primary and Single-Primary Modes”
Section 18.1.3.2, “Multi-Primary Mode”
Section 18.1.3.1, “Single-Primary Mode”

group_replication_ssl_mode

Section 18.6.1, “Communication Stack for Connection Security Management”
Section 18.9, “Group Replication System Variables”
Section 18.6.3.1.2, “Replication User With SSL”
Section 18.6.3.2, “Secure Socket Layer (SSL) Connections for Distributed Recovery”
Section 18.6.3.1, “Secure User Credentials for Distributed Recovery”
Section 18.6.3, “Securing Distributed Recovery Connections”
Section 18.6.2, “Securing Group Communication Connections with Secure Socket Layer (SSL)”
Section 18.5.4.1.4, “SSL and Authentication for Distributed Recovery”

group_replication_start_on_boot

Section 18.5.4.2.3, “Cloning Operations”
Section 18.2.1.2, “Configuring an Instance for Group Replication”
Section 18.7.7.4, “Exit Action”
Section 18.7.7.1, “Expel Timeout”
Section 18.10, “Frequently Asked Questions”
Section 18.9, “Group Replication System Variables”
Section 18.5.4.2.1, “Prerequisites for Cloning”
Section 18.6.3.1.3, “Providing Replication User Credentials Securely”
Section 18.5.2, “Restarting a Group”
Section 13.4.3.1, “START GROUP_REPLICATION Statement”
Section 18.8.3.2, “Upgrading a Group Replication Member”
Section 18.2.1.3, “User Credentials For Distributed Recovery”

group_replication_tls_source

Section 18.9, “Group Replication System Variables”

group_replication_transaction_size_limit

Section 18.3.2, “Group Replication Limitations”
Section 18.9, “Group Replication System Variables”
Section 18.7.5, “Message Fragmentation”

group_replication_unreachable_majority_timeout

Section 2.11.4, “Changes in MySQL 8.0”
Section 18.7.7.4, “Exit Action”
Section 18.9, “Group Replication System Variables”
Section 18.7.8, “Handling a Network Partition and Loss of Quorum”
Section 18.7.7.2, “Unreachable Majority Timeout”

group_replication_view_change_uuid

Section 18.9, “Group Replication System Variables”
Section 18.4.1, “GTIDs and Group Replication”

gtid_executed

Section 5.6.7.7, “Cloning for Replication”
Section 2.11.14, “Copying MySQL Databases to Another Machine”
Section 17.1.2.5.1, “Creating a Data Snapshot Using mysqldump”
Section 7.4.1, “Dumping Data in SQL Format with mysqldump”
Section 17.1.6.5, “Global Transaction ID System Variables”
Section 17.1.3.3, “GTID Auto-Positioning”
Section 17.1.3.1, “GTID Format and Storage”
Section 17.1.3.2, “GTID Life Cycle”
Section 4.5.4, “mysqldump — A Database Backup Program”
Section 27.12.11, “Performance Schema Replication Tables”
Section 17.1.5.2, “Provisioning a Multi-Source Replica for GTID-Based Replication”
Section 17.1.6.3, “Replica Server Options and Variables”
Section 17.2.5.4, “Replication Channel Based Filters”
Section 17.1.3.6, “Replication From a Source Without GTIDs to a Replica With GTIDs”
Section 17.1.4.1, “Replication Mode Concepts”
Section 13.4.1.2, “RESET MASTER Statement”
Section 18.5.2, “Restarting a Group”
Section 17.1.3.7, “Restrictions on Replication with GTIDs”
Section 5.1.8, “Server System Variables”
Section 13.7.7.23, “SHOW MASTER STATUS Statement”
Section 13.7.7.35, “SHOW REPLICA STATUS Statement”
Section 17.1.3.8, “Stored Function Examples to Manipulate GTIDs”
Section 27.12.21.4, “The log_status Table”
Section 18.5.4.2.2, “Threshold for Cloning”
Section 17.1.3.5, “Using GTIDs for Failover and Scaleout”
Section 18.5.6, “Using MySQL Enterprise Backup with Group Replication”

gtid_executed_compression_period

Section 2.11.4, “Changes in MySQL 8.0”
Section 17.1.6.5, “Global Transaction ID System Variables”
Section 17.1.3.1, “GTID Format and Storage”

GTID_MODE

Section 13.4.2.1, “CHANGE MASTER TO Statement”
Section 13.4.2.3, “CHANGE REPLICATION SOURCE TO Statement”
Section 17.1.3.3, “GTID Auto-Positioning”
Section 17.5.1.34, “Replication and Transaction Inconsistencies”
Section 17.2.1.2, “Usage of Row-Based Logging and Replication”

gtid_mode

Section 17.1.5.3, “Adding GTID-Based Sources to a Multi-Source Replica”
Section 13.4.2.1, “CHANGE MASTER TO Statement”
Section 13.4.2.3, “CHANGE REPLICATION SOURCE TO Statement”
Section 5.6.7.7, “Cloning for Replication”
Section 2.11.14, “Copying MySQL Databases to Another Machine”
Section 17.1.2.5.1, “Creating a Data Snapshot Using mysqldump”
Section 17.1.4.3, “Disabling GTID Transactions Online”
Section 7.4.1, “Dumping Data in SQL Format with mysqldump”
Section 17.1.4.2, “Enabling GTID Transactions Online”
Section 12.19, “Functions Used with Global Transaction Identifiers (GTIDs)”
Section 17.1.6.5, “Global Transaction ID System Variables”
Section 18.3.1, “Group Replication Requirements”
Section 17.1.3.1, “GTID Format and Storage”
Section 18.4.1, “GTIDs and Group Replication”
Section 17.4.2, “Handling an Unexpected Halt of a Replica”
Section 4.4.5, “mysql_upgrade — Check and Upgrade MySQL Tables”
Section 4.5.4, “mysqldump — A Database Backup Program”
Section 17.1.6.3, “Replica Server Options and Variables”
Section 17.1.3.6, “Replication From a Source Without GTIDs to a Replica With GTIDs”
Section 17.1.4.1, “Replication Mode Concepts”
Section 13.4.1.2, “RESET MASTER Statement”
Section 13.4.2.5, “RESET REPLICA Statement”
Section 17.1.3.7, “Restrictions on Replication with GTIDs”
Section 17.1.3.4, “Setting Up Replication Using GTIDs”
Section 17.1.7.3, “Skipping Transactions”
Section 17.1.7.3.1, “Skipping Transactions With GTIDs”
Section 17.1.7.3.2.1, “Skipping Transactions With SET GLOBAL sql_slave_skip_counter
Section 17.1.7.3.2, “Skipping Transactions Without GTIDs”
Section 17.4.9, “Switching Sources and Replicas with Asynchronous Connection Failover”
Section 27.12.7.1, “The events_transactions_current Table”
Section 17.5.3, “Upgrading a Replication Topology”
Section 2.11.6, “Upgrading MySQL Binary or Package-based Installations on Unix/Linux”
Section 17.1.3.5, “Using GTIDs for Failover and Scaleout”

gtid_next

Section 17.1.6.5, “Global Transaction ID System Variables”
Section 17.1.3.1, “GTID Format and Storage”
Section 17.1.3.2, “GTID Life Cycle”
Section 17.3.3.1, “Privileges For The Replication PRIVILEGE_CHECKS_USER Account”
Section 17.1.4.1, “Replication Mode Concepts”
Section 5.1.10, “Server Status Variables”
Section 13.4.2.10, “STOP REPLICA Statement”
Section 27.12.7.1, “The events_transactions_current Table”

gtid_owned

Section 17.1.6.5, “Global Transaction ID System Variables”
Section 17.1.3.2, “GTID Life Cycle”

gtid_purged

Section 13.4.2.1, “CHANGE MASTER TO Statement”
Section 13.4.2.3, “CHANGE REPLICATION SOURCE TO Statement”
Section 17.1.2.5.1, “Creating a Data Snapshot Using mysqldump”
Section 7.4.1, “Dumping Data in SQL Format with mysqldump”
Section 17.1.6.5, “Global Transaction ID System Variables”
Section 17.1.3.3, “GTID Auto-Positioning”
Section 17.1.3.1, “GTID Format and Storage”
Section 17.1.3.2, “GTID Life Cycle”
Section 4.5.4, “mysqldump — A Database Backup Program”
Section 17.1.5.2, “Provisioning a Multi-Source Replica for GTID-Based Replication”
Section 17.1.4.1, “Replication Mode Concepts”
Section 13.4.1.2, “RESET MASTER Statement”
Section 17.1.3.8, “Stored Function Examples to Manipulate GTIDs”
Section 18.5.4.2.2, “Threshold for Cloning”
Section 17.1.3.5, “Using GTIDs for Failover and Scaleout”

H

[index top]

have_compress

Section 5.1.8, “Server System Variables”

have_dynamic_loading

Section 17.4.10.1, “Installing Semisynchronous Replication”
Section 5.1.8, “Server System Variables”

have_geometry

Section 5.1.8, “Server System Variables”

have_openssl

Section 5.1.8, “Server System Variables”

have_profiling

Section 5.1.8, “Server System Variables”

have_query_cache

Section 5.1.8, “Server System Variables”

have_rtree_keys

Section 5.1.8, “Server System Variables”

have_ssl

Section 2.9.6, “Configuring SSL Library Support”
Section 5.1.8, “Server System Variables”

have_statement_timeout

Section 5.1.8, “Server System Variables”

have_symlink

Section 5.1.7, “Server Command Options”
Section 5.1.8, “Server System Variables”
Section 8.12.2.3, “Using Symbolic Links for Databases on Windows”
Section 8.12.2.2, “Using Symbolic Links for MyISAM Tables on Unix”

histogram_generation_max_mem_size

Section 13.7.3.1, “ANALYZE TABLE Statement”
Section 5.1.8, “Server System Variables”

host_cache_size

Section 5.1.12.3, “DNS Lookups and the Host Cache”
Section 5.1.7, “Server Command Options”
Section 5.1.8, “Server System Variables”
Section 27.12.21.2, “The host_cache Table”
Section 1.3, “What Is New in MySQL 8.0”

hostname

Section 13.7.5, “CLONE Statement”
Section 5.6.7.3, “Cloning Remote Data”
Section 18.2.1.2, “Configuring an Instance for Group Replication”
Section 18.5.4.1, “Connections for Distributed Recovery”
Section 18.10, “Frequently Asked Questions”
Section 18.9, “Group Replication System Variables”
Section 18.6.3, “Securing Distributed Recovery Connections”
Section 5.1.8, “Server System Variables”
Section 27.12.11.11, “The replication_group_members Table”

I

[index top]

identity

Section 5.4.4.3, “Mixed Binary Logging Format”
Section 17.5.1.39, “Replication and Variables”
Section 5.1.8, “Server System Variables”

immediate_server_version

Section 17.3.3.1, “Privileges For The Replication PRIVILEGE_CHECKS_USER Account”
Section 17.5.2, “Replication Compatibility Between MySQL Versions”
Section 17.1.6.2, “Replication Source Options and Variables”

information_schema_stats_expiry

Section 13.7.3.1, “ANALYZE TABLE Statement”
Section 14.7, “Data Dictionary Usage Differences”
Section 14.5, “INFORMATION_SCHEMA and Data Dictionary Integration”
Section 15.14, “InnoDB Startup Options and System Variables”
Section 8.2.3, “Optimizing INFORMATION_SCHEMA Queries”
Section 5.1.8, “Server System Variables”
Section 26.3.34, “The INFORMATION_SCHEMA STATISTICS Table”
Section 26.3.38, “The INFORMATION_SCHEMA TABLES Table”
Section 1.3, “What Is New in MySQL 8.0”

init_connect

Section 10.5, “Configuring Application Character Set and Collation”
Section 6.2.2, “Privileges Provided by MySQL”
Section 17.1.6.3, “Replica Server Options and Variables”
Section 5.1.8, “Server System Variables”
Section 27.12.21.2, “The host_cache Table”

init_file

Section 13.1.2, “ALTER DATABASE Statement”
Section 2.10.1, “Initializing the Data Directory”
Section 8.10.2.2, “Multiple Key Caches”
Section 27.4, “Performance Schema Runtime Configuration”
Section 27.12.14.2, “Performance Schema variables_info Table”
Section 17.5.1.21, “Replication and MEMORY Tables”
Section B.3.3.2.2, “Resetting the Root Password: Unix and Unix-Like Systems”
Section B.3.3.2.1, “Resetting the Root Password: Windows Systems”
Section 5.1.7, “Server Command Options”
Section 5.1.8, “Server System Variables”
Section 16.3, “The MEMORY Storage Engine”

init_replica

Section 17.3.3.1, “Privileges For The Replication PRIVILEGE_CHECKS_USER Account”
Section 17.1.6.3, “Replica Server Options and Variables”

init_slave

Section 17.3.3.1, “Privileges For The Replication PRIVILEGE_CHECKS_USER Account”
Section 17.1.6.3, “Replica Server Options and Variables”

innodb

Section 2.11.4, “Changes in MySQL 8.0”
Section 15.8.2, “Configuring InnoDB for Read-Only Operation”
Section 15.8.3.7, “Excluding Buffer Pool Pages from Core Files”
Section A.16, “MySQL 8.0 FAQ: InnoDB Change Buffer”

innodb_adaptive_flushing

Section 15.8.3.5, “Configuring Buffer Pool Flushing”
Section 15.14, “InnoDB Startup Options and System Variables”

innodb_adaptive_flushing_lwm

Section 15.8.3.5, “Configuring Buffer Pool Flushing”
Section 15.14, “InnoDB Startup Options and System Variables”

innodb_adaptive_hash_index

Section 15.5.3, “Adaptive Hash Index”
Section 15.8.4, “Configuring Thread Concurrency for InnoDB”
Section 15.14, “InnoDB Startup Options and System Variables”
MySQL Glossary
Section 8.5.9, “Optimizing InnoDB Configuration Variables”
Section 13.1.37, “TRUNCATE TABLE Statement”

innodb_adaptive_hash_index_parts

Section 15.5.3, “Adaptive Hash Index”
Section 15.14, “InnoDB Startup Options and System Variables”
Section 26.4.28, “The INFORMATION_SCHEMA INNODB_TRX Table”

innodb_adaptive_max_sleep_delay

Section 15.8.4, “Configuring Thread Concurrency for InnoDB”
Section 15.14, “InnoDB Startup Options and System Variables”

innodb_api_bk_commit_interval

Section 15.20.6.4, “Controlling Transactional Behavior of the InnoDB memcached Plugin”
Section 15.20.2, “InnoDB memcached Architecture”
Section 15.14, “InnoDB Startup Options and System Variables”

innodb_api_disable_rowlock

Section 15.20.6.4, “Controlling Transactional Behavior of the InnoDB memcached Plugin”
Section 15.14, “InnoDB Startup Options and System Variables”

innodb_api_enable_binlog

Section 15.14, “InnoDB Startup Options and System Variables”
Section 15.20.7, “The InnoDB memcached Plugin and Replication”

innodb_api_enable_mdl

Section 15.20.6.4, “Controlling Transactional Behavior of the InnoDB memcached Plugin”
Section 15.20.2, “InnoDB memcached Architecture”
Section 15.14, “InnoDB Startup Options and System Variables”

innodb_api_trx_level

Section 15.20.6.4, “Controlling Transactional Behavior of the InnoDB memcached Plugin”
Section 15.20.2, “InnoDB memcached Architecture”
Section 15.14, “InnoDB Startup Options and System Variables”

innodb_autoextend_increment

Section 15.6.3.2, “File-Per-Table Tablespaces”
Section 15.8.1, “InnoDB Startup Configuration”
Section 15.14, “InnoDB Startup Options and System Variables”
MySQL Glossary
Section 15.6.3.1, “The System Tablespace”

innodb_autoinc_lock_mode

Section 15.6.1.6, “AUTO_INCREMENT Handling in InnoDB”
Section 8.5.5, “Bulk Data Loading for InnoDB Tables”
Section 2.11.4, “Changes in MySQL 8.0”
Section 12.16, “Information Functions”
Section 15.7.1, “InnoDB Locking”
Section 15.14, “InnoDB Startup Options and System Variables”
Section 15.7.3, “Locks Set by Different SQL Statements in InnoDB”
MySQL Glossary
Section 1.3, “What Is New in MySQL 8.0”

innodb_background_drop_list_empty

Section 15.14, “InnoDB Startup Options and System Variables”

innodb_buffer_pool_chunk_size

Section 15.8.3.1, “Configuring InnoDB Buffer Pool Size”
Section 15.14, “InnoDB Startup Options and System Variables”

innodb_buffer_pool_debug

Section 15.14, “InnoDB Startup Options and System Variables”

innodb_buffer_pool_dump_at_shutdown

Section 15.14, “InnoDB Startup Options and System Variables”
MySQL Glossary
Section 15.8.3.6, “Saving and Restoring the Buffer Pool State”

innodb_buffer_pool_dump_now

Section 15.14, “InnoDB Startup Options and System Variables”
Section 15.8.3.6, “Saving and Restoring the Buffer Pool State”

innodb_buffer_pool_dump_pct

Section 15.14, “InnoDB Startup Options and System Variables”
Section 15.8.3.6, “Saving and Restoring the Buffer Pool State”

innodb_buffer_pool_filename

Section 15.14, “InnoDB Startup Options and System Variables”
Section 15.8.3.6, “Saving and Restoring the Buffer Pool State”

innodb_buffer_pool_in_core_file

Section 15.8.3.7, “Excluding Buffer Pool Pages from Core Files”
Section 15.14, “InnoDB Startup Options and System Variables”
Section 4.3.2, “mysqld_safe — MySQL Server Startup Script”
Section 5.1.7, “Server Command Options”

innodb_buffer_pool_instances

Section 15.8.3.5, “Configuring Buffer Pool Flushing”
Section 15.8.3.1, “Configuring InnoDB Buffer Pool Size”
Section 15.8.3.2, “Configuring Multiple Buffer Pool Instances”
Section 15.6.4, “Doublewrite Buffer”
Section 8.12.3.1, “How MySQL Uses Memory”
Section 15.8.1, “InnoDB Startup Configuration”
Section 15.14, “InnoDB Startup Options and System Variables”
MySQL Glossary
Section 15.20.6.3, “Tuning InnoDB memcached Plugin Performance”

innodb_buffer_pool_load_abort

Section 15.14, “InnoDB Startup Options and System Variables”
Section 5.1.10, “Server Status Variables”

innodb_buffer_pool_load_at_startup

Section 15.14, “InnoDB Startup Options and System Variables”
MySQL Glossary
Section 15.8.3.6, “Saving and Restoring the Buffer Pool State”
Section 5.1.10, “Server Status Variables”

innodb_buffer_pool_load_now

Section 15.14, “InnoDB Startup Options and System Variables”
Section 15.8.3.6, “Saving and Restoring the Buffer Pool State”
Section 5.1.10, “Server Status Variables”

innodb_buffer_pool_size

Section 2.11.4, “Changes in MySQL 8.0”
Section 15.9.1.6, “Compression for OLTP Workloads”
Section 15.8.3.1, “Configuring InnoDB Buffer Pool Size”
Section 15.8.3.2, “Configuring Multiple Buffer Pool Instances”
Section 15.6.1.5, “Converting Tables from MyISAM to InnoDB”
Section 15.8.12, “Enabling Automatic Configuration for a Dedicated MySQL Server”
Section 8.12.3.1, “How MySQL Uses Memory”
Section 15.20.2, “InnoDB memcached Architecture”
Section 15.8.1, “InnoDB Startup Configuration”
Section 15.14, “InnoDB Startup Options and System Variables”
MySQL Glossary
Section 8.5.8, “Optimizing InnoDB Disk I/O”
Section 5.1.10, “Server Status Variables”
Section 15.20.6.3, “Tuning InnoDB memcached Plugin Performance”
Section 1.3, “What Is New in MySQL 8.0”

innodb_change_buffer_max_size

Section 15.5.2, “Change Buffer”
Section 15.14, “InnoDB Startup Options and System Variables”
Section A.16, “MySQL 8.0 FAQ: InnoDB Change Buffer”
MySQL Glossary

innodb_change_buffering

Section 15.5.2, “Change Buffer”
Section 15.8.2, “Configuring InnoDB for Read-Only Operation”
Section 15.14, “InnoDB Startup Options and System Variables”
MySQL Glossary
Section 8.5.2, “Optimizing InnoDB Transaction Management”

innodb_change_buffering_debug

Section 15.14, “InnoDB Startup Options and System Variables”

innodb_checkpoint_disabled

Section 15.14, “InnoDB Startup Options and System Variables”

innodb_checksum_algorithm

Section 15.1.1, “Benefits of Using InnoDB Tables”
Section 15.14, “InnoDB Startup Options and System Variables”
MySQL Glossary
Section 8.5.8, “Optimizing InnoDB Disk I/O”

innodb_checksums

MySQL Glossary

innodb_cmp_per_index_enabled

Section 15.14, “InnoDB Startup Options and System Variables”
Section 15.9.1.4, “Monitoring InnoDB Table Compression at Runtime”
Section 26.4.8, “The INFORMATION_SCHEMA INNODB_CMP_PER_INDEX and INNODB_CMP_PER_INDEX_RESET Tables”
Section 15.9.1.3, “Tuning Compression for InnoDB Tables”

innodb_commit_concurrency

Section 15.14, “InnoDB Startup Options and System Variables”

innodb_compress_debug

Section 15.14, “InnoDB Startup Options and System Variables”

innodb_compression_failure_threshold_pct

Section 15.9.1.6, “Compression for OLTP Workloads”
Section 15.9.1.5, “How Compression Works for InnoDB Tables”
Section 15.14, “InnoDB Startup Options and System Variables”
MySQL Glossary
Section 15.9.1.3, “Tuning Compression for InnoDB Tables”

innodb_compression_level

Section 15.9.1.6, “Compression for OLTP Workloads”
Section 15.9.1.5, “How Compression Works for InnoDB Tables”
Section 15.14, “InnoDB Startup Options and System Variables”
MySQL Glossary
Section 15.9.1.3, “Tuning Compression for InnoDB Tables”

innodb_compression_pad_pct_max

Section 15.9.1.6, “Compression for OLTP Workloads”
Section 15.9.1.5, “How Compression Works for InnoDB Tables”
Section 15.14, “InnoDB Startup Options and System Variables”
MySQL Glossary
Section 15.9.1.3, “Tuning Compression for InnoDB Tables”

innodb_concurrency_tickets

Section 15.8.4, “Configuring Thread Concurrency for InnoDB”
Section 15.14, “InnoDB Startup Options and System Variables”
Section 8.5.9, “Optimizing InnoDB Configuration Variables”
Section 26.4.28, “The INFORMATION_SCHEMA INNODB_TRX Table”

innodb_data_file_path

Section 5.6.7.3, “Cloning Remote Data”
Section 15.11.2, “File Space Management”
Section 2.10.1, “Initializing the Data Directory”
Section 4.6.2, “innochecksum — Offline InnoDB File Checksum Utility”
Section 15.8.1, “InnoDB Startup Configuration”
Section 15.14, “InnoDB Startup Options and System Variables”
Section 26.3.15, “The INFORMATION_SCHEMA FILES Table”
Section 15.6.3.1, “The System Tablespace”
Section 15.21.1, “Troubleshooting InnoDB I/O Problems”

innodb_data_home_dir

Section 2.11.4, “Changes in MySQL 8.0”
Section 5.6.7.3, “Cloning Remote Data”
Section 15.6.1.2, “Creating Tables Externally”
Section 15.6.4, “Doublewrite Buffer”
Section 15.6.3.3, “General Tablespaces”
Section 2.10.1, “Initializing the Data Directory”
Section 15.18.2, “InnoDB Recovery”
Section 15.8.1, “InnoDB Startup Configuration”
Section 15.14, “InnoDB Startup Options and System Variables”
Section 15.6.3.6, “Moving Tablespace Files While the Server is Offline”
Section 15.6.5, “Redo Log”
Section 15.6.3.5, “Temporary Tablespaces”
Section 15.21.1, “Troubleshooting InnoDB I/O Problems”
Section 13.1.37, “TRUNCATE TABLE Statement”
Section 15.6.3.4, “Undo Tablespaces”
Section 18.5.6, “Using MySQL Enterprise Backup with Group Replication”
Section 1.3, “What Is New in MySQL 8.0”

innodb_ddl_buffer_size

Section 15.14, “InnoDB Startup Options and System Variables”
Section 15.12.4, “Online DDL Memory Management”

innodb_ddl_log_crash_reset_debug

Section 15.14, “InnoDB Startup Options and System Variables”

innodb_ddl_threads

Section 15.12.5, “Configuring Parallel Threads for Online DDL Operations”
Section 15.14, “InnoDB Startup Options and System Variables”
Section 15.12.4, “Online DDL Memory Management”

innodb_deadlock_detect

Section 15.6.1.5, “Converting Tables from MyISAM to InnoDB”
Section 15.7.5.2, “Deadlock Detection”
Section 15.7.5, “Deadlocks in InnoDB”
Section 15.14, “InnoDB Startup Options and System Variables”
Section 8.11.1, “Internal Locking Methods”
MySQL Glossary
Section 1.3, “What Is New in MySQL 8.0”

innodb_dedicated_server

Section 2.11.4, “Changes in MySQL 8.0”
Section 15.8.12, “Enabling Automatic Configuration for a Dedicated MySQL Server”
Section 15.14, “InnoDB Startup Options and System Variables”
Section 15.6.5, “Redo Log”
Section 1.3, “What Is New in MySQL 8.0”

innodb_default_row_format

Section 13.1.20, “CREATE TABLE Statement”
Section 15.6.1.1, “Creating InnoDB Tables”
Section 15.6.1.3, “Importing InnoDB Tables”
Section 15.10, “InnoDB Row Formats”
Section 15.14, “InnoDB Startup Options and System Variables”
MySQL Glossary
Section 8.4.1, “Optimizing Data Size”

innodb_directories

Section 2.11.4, “Changes in MySQL 8.0”
Section 13.1.21, “CREATE TABLESPACE Statement”
Section 15.6.1.2, “Creating Tables Externally”
Section 15.6.3.7, “Disabling Tablespace Path Validation”
Section 15.6.3.3, “General Tablespaces”
Section 15.18.2, “InnoDB Recovery”
Section 15.14, “InnoDB Startup Options and System Variables”
Section 15.6.3.6, “Moving Tablespace Files While the Server is Offline”
Section 15.6.5, “Redo Log”
Section 13.1.37, “TRUNCATE TABLE Statement”
Section 15.6.3.4, “Undo Tablespaces”
Section 1.3, “What Is New in MySQL 8.0”

innodb_disable_sort_file_cache

Section 15.14, “InnoDB Startup Options and System Variables”

innodb_doublewrite

Section 15.6.4, “Doublewrite Buffer”
Section 15.11.1, “InnoDB Disk I/O”
Section 15.8.1, “InnoDB Startup Configuration”
Section 15.14, “InnoDB Startup Options and System Variables”
Section 15.20.6.3, “Tuning InnoDB memcached Plugin Performance”
Section 1.3, “What Is New in MySQL 8.0”

innodb_doublewrite_batch_size

Section 15.6.4, “Doublewrite Buffer”
Section 15.14, “InnoDB Startup Options and System Variables”
Section 1.3, “What Is New in MySQL 8.0”

innodb_doublewrite_dir

Section 15.6.4, “Doublewrite Buffer”
Section 15.8.1, “InnoDB Startup Configuration”
Section 15.14, “InnoDB Startup Options and System Variables”
Section 1.3, “What Is New in MySQL 8.0”

innodb_doublewrite_files

Section 15.6.4, “Doublewrite Buffer”
Section 15.14, “InnoDB Startup Options and System Variables”
Section 1.3, “What Is New in MySQL 8.0”

innodb_doublewrite_pages

Section 15.6.4, “Doublewrite Buffer”
Section 15.14, “InnoDB Startup Options and System Variables”
Section 1.3, “What Is New in MySQL 8.0”

innodb_extend_and_initialize

Section 15.14, “InnoDB Startup Options and System Variables”
Section 15.6.3.8, “Optimizing Tablespace Space Allocation on Linux”
Section 1.3, “What Is New in MySQL 8.0”

innodb_fast_shutdown

Section 15.18.2, “InnoDB Recovery”
Section 15.14, “InnoDB Startup Options and System Variables”
MySQL Glossary
Section 2.11.5, “Preparing Your Installation for Upgrade”
Section 5.1.19, “The Server Shutdown Process”
Section 2.11.12, “Upgrade Troubleshooting”
Section 2.11.6, “Upgrading MySQL Binary or Package-based Installations on Unix/Linux”

innodb_fil_make_page_dirty_debug

Section 15.14, “InnoDB Startup Options and System Variables”

innodb_file_per

Section 13.1.20.2, “CREATE TEMPORARY TABLE Statement”
Section 15.14, “InnoDB Startup Options and System Variables”

innodb_file_per_table

Section 15.1.2, “Best Practices for InnoDB Tables”
Section 15.6.1.5, “Converting Tables from MyISAM to InnoDB”
Section 13.1.20.3, “CREATE TABLE ... LIKE Statement”
Section 13.1.20, “CREATE TABLE Statement”
Section 13.1.21, “CREATE TABLESPACE Statement”
Section 15.9.1.2, “Creating Compressed Tables”
Section 15.6.1.1, “Creating InnoDB Tables”
Section 15.6.1.2, “Creating Tables Externally”
Section 15.11.2, “File Space Management”
Section 15.6.3.2, “File-Per-Table Tablespaces”
Section 13.1.20.1, “Files Created by CREATE TABLE”
Section 13.7.8.3, “FLUSH Statement”
Section 15.9.1.5, “How Compression Works for InnoDB Tables”
Section 15.6.1.3, “Importing InnoDB Tables”
Section 15.2, “InnoDB and the ACID Model”
Section 15.10, “InnoDB Row Formats”
Section 15.14, “InnoDB Startup Options and System Variables”
MySQL Glossary
Section 13.7.3.4, “OPTIMIZE TABLE Statement”
Section 15.11.5, “Reclaiming Disk Space with TRUNCATE TABLE”
Section 17.4.6, “Replicating Different Databases to Different Replicas”
Section 24.6, “Restrictions and Limitations on Partitioning”
Section 15.9.1.7, “SQL Compression Syntax Warnings and Errors”
Section 15.21.4, “Troubleshooting InnoDB Data Dictionary Operations”

innodb_fill_factor

Section 15.14, “InnoDB Startup Options and System Variables”
Section 15.6.2.3, “Sorted Index Builds”
Section 15.6.2.2, “The Physical Structure of an InnoDB Index”

innodb_flush_log_at_timeout

Section 15.14, “InnoDB Startup Options and System Variables”
Section 15.5.4, “Log Buffer”

innodb_flush_log_at_trx_commit

Section 13.1.1, “Atomic Data Definition Statement Support”
Section 17.1.6.4, “Binary Logging Options and Variables”
Section 17.4.2, “Handling an Unexpected Halt of a Replica”
Section 15.2, “InnoDB and the ACID Model”
Section 15.14, “InnoDB Startup Options and System Variables”
Section 15.5.4, “Log Buffer”
Section 8.5.2, “Optimizing InnoDB Transaction Management”
Section 17.5.1.28, “Replication and Source or Replica Shutdowns”
Section 15.20.6.3, “Tuning InnoDB memcached Plugin Performance”

innodb_flush_method

Section 2.11.4, “Changes in MySQL 8.0”
Section 15.6.4, “Doublewrite Buffer”
Section 15.8.12, “Enabling Automatic Configuration for a Dedicated MySQL Server”
Section 15.6.3.2, “File-Per-Table Tablespaces”
Section 15.14, “InnoDB Startup Options and System Variables”
Section 8.5.8, “Optimizing InnoDB Disk I/O”
Section 5.1.10, “Server Status Variables”
Section 15.20.6.3, “Tuning InnoDB memcached Plugin Performance”
Section 1.3, “What Is New in MySQL 8.0”

innodb_flush_neighbors

Section 2.11.4, “Changes in MySQL 8.0”
Section 15.8.3.5, “Configuring Buffer Pool Flushing”
Section 15.14, “InnoDB Startup Options and System Variables”
MySQL Glossary
Section 8.5.8, “Optimizing InnoDB Disk I/O”

innodb_flush_sync

Section 15.8.7, “Configuring InnoDB I/O Capacity”
Section 15.14, “InnoDB Startup Options and System Variables”

innodb_flushing_avg_loops

Section 15.8.3.5, “Configuring Buffer Pool Flushing”
Section 15.14, “InnoDB Startup Options and System Variables”

innodb_force_load_corrupted

Section 15.14, “InnoDB Startup Options and System Variables”

innodb_force_recovery

Section 13.1.32, “DROP TABLE Statement”
Section 15.21.3, “Forcing InnoDB Recovery”
Section 1.5, “How to Report Bugs or Problems”
Section 15.18.2, “InnoDB Recovery”
Section 15.14, “InnoDB Startup Options and System Variables”
Section 8.5.2, “Optimizing InnoDB Transaction Management”
Section 2.11.13, “Rebuilding or Repairing Tables or Indexes”
Section 15.21.2, “Troubleshooting Recovery Failures”

innodb_fsync_threshold

Section 15.14, “InnoDB Startup Options and System Variables”
Section 8.5.8, “Optimizing InnoDB Disk I/O”

innodb_ft_aux_table

Section 15.15.4, “InnoDB INFORMATION_SCHEMA FULLTEXT Index Tables”
Section 15.14, “InnoDB Startup Options and System Variables”
Section 26.4.14, “The INFORMATION_SCHEMA INNODB_FT_BEING_DELETED Table”
Section 26.4.15, “The INFORMATION_SCHEMA INNODB_FT_CONFIG Table”
Section 26.4.17, “The INFORMATION_SCHEMA INNODB_FT_DELETED Table”
Section 26.4.18, “The INFORMATION_SCHEMA INNODB_FT_INDEX_CACHE Table”
Section 26.4.19, “The INFORMATION_SCHEMA INNODB_FT_INDEX_TABLE Table”

innodb_ft_cache_size

Section 15.6.2.4, “InnoDB Full-Text Indexes”
Section 15.15.4, “InnoDB INFORMATION_SCHEMA FULLTEXT Index Tables”
Section 15.14, “InnoDB Startup Options and System Variables”
MySQL Glossary
Section 26.4.18, “The INFORMATION_SCHEMA INNODB_FT_INDEX_CACHE Table”

innodb_ft_enable_diag_print

Section 15.14, “InnoDB Startup Options and System Variables”

innodb_ft_enable_stopword

Section 12.10.2, “Boolean Full-Text Searches”
Section 12.10.6, “Fine-Tuning MySQL Full-Text Search”
Section 15.14, “InnoDB Startup Options and System Variables”
Section 12.10.1, “Natural Language Full-Text Searches”

innodb_ft_max_token_size

Section 12.10.2, “Boolean Full-Text Searches”
Section 12.10.6, “Fine-Tuning MySQL Full-Text Search”
Section 12.10.4, “Full-Text Stopwords”
Section 15.14, “InnoDB Startup Options and System Variables”
Section 12.10.8, “ngram Full-Text Parser”

innodb_ft_min_token_size

Section 12.10.2, “Boolean Full-Text Searches”
Section 12.10.6, “Fine-Tuning MySQL Full-Text Search”
Section 12.10.4, “Full-Text Stopwords”
Section 15.14, “InnoDB Startup Options and System Variables”
Section 12.10.9, “MeCab Full-Text Parser Plugin”
Section 12.10.1, “Natural Language Full-Text Searches”
Section 12.10.8, “ngram Full-Text Parser”

innodb_ft_num_word_optimize

Section 12.10.6, “Fine-Tuning MySQL Full-Text Search”
Section 15.14, “InnoDB Startup Options and System Variables”
Section 13.7.3.4, “OPTIMIZE TABLE Statement”

innodb_ft_result_cache_limit

Section 15.14, “InnoDB Startup Options and System Variables”

innodb_ft_server_stopword_table

Section 12.10.2, “Boolean Full-Text Searches”
Section 12.10.6, “Fine-Tuning MySQL Full-Text Search”
Section 12.10.4, “Full-Text Stopwords”
Section 15.14, “InnoDB Startup Options and System Variables”
Section 12.10.1, “Natural Language Full-Text Searches”
Section 26.4.16, “The INFORMATION_SCHEMA INNODB_FT_DEFAULT_STOPWORD Table”

innodb_ft_sort_pll_degree

Section 15.6.2.4, “InnoDB Full-Text Indexes”
Section 15.14, “InnoDB Startup Options and System Variables”

innodb_ft_total_cache_size

Section 15.6.2.4, “InnoDB Full-Text Indexes”
Section 15.15.4, “InnoDB INFORMATION_SCHEMA FULLTEXT Index Tables”
Section 15.14, “InnoDB Startup Options and System Variables”
Section 26.4.18, “The INFORMATION_SCHEMA INNODB_FT_INDEX_CACHE Table”

innodb_ft_user_stopword_table

Section 12.10.2, “Boolean Full-Text Searches”
Section 12.10.6, “Fine-Tuning MySQL Full-Text Search”
Section 12.10.4, “Full-Text Stopwords”
Section 15.14, “InnoDB Startup Options and System Variables”
Section 12.10.1, “Natural Language Full-Text Searches”
Section 26.4.16, “The INFORMATION_SCHEMA INNODB_FT_DEFAULT_STOPWORD Table”

innodb_idle_flush_pct

Section 15.8.3.5, “Configuring Buffer Pool Flushing”
Section 15.14, “InnoDB Startup Options and System Variables”
Section 8.5.8, “Optimizing InnoDB Disk I/O”
Section 1.3, “What Is New in MySQL 8.0”

innodb_io_capacity

Section 15.8.3.5, “Configuring Buffer Pool Flushing”
Section 15.8.7, “Configuring InnoDB I/O Capacity”
Section 15.14, “InnoDB Startup Options and System Variables”
Section A.16, “MySQL 8.0 FAQ: InnoDB Change Buffer”
Section 8.5.8, “Optimizing InnoDB Disk I/O”

innodb_io_capacity_max

Section 15.8.3.5, “Configuring Buffer Pool Flushing”
Section 15.8.7, “Configuring InnoDB I/O Capacity”
Section 15.14, “InnoDB Startup Options and System Variables”
Section 8.5.8, “Optimizing InnoDB Disk I/O”

innodb_limit_optimistic_insert_debug

Section 15.14, “InnoDB Startup Options and System Variables”

innodb_lock_wait_timeout

Section 15.6.1.5, “Converting Tables from MyISAM to InnoDB”
Section 15.7.5.2, “Deadlock Detection”
Section 15.7.5, “Deadlocks in InnoDB”
Section 15.14, “InnoDB Startup Options and System Variables”
Section 8.11.1, “Internal Locking Methods”
MySQL Glossary
Section 17.1.6.3, “Replica Server Options and Variables”
Section 17.5.1.32, “Replication Retries and Timeouts”
Section 1.3, “What Is New in MySQL 8.0”

innodb_log_buffer_size

Section 15.8.1, “InnoDB Startup Configuration”
Section 15.14, “InnoDB Startup Options and System Variables”
Section 15.5.4, “Log Buffer”
MySQL Glossary
Section 8.5.4, “Optimizing InnoDB Redo Logging”
Section 1.3, “What Is New in MySQL 8.0”

innodb_log_checkpoint_fuzzy_now

Section 15.14, “InnoDB Startup Options and System Variables”

innodb_log_checkpoint_now

Section 15.14, “InnoDB Startup Options and System Variables”

innodb_log_checksums

Section 15.14, “InnoDB Startup Options and System Variables”

innodb_log_compressed_pages

Section 15.9.1.6, “Compression for OLTP Workloads”
Section 15.14, “InnoDB Startup Options and System Variables”
Section 8.5.8, “Optimizing InnoDB Disk I/O”

innodb_log_file_size

Section 2.11.4, “Changes in MySQL 8.0”
Section 15.8.3.5, “Configuring Buffer Pool Flushing”
Section 15.8.2, “Configuring InnoDB for Read-Only Operation”
Section 15.8.12, “Enabling Automatic Configuration for a Dedicated MySQL Server”
Section 2.10.1, “Initializing the Data Directory”
Section 15.8.1, “InnoDB Startup Configuration”
Section 15.14, “InnoDB Startup Options and System Variables”
Section 8.5.8, “Optimizing InnoDB Disk I/O”
Section 8.5.4, “Optimizing InnoDB Redo Logging”
Section 15.6.5, “Redo Log”
Section 1.3, “What Is New in MySQL 8.0”

innodb_log_files_in_group

Section 2.11.4, “Changes in MySQL 8.0”
Section 15.8.12, “Enabling Automatic Configuration for a Dedicated MySQL Server”
Section 15.8.1, “InnoDB Startup Configuration”
Section 15.14, “InnoDB Startup Options and System Variables”
Section 8.5.4, “Optimizing InnoDB Redo Logging”
Section 15.6.5, “Redo Log”
Section 1.3, “What Is New in MySQL 8.0”

innodb_log_group_home_dir

Section 5.6.7.3, “Cloning Remote Data”
Section 2.10.1, “Initializing the Data Directory”
Section 15.8.1, “InnoDB Startup Configuration”
Section 15.14, “InnoDB Startup Options and System Variables”
Section 15.6.5, “Redo Log”
Section 15.6.3.4, “Undo Tablespaces”
Section 18.5.6, “Using MySQL Enterprise Backup with Group Replication”

innodb_log_spin_cpu_abs_lwm

Section 15.14, “InnoDB Startup Options and System Variables”
Section 8.5.4, “Optimizing InnoDB Redo Logging”
Section 1.3, “What Is New in MySQL 8.0”

innodb_log_spin_cpu_pct_hwm

Section 15.14, “InnoDB Startup Options and System Variables”
Section 8.5.4, “Optimizing InnoDB Redo Logging”
Section 1.3, “What Is New in MySQL 8.0”

innodb_log_wait_for_flush_spin_hwm

Section 15.14, “InnoDB Startup Options and System Variables”
Section 8.5.4, “Optimizing InnoDB Redo Logging”
Section 1.3, “What Is New in MySQL 8.0”

innodb_log_write_ahead_size

Section 15.14, “InnoDB Startup Options and System Variables”
Section 8.5.4, “Optimizing InnoDB Redo Logging”

innodb_log_writer_threads

Section 15.14, “InnoDB Startup Options and System Variables”
Section 8.5.4, “Optimizing InnoDB Redo Logging”

innodb_lru_scan_depth

Section 15.8.3.5, “Configuring Buffer Pool Flushing”
Section 15.14, “InnoDB Startup Options and System Variables”

innodb_max_dirty_pages_pct

Section 2.11.4, “Changes in MySQL 8.0”
Section 15.8.3.5, “Configuring Buffer Pool Flushing”
Section 15.14, “InnoDB Startup Options and System Variables”
Section 8.5.8, “Optimizing InnoDB Disk I/O”
Section 1.3, “What Is New in MySQL 8.0”

innodb_max_dirty_pages_pct_lwm

Section 2.11.4, “Changes in MySQL 8.0”
Section 15.8.3.5, “Configuring Buffer Pool Flushing”
Section 15.14, “InnoDB Startup Options and System Variables”
Section 1.3, “What Is New in MySQL 8.0”

innodb_max_purge_lag

Section 15.3, “InnoDB Multi-Versioning”
Section 15.14, “InnoDB Startup Options and System Variables”
MySQL Glossary
Section 15.8.9, “Purge Configuration”

innodb_max_purge_lag_delay

Section 15.14, “InnoDB Startup Options and System Variables”
Section 15.8.9, “Purge Configuration”

innodb_max_undo_log_size

Section 2.11.4, “Changes in MySQL 8.0”
Section 15.14, “InnoDB Startup Options and System Variables”
Section 15.6.3.4, “Undo Tablespaces”

innodb_merge_threshold_set_all_debug

Section 15.14, “InnoDB Startup Options and System Variables”

innodb_monitor_disable

Section 15.15.6, “InnoDB INFORMATION_SCHEMA Metrics Table”
Section 15.14, “InnoDB Startup Options and System Variables”
Section 13.7.7.15, “SHOW ENGINE Statement”
Section 26.4.21, “The INFORMATION_SCHEMA INNODB_METRICS Table”

innodb_monitor_enable

Section 15.15.6, “InnoDB INFORMATION_SCHEMA Metrics Table”
Section 15.14, “InnoDB Startup Options and System Variables”
Section 13.7.7.15, “SHOW ENGINE Statement”
Section 26.4.21, “The INFORMATION_SCHEMA INNODB_METRICS Table”

innodb_monitor_reset

Section 15.15.6, “InnoDB INFORMATION_SCHEMA Metrics Table”
Section 15.14, “InnoDB Startup Options and System Variables”
Section 26.4.21, “The INFORMATION_SCHEMA INNODB_METRICS Table”

innodb_monitor_reset_all

Section 15.15.6, “InnoDB INFORMATION_SCHEMA Metrics Table”
Section 15.14, “InnoDB Startup Options and System Variables”
Section 26.4.21, “The INFORMATION_SCHEMA INNODB_METRICS Table”

innodb_numa_interleave

Section 15.14, “InnoDB Startup Options and System Variables”

innodb_old_blocks_pct

Section 15.14, “InnoDB Startup Options and System Variables”
Section 15.8.3.3, “Making the Buffer Pool Scan Resistant”
MySQL Glossary

innodb_old_blocks_time

Section 15.5.1, “Buffer Pool”
Section 15.14, “InnoDB Startup Options and System Variables”
Section 15.8.3.3, “Making the Buffer Pool Scan Resistant”

innodb_online_alter_log_max_size

Section 15.14, “InnoDB Startup Options and System Variables”
MySQL Glossary
Section 15.12.7, “Online DDL Failure Conditions”
Section 15.12.3, “Online DDL Space Requirements”

innodb_open_files

Section 15.14, “InnoDB Startup Options and System Variables”
Section 5.1.8, “Server System Variables”
Section 1.3, “What Is New in MySQL 8.0”

innodb_optimize_fulltext_only

Section 12.10.6, “Fine-Tuning MySQL Full-Text Search”
Section 15.6.2.4, “InnoDB Full-Text Indexes”
Section 15.15.4, “InnoDB INFORMATION_SCHEMA FULLTEXT Index Tables”
Section 15.14, “InnoDB Startup Options and System Variables”
Section 13.7.3.4, “OPTIMIZE TABLE Statement”
Section 26.4.19, “The INFORMATION_SCHEMA INNODB_FT_INDEX_TABLE Table”

innodb_page_cleaners

Section 15.8.3.5, “Configuring Buffer Pool Flushing”
Section 15.14, “InnoDB Startup Options and System Variables”
MySQL Glossary

innodb_page_size

Section 5.6.7.3, “Cloning Remote Data”
Section 15.6.1.5, “Converting Tables from MyISAM to InnoDB”
Section 13.1.20, “CREATE TABLE Statement”
Section 13.1.21, “CREATE TABLESPACE Statement”
Section 15.9.1.2, “Creating Compressed Tables”
Section 15.8.10.3, “Estimating ANALYZE TABLE Complexity for InnoDB Tables”
Section 15.8.3.7, “Excluding Buffer Pool Pages from Core Files”
Section 15.11.2, “File Space Management”
Section 15.6.3.3, “General Tablespaces”
Section 15.9.1.5, “How Compression Works for InnoDB Tables”
Section 15.6.1.3, “Importing InnoDB Tables”
Section 15.22, “InnoDB Limits”
Section 15.9.2, “InnoDB Page Compression”
Section 15.23, “InnoDB Restrictions and Limitations”
Section 15.8.1, “InnoDB Startup Configuration”
Section 15.14, “InnoDB Startup Options and System Variables”
Section 8.4.7, “Limits on Table Column Count and Row Size”
MySQL Glossary
Section 8.5.8, “Optimizing InnoDB Disk I/O”
Section 8.5.4, “Optimizing InnoDB Redo Logging”
Section 15.9.1.1, “Overview of Table Compression”
Section 15.6.3.9, “Tablespace AUTOEXTEND_SIZE Configuration”
Section 26.3.15, “The INFORMATION_SCHEMA FILES Table”
Section 15.6.2.2, “The Physical Structure of an InnoDB Index”
Section 15.20.9, “Troubleshooting the InnoDB memcached Plugin”
Section 15.6.3.4, “Undo Tablespaces”

innodb_parallel_read_threads

Section 13.7.3.2, “CHECK TABLE Statement”
Section 15.12.5, “Configuring Parallel Threads for Online DDL Operations”
Section 15.14, “InnoDB Startup Options and System Variables”
Section 1.3, “What Is New in MySQL 8.0”

innodb_print_all_deadlocks

Section 15.7.5.1, “An InnoDB Deadlock Example”
Section 15.6.1.5, “Converting Tables from MyISAM to InnoDB”
Section 15.7.5, “Deadlocks in InnoDB”
Section 15.7.5.3, “How to Minimize and Handle Deadlocks”
Section 15.14, “InnoDB Startup Options and System Variables”
Section 15.21, “InnoDB Troubleshooting”

innodb_print_ddl_logs

Section 13.1.1, “Atomic Data Definition Statement Support”
Section 15.14, “InnoDB Startup Options and System Variables”

innodb_purge_batch_size

Section 15.14, “InnoDB Startup Options and System Variables”
Section 15.8.9, “Purge Configuration”

innodb_purge_rseg_truncate_frequency

Section 15.14, “InnoDB Startup Options and System Variables”
Section 15.8.9, “Purge Configuration”
Section 15.6.3.4, “Undo Tablespaces”

innodb_purge_threads

Section 15.14, “InnoDB Startup Options and System Variables”
MySQL Glossary
Section 15.8.9, “Purge Configuration”

innodb_random_read_ahead

Section 15.8.3.4, “Configuring InnoDB Buffer Pool Prefetching (Read-Ahead)”
Section 15.14, “InnoDB Startup Options and System Variables”
MySQL Glossary

innodb_read_ahead_threshold

Section 15.8.3.4, “Configuring InnoDB Buffer Pool Prefetching (Read-Ahead)”
Section 15.14, “InnoDB Startup Options and System Variables”

innodb_read_io_threads

Section 15.8.5, “Configuring the Number of Background InnoDB I/O Threads”
Section 15.17.3, “InnoDB Standard Monitor and Lock Monitor Output”
Section 15.14, “InnoDB Startup Options and System Variables”
Section 15.8.6, “Using Asynchronous I/O on Linux”

innodb_read_only

Section 13.7.3.1, “ANALYZE TABLE Statement”
Section 15.8.2, “Configuring InnoDB for Read-Only Operation”
Section 14.7, “Data Dictionary Usage Differences”
Section 15.14, “InnoDB Startup Options and System Variables”
Section 8.2.3, “Optimizing INFORMATION_SCHEMA Queries”
Section 5.1.8, “Server System Variables”
Section 26.3.34, “The INFORMATION_SCHEMA STATISTICS Table”
Section 26.3.38, “The INFORMATION_SCHEMA TABLES Table”

innodb_redo_log_archive_dirs

Section 15.14, “InnoDB Startup Options and System Variables”
Section 15.6.5, “Redo Log”

innodb_redo_log_capacity

Section 2.11.4, “Changes in MySQL 8.0”
Section 15.8.12, “Enabling Automatic Configuration for a Dedicated MySQL Server”
Section 15.8.1, “InnoDB Startup Configuration”
Section 15.14, “InnoDB Startup Options and System Variables”
Section 8.5.8, “Optimizing InnoDB Disk I/O”
Section 8.5.4, “Optimizing InnoDB Redo Logging”
Section 15.6.5, “Redo Log”
Section 5.1.10, “Server Status Variables”
Section 1.3, “What Is New in MySQL 8.0”

innodb_redo_log_encrypt

Section 5.6.7.5, “Cloning Encrypted Data”
Section 15.13, “InnoDB Data-at-Rest Encryption”
Section 15.14, “InnoDB Startup Options and System Variables”

innodb_replication_delay

Section 15.14, “InnoDB Startup Options and System Variables”

innodb_rollback_on_timeout

Section 15.14, “InnoDB Startup Options and System Variables”

innodb_rollback_segments

Section 15.14, “InnoDB Startup Options and System Variables”
Section 15.6.6, “Undo Logs”
Section 15.6.3.4, “Undo Tablespaces”
Section 1.3, “What Is New in MySQL 8.0”

innodb_saved_page_number_debug

Section 15.14, “InnoDB Startup Options and System Variables”

innodb_segment_reserve_factor

Section 15.11.2, “File Space Management”
Section 15.14, “InnoDB Startup Options and System Variables”
Section 1.3, “What Is New in MySQL 8.0”

innodb_sort_buffer_size

Section 15.14, “InnoDB Startup Options and System Variables”
MySQL Glossary
Section 15.12.4, “Online DDL Memory Management”
Section 15.12.3, “Online DDL Space Requirements”

innodb_spin_wait_delay

Section 15.8.8, “Configuring Spin Lock Polling”
Section 15.14, “InnoDB Startup Options and System Variables”

innodb_spin_wait_pause_multiplier

Section 15.8.8, “Configuring Spin Lock Polling”
Section 15.14, “InnoDB Startup Options and System Variables”
Section 1.3, “What Is New in MySQL 8.0”

innodb_stats_auto_recalc

Section 15.8.10.1.1, “Configuring Automatic Statistics Calculation for Persistent Optimizer Statistics”
Section 15.8.10, “Configuring Optimizer Statistics for InnoDB”
Section 15.8.10.1.2, “Configuring Optimizer Statistics Parameters for Individual Tables”
Section 13.1.20, “CREATE TABLE Statement”
Section 15.8.10.1.6, “InnoDB Persistent Statistics Tables Example”
Section 15.14, “InnoDB Startup Options and System Variables”

innodb_stats_include_delete_marked

Section 15.8.10.1.4, “Including Delete-marked Records in Persistent Statistics Calculations”
Section 15.14, “InnoDB Startup Options and System Variables”

innodb_stats_method

Section 8.3.8, “InnoDB and MyISAM Index Statistics Collection”
Section 15.14, “InnoDB Startup Options and System Variables”
MySQL Glossary

innodb_stats_on_metadata

Section 15.8.10.2, “Configuring Non-Persistent Optimizer Statistics Parameters”
Section 15.14, “InnoDB Startup Options and System Variables”

innodb_stats_persistent

Section 13.7.3.1, “ANALYZE TABLE Statement”
Section 15.8.10.2, “Configuring Non-Persistent Optimizer Statistics Parameters”
Section 15.8.10, “Configuring Optimizer Statistics for InnoDB”
Section 15.8.10.1.2, “Configuring Optimizer Statistics Parameters for Individual Tables”
Section 15.8.10.1, “Configuring Persistent Optimizer Statistics Parameters”
Section 13.1.15, “CREATE INDEX Statement”
Section 13.1.20, “CREATE TABLE Statement”
Section 15.8.10.3, “Estimating ANALYZE TABLE Complexity for InnoDB Tables”
Section 15.14, “InnoDB Startup Options and System Variables”
Section 8.5.10, “Optimizing InnoDB for Systems with Many Tables”

innodb_stats_persistent_sample_pages

Section 13.7.3.1, “ANALYZE TABLE Statement”
Section 15.8.10.1.2, “Configuring Optimizer Statistics Parameters for Individual Tables”
Section 15.8.10.1.3, “Configuring the Number of Sampled Pages for InnoDB Optimizer Statistics”
Section 15.8.10.3, “Estimating ANALYZE TABLE Complexity for InnoDB Tables”
Section 15.14, “InnoDB Startup Options and System Variables”

innodb_stats_sample_pages

Section 15.14, “InnoDB Startup Options and System Variables”

innodb_stats_transient_sample_pages

Section 13.7.3.1, “ANALYZE TABLE Statement”
Section 15.8.10.2, “Configuring Non-Persistent Optimizer Statistics Parameters”
Section 15.8.10.3, “Estimating ANALYZE TABLE Complexity for InnoDB Tables”
Section 15.14, “InnoDB Startup Options and System Variables”

innodb_status_output

Section 15.17.2, “Enabling InnoDB Monitors”
Section 15.14, “InnoDB Startup Options and System Variables”

innodb_status_output_locks

Section 15.17.2, “Enabling InnoDB Monitors”
Section 15.14, “InnoDB Startup Options and System Variables”

innodb_strict_mode

Section 13.1.20, “CREATE TABLE Statement”
Section 13.1.21, “CREATE TABLESPACE Statement”
Section 13.1.20.2, “CREATE TEMPORARY TABLE Statement”
Section 15.9.1.2, “Creating Compressed Tables”
Section 15.9.1.5, “How Compression Works for InnoDB Tables”
Section 15.14, “InnoDB Startup Options and System Variables”
MySQL Glossary
Section 5.1.11, “Server SQL Modes”
Section 15.9.1.7, “SQL Compression Syntax Warnings and Errors”
Section 1.3, “What Is New in MySQL 8.0”

innodb_sync_array_size

Section 15.14, “InnoDB Startup Options and System Variables”

innodb_sync_debug

Section 15.14, “InnoDB Startup Options and System Variables”
Section 2.9.7, “MySQL Source-Configuration Options”

innodb_sync_spin_loops

Section 15.14, “InnoDB Startup Options and System Variables”

innodb_table_locks

Section 15.14, “InnoDB Startup Options and System Variables”
Section 15.7.3, “Locks Set by Different SQL Statements in InnoDB”

innodb_temp_data_file_path

Section 15.8.2, “Configuring InnoDB for Read-Only Operation”
Section 15.8.1, “InnoDB Startup Configuration”
Section 15.14, “InnoDB Startup Options and System Variables”
MySQL Glossary
Section 15.6.3.5, “Temporary Tablespaces”
Section 26.3.15, “The INFORMATION_SCHEMA FILES Table”

innodb_temp_tablespaces_dir

Section 15.8.1, “InnoDB Startup Configuration”
Section 15.14, “InnoDB Startup Options and System Variables”
Section 15.6.5, “Redo Log”
Section 15.6.3.5, “Temporary Tablespaces”
Section 1.3, “What Is New in MySQL 8.0”

innodb_thread_concurrency

Section 15.8.4, “Configuring Thread Concurrency for InnoDB”
Section 15.17.3, “InnoDB Standard Monitor and Lock Monitor Output”
Section 15.14, “InnoDB Startup Options and System Variables”
Section A.15, “MySQL 8.0 FAQ: MySQL Enterprise Thread Pool”
Section 8.5.9, “Optimizing InnoDB Configuration Variables”

innodb_thread_sleep_delay

Section 15.8.4, “Configuring Thread Concurrency for InnoDB”
Section 15.14, “InnoDB Startup Options and System Variables”

innodb_tmpdir

Section 15.14, “InnoDB Startup Options and System Variables”
Section 15.12.7, “Online DDL Failure Conditions”
Section 15.12.3, “Online DDL Space Requirements”
Section 15.6.5, “Redo Log”

innodb_trx_purge_view_update_only_debug

Section 15.14, “InnoDB Startup Options and System Variables”

innodb_trx_rseg_n_slots_debug

Section 15.14, “InnoDB Startup Options and System Variables”

innodb_undo_directory

Section 2.11.4, “Changes in MySQL 8.0”
Section 5.6.7.3, “Cloning Remote Data”
Section 15.8.2, “Configuring InnoDB for Read-Only Operation”
Section 13.1.21, “CREATE TABLESPACE Statement”
Section 15.6.1.2, “Creating Tables Externally”
Section 15.6.3.3, “General Tablespaces”
Section 15.18.2, “InnoDB Recovery”
Section 15.8.1, “InnoDB Startup Configuration”
Section 15.14, “InnoDB Startup Options and System Variables”
Section 15.6.3.6, “Moving Tablespace Files While the Server is Offline”
Section 15.6.5, “Redo Log”
Section 15.6.3.4, “Undo Tablespaces”
Section 18.5.6, “Using MySQL Enterprise Backup with Group Replication”
Section 1.3, “What Is New in MySQL 8.0”

innodb_undo_log_encrypt

Section 5.6.7.5, “Cloning Encrypted Data”
Section 15.13, “InnoDB Data-at-Rest Encryption”
Section 15.14, “InnoDB Startup Options and System Variables”

innodb_undo_log_truncate

Section 2.11.4, “Changes in MySQL 8.0”
Section 15.14, “InnoDB Startup Options and System Variables”
Section 15.6.3.4, “Undo Tablespaces”
Section 1.3, “What Is New in MySQL 8.0”

innodb_undo_tablespaces

Section 2.11.4, “Changes in MySQL 8.0”
Section 15.8.2, “Configuring InnoDB for Read-Only Operation”
Section 15.14, “InnoDB Startup Options and System Variables”
MySQL Glossary
Section 15.6.3.4, “Undo Tablespaces”
Section 1.3, “What Is New in MySQL 8.0”

innodb_use_fdatasync

Section 15.14, “InnoDB Startup Options and System Variables”
Section 8.5.8, “Optimizing InnoDB Disk I/O”
Section 5.1.10, “Server Status Variables”
Section 1.3, “What Is New in MySQL 8.0”

innodb_use_native_aio

Section 2.11.4, “Changes in MySQL 8.0”
Section 15.14, “InnoDB Startup Options and System Variables”
MySQL Glossary
Section 8.5.8, “Optimizing InnoDB Disk I/O”
Section 15.8.6, “Using Asynchronous I/O on Linux”

innodb_validate_tablespace_paths

Section 15.6.3.7, “Disabling Tablespace Path Validation”
Section 15.14, “InnoDB Startup Options and System Variables”
Section 1.3, “What Is New in MySQL 8.0”

innodb_version

Section 15.14, “InnoDB Startup Options and System Variables”

innodb_write_io_threads

Section 15.8.5, “Configuring the Number of Background InnoDB I/O Threads”
Section 15.6.4, “Doublewrite Buffer”
Section 15.17.3, “InnoDB Standard Monitor and Lock Monitor Output”
Section 15.14, “InnoDB Startup Options and System Variables”
Section 15.8.6, “Using Asynchronous I/O on Linux”

insert_id

Section 16.8.3, “FEDERATED Storage Engine Notes and Tips”
Section 5.1.8, “Server System Variables”

interactive_timeout

Section B.3.2.9, “Communication Errors and Aborted Connections”
Section 5.1.8, “Server System Variables”

internal_tmp_disk_storage_engine

Section 8.12.3.1, “How MySQL Uses Memory”
Section 15.8.1, “InnoDB Startup Configuration”
Section 15.14, “InnoDB Startup Options and System Variables”
Section 8.4.4, “Internal Temporary Table Use in MySQL”
Section 8.2.2.4, “Optimizing Derived Tables, View References, and Common Table Expressions with Merging or Materialization”
Section 5.1.8, “Server System Variables”
Section 15.6.3.5, “Temporary Tablespaces”
Section 1.3, “What Is New in MySQL 8.0”

internal_tmp_mem_storage_engine

Section 2.11.4, “Changes in MySQL 8.0”
Section 8.4.4, “Internal Temporary Table Use in MySQL”
Section 5.1.8, “Server System Variables”
Section 1.3, “What Is New in MySQL 8.0”

J

[index top]

join_buffer_size

Section 8.2.1.12, “Block Nested-Loop and Batched Key Access Joins”
Section 8.2.1.4, “Hash Join Optimization”
Section 8.2.1.7, “Nested-Loop Join Algorithms”
Section 5.1.8, “Server System Variables”
Section 1.3, “What Is New in MySQL 8.0”

K

[index top]

keep_files_on_create

Section 5.1.8, “Server System Variables”

key_buffer_size

Section 8.6.2, “Bulk Data Loading for MyISAM Tables”
Section 15.6.1.5, “Converting Tables from MyISAM to InnoDB”
Section 8.8.5, “Estimating Query Performance”
Section 8.12.3.1, “How MySQL Uses Memory”
Section 7.6.3, “How to Repair MyISAM Tables”
Section 15.8.1, “InnoDB Startup Configuration”
Section B.3.7, “Known Issues in MySQL”
Section 8.10.2.2, “Multiple Key Caches”
Section 8.2.5.3, “Optimizing DELETE Statements”
Section 8.6.3, “Optimizing REPAIR TABLE Statements”
Section 8.10.2.6, “Restructuring a Key Cache”
Section 5.1.10, “Server Status Variables”
Section 5.1.8, “Server System Variables”
Section 5.1.9.5, “Structured System Variables”
Section 8.10.2, “The MyISAM Key Cache”

key_cache_age_threshold

Section 8.10.2.3, “Midpoint Insertion Strategy”
Section 5.1.8, “Server System Variables”
Section 5.1.9.5, “Structured System Variables”

key_cache_block_size

Section 8.10.2.5, “Key Cache Block Size”
Section 8.10.2.6, “Restructuring a Key Cache”
Section 5.1.8, “Server System Variables”
Section 5.1.9.5, “Structured System Variables”

key_cache_division_limit

Section 8.10.2.3, “Midpoint Insertion Strategy”
Section 5.1.8, “Server System Variables”
Section 5.1.9.5, “Structured System Variables”

keyring_aws_cmk_id

Section 6.4.4.19, “Keyring System Variables”
Section 6.4.4.16, “Plugin-Specific Keyring Key-Management Functions”
Section 6.4.4.9, “Using the keyring_aws Amazon Web Services Keyring Plugin”

keyring_aws_conf_file

Section 6.4.4.19, “Keyring System Variables”
Section 6.4.4.9, “Using the keyring_aws Amazon Web Services Keyring Plugin”

keyring_aws_data_file

Section 6.4.4.19, “Keyring System Variables”
Section 6.4.4.16, “Plugin-Specific Keyring Key-Management Functions”
Section 6.4.4.9, “Using the keyring_aws Amazon Web Services Keyring Plugin”

keyring_aws_region

Section 6.4.4.19, “Keyring System Variables”

keyring_encrypted_file_data

Section 15.13, “InnoDB Data-at-Rest Encryption”
Section 6.4.4.19, “Keyring System Variables”
Section 2.9.7, “MySQL Source-Configuration Options”
Section 6.4.4.7, “Using the keyring_encrypted_file Encrypted File-Based Keyring Plugin”

keyring_encrypted_file_password

Section 6.4.4.19, “Keyring System Variables”
Section 6.4.4.7, “Using the keyring_encrypted_file Encrypted File-Based Keyring Plugin”

keyring_file_data

Section 15.13, “InnoDB Data-at-Rest Encryption”
Section 2.4.3, “Installing and Using the MySQL Launch Daemon”
Section 6.4.4.19, “Keyring System Variables”
Section 6.4.4.14, “Migrating Keys Between Keyring Keystores”
Section 2.9.7, “MySQL Source-Configuration Options”
Section 6.4.4.6, “Using the keyring_file File-Based Keyring Plugin”

keyring_hashicorp_auth_path

Section 6.4.4.19, “Keyring System Variables”
Section 6.4.4.10, “Using the HashiCorp Vault Keyring Plugin”

keyring_hashicorp_ca_path

Section 6.4.4.19, “Keyring System Variables”
Section 6.4.4.10, “Using the HashiCorp Vault Keyring Plugin”

keyring_hashicorp_caching

Section 6.4.4.19, “Keyring System Variables”
Section 6.4.4.10, “Using the HashiCorp Vault Keyring Plugin”

keyring_hashicorp_commit_auth_path

Section 6.4.4.19, “Keyring System Variables”

keyring_hashicorp_commit_ca_path

Section 6.4.4.19, “Keyring System Variables”

keyring_hashicorp_commit_caching

Section 6.4.4.19, “Keyring System Variables”

keyring_hashicorp_commit_role_id

Section 6.4.4.19, “Keyring System Variables”
Section 6.4.4.10, “Using the HashiCorp Vault Keyring Plugin”

keyring_hashicorp_commit_server_url

Section 6.4.4.19, “Keyring System Variables”

keyring_hashicorp_commit_store_path

Section 6.4.4.19, “Keyring System Variables”
Section 6.4.4.10, “Using the HashiCorp Vault Keyring Plugin”

keyring_hashicorp_role_id

Section 6.4.4.19, “Keyring System Variables”
Section 6.4.4.10, “Using the HashiCorp Vault Keyring Plugin”

keyring_hashicorp_secret_id

Section 6.4.4.19, “Keyring System Variables”
Section 6.4.4.10, “Using the HashiCorp Vault Keyring Plugin”

keyring_hashicorp_server_url

Section 6.4.4.19, “Keyring System Variables”
Section 6.4.4.10, “Using the HashiCorp Vault Keyring Plugin”

keyring_hashicorp_store_path

Section 6.4.4.19, “Keyring System Variables”
Section 6.4.4.10, “Using the HashiCorp Vault Keyring Plugin”

keyring_oci_ca_certificate

Section 6.4.4.19, “Keyring System Variables”
Section 6.4.4.12, “Using the Oracle Cloud Infrastructure Vault Keyring Plugin”

keyring_oci_compartment

Section 6.4.4.19, “Keyring System Variables”
Section 6.4.4.12, “Using the Oracle Cloud Infrastructure Vault Keyring Plugin”

keyring_oci_encryption_endpoint

Section 6.4.4.19, “Keyring System Variables”
Section 6.4.4.12, “Using the Oracle Cloud Infrastructure Vault Keyring Plugin”

keyring_oci_key_file

Section 6.4.4.19, “Keyring System Variables”
Section 6.4.4.12, “Using the Oracle Cloud Infrastructure Vault Keyring Plugin”

keyring_oci_key_fingerprint

Section 6.4.4.19, “Keyring System Variables”
Section 6.4.4.12, “Using the Oracle Cloud Infrastructure Vault Keyring Plugin”

keyring_oci_management_endpoint

Section 6.4.4.19, “Keyring System Variables”
Section 6.4.4.12, “Using the Oracle Cloud Infrastructure Vault Keyring Plugin”

keyring_oci_master_key

Section 6.4.4.19, “Keyring System Variables”
Section 6.4.4.12, “Using the Oracle Cloud Infrastructure Vault Keyring Plugin”

keyring_oci_secrets_endpoint

Section 6.4.4.19, “Keyring System Variables”
Section 6.4.4.12, “Using the Oracle Cloud Infrastructure Vault Keyring Plugin”

keyring_oci_tenancy

Section 6.4.4.19, “Keyring System Variables”
Section 6.4.4.12, “Using the Oracle Cloud Infrastructure Vault Keyring Plugin”

keyring_oci_user

Section 6.4.4.19, “Keyring System Variables”
Section 6.4.4.12, “Using the Oracle Cloud Infrastructure Vault Keyring Plugin”

keyring_oci_vaults_endpoint

Section 6.4.4.19, “Keyring System Variables”
Section 6.4.4.12, “Using the Oracle Cloud Infrastructure Vault Keyring Plugin”

keyring_oci_virtual_vault

Section 6.4.4.19, “Keyring System Variables”
Section 6.4.4.12, “Using the Oracle Cloud Infrastructure Vault Keyring Plugin”

keyring_okv_conf_dir

Section 6.4.4.19, “Keyring System Variables”
Section 6.4.4.8, “Using the keyring_okv KMIP Plugin”

keyring_operations

Section 6.4.4.19, “Keyring System Variables”
Section 6.4.4.14, “Migrating Keys Between Keyring Keystores”

L

[index top]

large_files_support

Section 24.6, “Restrictions and Limitations on Partitioning”
Section 5.1.8, “Server System Variables”

large_page_size

Section 5.1.8, “Server System Variables”

large_pages

Section 5.1.8, “Server System Variables”

last_insert_id

Section 5.4.4.3, “Mixed Binary Logging Format”
Section 17.5.1.39, “Replication and Variables”
Section 5.1.8, “Server System Variables”

lc_messages

Section 5.1.8, “Server System Variables”
Section 10.12, “Setting the Error Message Language”

lc_messages_dir

Section 5.1.8, “Server System Variables”
Section 10.12, “Setting the Error Message Language”

lc_time_names

Section 12.7, “Date and Time Functions”
Section 5.4.4.3, “Mixed Binary Logging Format”
Section 10.16, “MySQL Server Locale Support”
Section 17.5.1.39, “Replication and Variables”
Section 5.1.8, “Server System Variables”
Section 12.8, “String Functions and Operators”

license

Section 5.1.8, “Server System Variables”

local

Section 13.2.10, “LOAD XML Statement”

local_infile

Section 2.11.4, “Changes in MySQL 8.0”
Section 13.2.9, “LOAD DATA Statement”
Section 2.9.7, “MySQL Source-Configuration Options”
Section 6.1.6, “Security Considerations for LOAD DATA LOCAL”
Section 5.1.8, “Server System Variables”

lock_order

Section 5.9.3, “The LOCK_ORDER Tool”

lock_order_debug_loop

Section 5.9.3, “The LOCK_ORDER Tool”

lock_order_debug_missing_arc

Section 5.9.3, “The LOCK_ORDER Tool”

lock_order_debug_missing_key

Section 5.9.3, “The LOCK_ORDER Tool”

lock_order_debug_missing_unlock

Section 5.9.3, “The LOCK_ORDER Tool”

lock_order_dependencies

Section 5.9.3, “The LOCK_ORDER Tool”

lock_order_extra_dependencies

Section 5.9.3, “The LOCK_ORDER Tool”

lock_order_output_directory

Section 5.9.3, “The LOCK_ORDER Tool”

lock_order_print_txt

Section 5.9.3, “The LOCK_ORDER Tool”

lock_order_trace_loop

Section 5.9.3, “The LOCK_ORDER Tool”

lock_order_trace_missing_arc

Section 5.9.3, “The LOCK_ORDER Tool”

lock_order_trace_missing_key

Section 5.9.3, “The LOCK_ORDER Tool”

lock_order_trace_missing_unlock

Section 5.9.3, “The LOCK_ORDER Tool”

lock_wait_timeout

Section 13.3.5, “LOCK INSTANCE FOR BACKUP and UNLOCK INSTANCE Statements”
Section 5.1.8, “Server System Variables”

locked_in_memory

Section 5.1.8, “Server System Variables”

log

Section 2.11.4, “Changes in MySQL 8.0”
Section 15.8.3.1, “Configuring InnoDB Buffer Pool Size”
Section 18.3.1, “Group Replication Requirements”
Section 15.14, “InnoDB Startup Options and System Variables”
Section 17.2.2.3, “Startup Options and Replication Channels”
Section 15.20.7, “The InnoDB memcached Plugin and Replication”

log_bin

Section 17.1.6.4, “Binary Logging Options and Variables”
Section 2.11.4, “Changes in MySQL 8.0”
Section 17.5.5, “How to Report Replication Bugs or Problems”
Section 23.4.3.9.2, “NDB Cluster System Variables”
Section 17.1.6.3, “Replica Server Options and Variables”
Section 17.5.1.34, “Replication and Transaction Inconsistencies”
Section 13.4.1.2, “RESET MASTER Statement”
Section 5.4.4.2, “Setting The Binary Log Format”
Section 17.1.2.1, “Setting the Replication Source Configuration”
Section 5.4.4, “The Binary Log”
Section 23.3.7, “Upgrading and Downgrading NDB Cluster”

log_bin_basename

Section 17.1.6.4, “Binary Logging Options and Variables”
Section 5.4.4, “The Binary Log”

log_bin_index

Section 17.1.6.4, “Binary Logging Options and Variables”

log_bin_trust_function_creators

Section 17.1.6.4, “Binary Logging Options and Variables”
Section A.4, “MySQL 8.0 FAQ: Stored Procedures and Functions”
Section 25.7, “Stored Program Binary Logging”

log_bin_use_v

Section 17.1.6.4, “Binary Logging Options and Variables”
Section 23.4.3.9.1, “MySQL Server Options for NDB Cluster”
Section 23.7.11, “NDB Cluster Replication Conflict Resolution”

log_error

Section 5.4.2.2, “Default Error Log Destination Configuration”
Section 5.5.3, “Error Log Components”
Section 5.4.2.7, “Error Logging in JSON Format”
Section 2.4.3, “Installing and Using the MySQL Launch Daemon”
Section 2.5.6.2, “More Topics on Deploying MySQL Server with Docker”
Section 5.1.8, “Server System Variables”
Section 1.3, “What Is New in MySQL 8.0”

log_error_services

Section 2.11.4, “Changes in MySQL 8.0”
Section 5.4.2.2, “Default Error Log Destination Configuration”
Section 5.5.3, “Error Log Components”
Section 5.4.2.1, “Error Log Configuration”
Section 5.4.2.7, “Error Logging in JSON Format”
Section 5.4.2.8, “Error Logging to the System Log”
Section 5.4.2.6, “Rule-Based Error Log Filtering (log_filter_dragnet)”
Section 5.1.8, “Server System Variables”
Section 27.12.21.1, “The error_log Table”
Section 1.3, “What Is New in MySQL 8.0”

log_error_suppression_list

Section 5.5.3, “Error Log Components”
Section 5.4.2.1, “Error Log Configuration”
Section 5.4.2.5, “Priority-Based Error Log Filtering (log_filter_internal)”
Section 5.1.8, “Server System Variables”
Section 5.4.2.4, “Types of Error Log Filtering”

log_error_verbosity

Section 2.11.4, “Changes in MySQL 8.0”
Section B.3.2.9, “Communication Errors and Aborted Connections”
Section 6.4.5.5, “Configuring Audit Logging Characteristics”
Section 15.6.3.7, “Disabling Tablespace Path Validation”
Section 5.5.3, “Error Log Components”
Section 5.4.2.1, “Error Log Configuration”
Section 5.4.2.9, “Error Log Output Format”
Section 5.4.2.8, “Error Logging to the System Log”
Section 6.4.1.8, “Kerberos Pluggable Authentication”
Section 5.4.4.3, “Mixed Binary Logging Format”
Section 18.4, “Monitoring Group Replication”
Section B.3.2.7, “MySQL server has gone away”
Section 27.12.9, “Performance Schema Connection Attribute Tables”
Section 27.15, “Performance Schema System Variables”
Section 5.4.2.5, “Priority-Based Error Log Filtering (log_filter_internal)”
Section 5.4.2.6, “Rule-Based Error Log Filtering (log_filter_dragnet)”
Section 5.1.7, “Server Command Options”
Section 5.1.3, “Server Configuration Validation”
Section 5.1.8, “Server System Variables”
Section 5.4.2.4, “Types of Error Log Filtering”
Section 6.4.7.3, “Using MySQL Enterprise Firewall”
Section 1.3, “What Is New in MySQL 8.0”

log_output

Section 5.4.1, “Selecting General Query Log and Slow Query Log Output Destinations”
Section 5.1.8, “Server System Variables”
Section 5.4.3, “The General Query Log”
Section 5.4.5, “The Slow Query Log”

log_queries_not_using_indexes

Section 5.1.8, “Server System Variables”
Section 5.4.5, “The Slow Query Log”

log_raw

Section 5.1.8, “Server System Variables”

log_replica_updates

Section 17.1.6.4, “Binary Logging Options and Variables”
Section 18.3.1, “Group Replication Requirements”
Section 17.1.3.1, “GTID Format and Storage”
Section 17.4.7, “Improving Replication Performance”
Section 23.7.3, “Known Issues in NDB Cluster Replication”
Section 23.4.3.9.1, “MySQL Server Options for NDB Cluster”
Section 23.7.10, “NDB Cluster Replication: Bidirectional and Circular Replication”
Section 23.4.3.9.2, “NDB Cluster System Variables”
Section 17.5.1.34, “Replication and Transaction Inconsistencies”
Section 17.1.2.2, “Setting the Replica Configuration”
Section 17.1.3.8, “Stored Function Examples to Manipulate GTIDs”
Section 5.4.4, “The Binary Log”

log_slave_updates

Section 17.1.6.4, “Binary Logging Options and Variables”
Section 18.3.1, “Group Replication Requirements”
Section 17.1.3.1, “GTID Format and Storage”
Section 17.4.7, “Improving Replication Performance”
Section 23.7.3, “Known Issues in NDB Cluster Replication”
Section 23.4.3.9.1, “MySQL Server Options for NDB Cluster”
Section 23.7.10, “NDB Cluster Replication: Bidirectional and Circular Replication”
Section 23.4.3.9.2, “NDB Cluster System Variables”
Section 17.1.6.3, “Replica Server Options and Variables”
Section 17.5.1.34, “Replication and Transaction Inconsistencies”
Section 17.1.2.2, “Setting the Replica Configuration”
Section 17.1.3.8, “Stored Function Examples to Manipulate GTIDs”
Section 5.4.4, “The Binary Log”

log_slow_admin_statements

Section 5.1.8, “Server System Variables”
Section 5.4.5, “The Slow Query Log”

log_slow_extra

Section 6.4.5.4, “Audit Log File Formats”
Section 6.4.5.5, “Configuring Audit Logging Characteristics”
Section 5.1.8, “Server System Variables”
Section 5.4.5, “The Slow Query Log”

log_slow_replica_statements

Section 17.1.6.3, “Replica Server Options and Variables”
Section 5.4.5, “The Slow Query Log”

log_slow_slave_statements

Section 17.1.6.3, “Replica Server Options and Variables”
Section 5.4.5, “The Slow Query Log”

log_statements_unsafe_for_binlog

Section 17.1.6.4, “Binary Logging Options and Variables”

log_syslog

Section 5.1.8, “Server System Variables”

log_syslog_facility

Section 5.4.2.8, “Error Logging to the System Log”
Section 4.3.2, “mysqld_safe — MySQL Server Startup Script”
Section 5.1.8, “Server System Variables”

log_syslog_include_pid

Section 5.4.2.8, “Error Logging to the System Log”
Section 5.1.8, “Server System Variables”

log_syslog_tag

Section 5.4.2.8, “Error Logging to the System Log”
Section 4.3.2, “mysqld_safe — MySQL Server Startup Script”
Section 5.1.8, “Server System Variables”

log_throttle_queries_not_using_indexes

Section 5.1.8, “Server System Variables”
Section 5.4.5, “The Slow Query Log”

log_timestamps

Section 5.4.2.9, “Error Log Output Format”
Section 5.1.8, “Server System Variables”
Section 27.12.21.1, “The error_log Table”
Section 5.4.3, “The General Query Log”
Section 5.4.5, “The Slow Query Log”

long_query_time

Section 5.4, “MySQL Server Logs”
Section 4.5.2, “mysqladmin — A MySQL Server Administration Program”
Section 4.5.4, “mysqldump — A Database Backup Program”
Section 17.1.6.3, “Replica Server Options and Variables”
Section 5.1.10, “Server Status Variables”
Section 5.1.8, “Server System Variables”
Section 5.4.5, “The Slow Query Log”

low_priority_updates

Section A.14, “MySQL 8.0 FAQ: Replication”
Section 5.1.8, “Server System Variables”
Section 8.11.2, “Table Locking Issues”

lower_case_file_system

Section 5.1.8, “Server System Variables”

lower_case_table_names

Section 2.3.3.3.1.7, “Advanced Options”
Section 2.11.4, “Changes in MySQL 8.0”
Section 13.1.20.5, “FOREIGN KEY Constraints”
Section 13.7.1.6, “GRANT Statement”
Section 18.3.1, “Group Replication Requirements”
Section 18.9, “Group Replication System Variables”
Section 17.2.5, “How Servers Evaluate Replication Filtering Rules”
Section 1.5, “How to Report Bugs or Problems”
Section 9.2.3, “Identifier Case Sensitivity”
Section 13.2.6, “IMPORT TABLE Statement”
Section 15.6.1.3, “Importing InnoDB Tables”
Section 15.6.1.4, “Moving or Copying InnoDB Tables”
Section 18.8.3.1, “Online Upgrade Considerations”
Section 2.11.5, “Preparing Your Installation for Upgrade”
Section 17.5.1.39, “Replication and Variables”
Section 13.7.1.8, “REVOKE Statement”
Section 5.1.8, “Server System Variables”
Section 13.7.7.39, “SHOW TABLES Statement”
Section 26.4.9, “The INFORMATION_SCHEMA INNODB_COLUMNS Table”
Section 26.4.23, “The INFORMATION_SCHEMA INNODB_TABLES Table”
Section 10.8.7, “Using Collation in INFORMATION_SCHEMA Searches”
Section 23.2.4, “What is New in NDB Cluster”

M

[index top]

mandatory_roles

Section 6.2.11, “Account Categories”
Section 13.7.1.4, “DROP ROLE Statement”
Section 13.7.1.5, “DROP USER Statement”
Section 6.2.2, “Privileges Provided by MySQL”
Section 13.7.1.8, “REVOKE Statement”
Section 5.1.8, “Server System Variables”
Section 13.7.1.11, “SET ROLE Statement”
Section 13.7.7.21, “SHOW GRANTS Statement”
Section 5.1.9.1, “System Variable Privileges”
Section 6.2.10, “Using Roles”

master

Section 2.11.4, “Changes in MySQL 8.0”

master_info_repository

Section 2.11.4, “Changes in MySQL 8.0”
Section 5.6.7.7, “Cloning for Replication”
Section 18.3.1, “Group Replication Requirements”
Section 17.1.6.3, “Replica Server Options and Variables”
Section 17.2.4.2, “Replication Metadata Repositories”
Section 13.4.2.5, “RESET REPLICA Statement”
Section 17.2.2.3, “Startup Options and Replication Channels”
Section 1.3, “What Is New in MySQL 8.0”

master_verify_checksum

Section 17.1.6.4, “Binary Logging Options and Variables”
MySQL Glossary
Section 5.4.4, “The Binary Log”

max_allowed_packet

Section 12.20.1, “Aggregate Function Descriptions”
Section 5.4.4.5.1, “Behaviors When Binary Log Transaction Compression is Enabled”
Section 2.11.4, “Changes in MySQL 8.0”
Section 5.6.7.3, “Cloning Remote Data”
Section B.3.2.9, “Communication Errors and Aborted Connections”
Section 12.4.2, “Comparison Functions and Operators”
Section 11.7, “Data Type Storage Requirements”
Section B.3.4.6, “Deleting Rows from Related Tables”
Section 8.12.3.1, “How MySQL Uses Memory”
Section B.3.2.3, “Lost connection to MySQL server”
Section B.3.2.7, “MySQL server has gone away”
Section 4.5.4, “mysqldump — A Database Backup Program”
Section 23.7.11, “NDB Cluster Replication Conflict Resolution”
Section B.3.2.8, “Packet Too Large”
Section 17.1.6.3, “Replica Server Options and Variables”
Section 17.5.1.20, “Replication and max_allowed_packet”
Section 5.1.8, “Server System Variables”
Section 12.8, “String Functions and Operators”
Section 11.3.4, “The BLOB and TEXT Types”
Section 11.5, “The JSON Data Type”
Section 5.6.6.3, “Using Version Tokens”
Section 20.5.6.2, “X Plugin Options and System Variables”

max_binlog_cache_size

Section 17.1.6.4, “Binary Logging Options and Variables”
Section 8.12.3.1, “How MySQL Uses Memory”
Section 5.4.4, “The Binary Log”

max_binlog_size

Section 17.1.6.4, “Binary Logging Options and Variables”
Section 17.1.3.1, “GTID Format and Storage”
Section 5.4, “MySQL Server Logs”
Section 17.1.6.3, “Replica Server Options and Variables”
Section 5.4.6, “Server Log Maintenance”
Section 5.4.4, “The Binary Log”
Section 17.2.4.1, “The Relay Log”

max_binlog_stmt_cache_size

Section 17.1.6.4, “Binary Logging Options and Variables”
Section 8.12.3.1, “How MySQL Uses Memory”

max_connect_errors

Section 5.1.12.3, “DNS Lookups and the Host Cache”
Section 5.1.8, “Server System Variables”
Section 27.12.21.2, “The host_cache Table”

max_connections

Section 5.1.12.2, “Administrative Connection Management”
Section 2.11.4, “Changes in MySQL 8.0”
Section 5.1.12.1, “Connection Interfaces”
Section 5.9.1.4, “Debugging mysqld under gdb”
Section 14.4, “Dictionary Object Cache”
Section B.3.2.16, “File Not Found and Similar Errors”
Section 8.4.3.1, “How MySQL Opens and Closes Tables”
Section 27.15, “Performance Schema System Variables”
Section 6.2.2, “Privileges Provided by MySQL”
Section 5.1.10, “Server Status Variables”
Section 5.1.8, “Server System Variables”
Section 27.12.21.6, “The processlist Table”
Section 5.6.3.3, “Thread Pool Operation”
Section B.3.2.5, “Too many connections”
Section 1.3, “What Is New in MySQL 8.0”
Section 20.5.6.2, “X Plugin Options and System Variables”

max_delayed_threads

Section 5.1.8, “Server System Variables”

max_digest_length

Section 12.14, “Encryption and Compression Functions”
Section 8.12.3.1, “How MySQL Uses Memory”
Section 27.10, “Performance Schema Statement Digests and Sampling”
Section 27.15, “Performance Schema System Variables”
Section 5.1.8, “Server System Variables”
Section 6.4.7.3, “Using MySQL Enterprise Firewall”

max_error_count

Section 2.11.4, “Changes in MySQL 8.0”
Section 13.2.9, “LOAD DATA Statement”
Section 13.6.7.4, “RESIGNAL Statement”
Section 5.1.8, “Server System Variables”
Section 13.7.7.17, “SHOW ERRORS Statement”
Section 13.7.7.42, “SHOW WARNINGS Statement”
Section 13.6.7.7, “The MySQL Diagnostics Area”

max_execution_time

Section 8.9.3, “Optimizer Hints”
Section 5.1.10, “Server Status Variables”
Section 5.1.8, “Server System Variables”
Section 13.2.20, “WITH (Common Table Expressions)”

max_heap_table_size

Section 8.12.3.1, “How MySQL Uses Memory”
Section 8.4.4, “Internal Temporary Table Use in MySQL”
Section 8.4.6, “Limits on Table Size”
Section 17.5.1.21, “Replication and MEMORY Tables”
Section 17.5.1.39, “Replication and Variables”
Section 13.6.6.5, “Restrictions on Server-Side Cursors”
Section 5.1.8, “Server System Variables”
Section 16.3, “The MEMORY Storage Engine”

max_insert_delayed_threads

Section 5.1.8, “Server System Variables”

max_join_size

Section 8.8.2, “EXPLAIN Output Format”
Section 4.5.1.6, “mysql Client Tips”
Section 5.1.8, “Server System Variables”
Section 13.7.6.1, “SET Syntax for Variable Assignment”

max_length_for_sort_data

Section 8.2.1.16, “ORDER BY Optimization”
Section 5.1.8, “Server System Variables”
Section 1.3, “What Is New in MySQL 8.0”

max_points_in_geometry

Section 5.1.8, “Server System Variables”
Section 12.17.8, “Spatial Operator Functions”

max_prepared_stmt_count

Section 8.10.3, “Caching of Prepared Statements and Stored Programs”
Section 13.5.3, “DEALLOCATE PREPARE Statement”
Section 27.15, “Performance Schema System Variables”
Section 13.5, “Prepared Statements”
Section 5.1.10, “Server Status Variables”
Section 5.1.8, “Server System Variables”

max_relay_log_size

Section 17.1.6.4, “Binary Logging Options and Variables”
Section 17.1.6.3, “Replica Server Options and Variables”
Section 17.2.4.1, “The Relay Log”

max_seeks_for_key

Section 13.7.3.1, “ANALYZE TABLE Statement”
Section 5.1.8, “Server System Variables”

max_sort_length

Section B.3.7, “Known Issues in MySQL”
Section 8.2.1.16, “ORDER BY Optimization”
Section 13.2.13, “SELECT Statement”
Section 5.1.8, “Server System Variables”
Section 11.3.4, “The BLOB and TEXT Types”
Section 11.5, “The JSON Data Type”

max_sp_recursion_depth

Section 5.1.8, “Server System Variables”
Section 25.2.1, “Stored Routine Syntax”

max_user_connections

Section 13.7.1.1, “ALTER USER Statement”
Section 13.7.1.3, “CREATE USER Statement”
Section 13.7.8.3, “FLUSH Statement”
Section 6.1.3, “Making MySQL Secure Against Attackers”
Section 5.1.8, “Server System Variables”
Section 6.2.21, “Setting Account Resource Limits”

max_write_lock_count

Section 13.3.6, “LOCK TABLES and UNLOCK TABLES Statements”
Section 8.11.4, “Metadata Locking”
Section 5.1.8, “Server System Variables”
Section 8.11.2, “Table Locking Issues”

mecab_rc_file

Section 12.10.9, “MeCab Full-Text Parser Plugin”
Section 5.1.8, “Server System Variables”

metadata_locks_cache_size

Section 5.1.8, “Server System Variables”

metadata_locks_hash_instances

Section 5.1.8, “Server System Variables”

min_examined_row_limit

Section 5.1.8, “Server System Variables”
Section 5.4.5, “The Slow Query Log”

myisam_data_pointer_size

Section 13.1.20, “CREATE TABLE Statement”
Section 8.4.6, “Limits on Table Size”
Section 5.1.8, “Server System Variables”

myisam_max_sort_file_size

Section 16.2.1, “MyISAM Startup Options”
Section 8.6.3, “Optimizing REPAIR TABLE Statements”
Section 5.1.8, “Server System Variables”

myisam_mmap_size

Section 5.1.8, “Server System Variables”

myisam_recover_options

Section 16.2.1, “MyISAM Startup Options”
Section 8.6.1, “Optimizing MyISAM Queries”
Section 5.1.8, “Server System Variables”
Section 7.6.5, “Setting Up a MyISAM Table Maintenance Schedule”
Section B.3.2.17, “Table-Corruption Issues”
Section 16.2, “The MyISAM Storage Engine”
Section 5.9.1.6, “Using Server Logs to Find Causes of Errors in mysqld”

myisam_repair_threads

Section 5.1.8, “Server System Variables”
Section 1.3, “What Is New in MySQL 8.0”

myisam_sort_buffer_size

Section 13.1.9, “ALTER TABLE Statement”
Section 16.2.1, “MyISAM Startup Options”
Section 8.6.3, “Optimizing REPAIR TABLE Statements”
Section 5.1.8, “Server System Variables”

myisam_stats_method

Section 8.3.8, “InnoDB and MyISAM Index Statistics Collection”
Section 5.1.8, “Server System Variables”

myisam_use_mmap

Section 8.12.3.1, “How MySQL Uses Memory”
Section 5.1.8, “Server System Variables”

mysql_firewall_mode

Section 6.4.7.4, “MySQL Enterprise Firewall Reference”
Section 6.4.7.3, “Using MySQL Enterprise Firewall”

mysql_firewall_trace

Section 6.4.7.4, “MySQL Enterprise Firewall Reference”
Section 6.4.7.3, “Using MySQL Enterprise Firewall”

mysql_native_password_proxy_users

Section 6.2.19, “Proxy Users”
Section 5.1.8, “Server System Variables”

mysqlx_bind_address

Section 5.1.14, “Network Namespace Support”
Section 20.5.6.2, “X Plugin Options and System Variables”
Section 20.5.6.3, “X Plugin Status Variables”

mysqlx_compression_algorithms

Section 20.5.5, “Connection Compression with X Plugin”
Section 20.5.6.2, “X Plugin Options and System Variables”
Section 20.5.6.3, “X Plugin Status Variables”

mysqlx_connect_timeout

Section 20.5.6.2, “X Plugin Options and System Variables”

mysqlx_deflate_default_compression_level

Section 20.5.5, “Connection Compression with X Plugin”
Section 20.5.6.2, “X Plugin Options and System Variables”

mysqlx_deflate_max_client_compression_level

Section 20.5.5, “Connection Compression with X Plugin”
Section 20.5.6.2, “X Plugin Options and System Variables”

mysqlx_document_id_unique_prefix

Section 20.5.6.2, “X Plugin Options and System Variables”

mysqlx_enable_hello_notice

Section 20.5.6.2, “X Plugin Options and System Variables”

mysqlx_idle_worker_thread_timeout

Section 20.5.6.2, “X Plugin Options and System Variables”

mysqlx_interactive_timeout

Section 20.5.6.2, “X Plugin Options and System Variables”

mysqlx_lz

Section 20.5.5, “Connection Compression with X Plugin”
Section 20.5.6.2, “X Plugin Options and System Variables”

mysqlx_max_allowed_packet

Section 20.5.5, “Connection Compression with X Plugin”
Section 20.5.6.2, “X Plugin Options and System Variables”

mysqlx_max_connections

Section 20.5.6.2, “X Plugin Options and System Variables”

mysqlx_min_worker_threads

Section 20.5.6.2, “X Plugin Options and System Variables”

mysqlx_port

Section 5.6.7.14, “Clone Plugin Limitations”
Section 13.7.5, “CLONE Statement”
Section 5.6.7.3, “Cloning Remote Data”
Section 20.3.1, “MySQL Shell”
Section 20.4.1, “MySQL Shell”
Section 2.9.7, “MySQL Source-Configuration Options”
Section 6.7.5.2, “Setting the TCP Port Context for MySQL Features”
Section 20.5.6.2, “X Plugin Options and System Variables”

mysqlx_port_open_timeout

Section 20.5.6.2, “X Plugin Options and System Variables”

mysqlx_read_timeout

Section 20.5.6.2, “X Plugin Options and System Variables”

mysqlx_socket

Section 20.5.6.2, “X Plugin Options and System Variables”

mysqlx_ssl_ca

Section 20.5.6.2, “X Plugin Options and System Variables”

mysqlx_ssl_capath

Section 20.5.6.2, “X Plugin Options and System Variables”

mysqlx_ssl_cert

Section 20.5.6.2, “X Plugin Options and System Variables”

mysqlx_ssl_cipher

Section 20.5.6.2, “X Plugin Options and System Variables”

mysqlx_ssl_crl

Section 20.5.6.2, “X Plugin Options and System Variables”

mysqlx_ssl_crlpath

Section 20.5.6.2, “X Plugin Options and System Variables”

mysqlx_ssl_key

Section 20.5.6.2, “X Plugin Options and System Variables”

mysqlx_wait_timeout

Section 20.5.6.2, “X Plugin Options and System Variables”

mysqlx_write_timeout

Section 20.5.6.2, “X Plugin Options and System Variables”

mysqlx_zstd_default_compression_level

Section 20.5.5, “Connection Compression with X Plugin”
Section 20.5.6.2, “X Plugin Options and System Variables”

mysqlx_zstd_max_client_compression_level

Section 20.5.5, “Connection Compression with X Plugin”
Section 20.5.6.2, “X Plugin Options and System Variables”

N

[index top]

named_pipe

Section B.3.2.2, “Can't connect to [local] MySQL server”
Section 4.2.3, “Command Options for Connecting to the Server”
Section 4.2.4, “Connecting to the MySQL Server Using Command Options”
Section 4.5.1.1, “mysql Client Options”
Section 4.6.8, “mysql_migrate_keyring — Keyring Key Migration Utility”
Section 4.4.2, “mysql_secure_installation — Improve MySQL Installation Security”
Section 4.4.5, “mysql_upgrade — Check and Upgrade MySQL Tables”
Section 4.5.2, “mysqladmin — A MySQL Server Administration Program”
Section 4.6.9, “mysqlbinlog — Utility for Processing Binary Log Files”
Section 4.5.3, “mysqlcheck — A Table Maintenance Program”
Section 4.5.4, “mysqldump — A Database Backup Program”
Section 4.5.5, “mysqlimport — A Data Import Program”
Section 4.5.6, “mysqlpump — A Database Backup Program”
Section 4.5.7, “mysqlshow — Display Database, Table, and Column Information”
Section 4.5.8, “mysqlslap — A Load Emulation Client”
Section 2.3.4.3, “Selecting a MySQL Server Type”
Section 5.1.8, “Server System Variables”
Section 1.2.2, “The Main Features of MySQL”
Section 2.3.3.3.1.1, “Type and Networking”

named_pipe_full_access_group

Section 4.2.3, “Command Options for Connecting to the Server”
Section 4.2.4, “Connecting to the MySQL Server Using Command Options”
Section 4.2.7, “Connection Transport Protocols”
Section 4.5.1.1, “mysql Client Options”
Section 4.6.8, “mysql_migrate_keyring — Keyring Key Migration Utility”
Section 4.4.2, “mysql_secure_installation — Improve MySQL Installation Security”
Section 4.4.5, “mysql_upgrade — Check and Upgrade MySQL Tables”
Section 4.5.2, “mysqladmin — A MySQL Server Administration Program”
Section 4.6.9, “mysqlbinlog — Utility for Processing Binary Log Files”
Section 4.5.3, “mysqlcheck — A Table Maintenance Program”
Section 4.5.4, “mysqldump — A Database Backup Program”
Section 4.5.5, “mysqlimport — A Data Import Program”
Section 4.5.6, “mysqlpump — A Database Backup Program”
Section 4.5.7, “mysqlshow — Display Database, Table, and Column Information”
Section 4.5.8, “mysqlslap — A Load Emulation Client”
Section 5.1.8, “Server System Variables”
Section 1.3, “What Is New in MySQL 8.0”

ndb_autoincrement_prefetch_sz

Section 23.4.3.9.2, “NDB Cluster System Variables”
Section 23.5.13, “ndb_import — Import CSV Data Into NDB”
Section 23.2.4, “What is New in NDB Cluster”

ndb_cache_check_time

Section 23.4.3.9.2, “NDB Cluster System Variables”

ndb_clear_apply_status

Section 23.4.3.9.2, “NDB Cluster System Variables”
Section 13.4.2.5, “RESET REPLICA Statement”

ndb_conflict_role

Section 23.4.3.9.2, “NDB Cluster System Variables”
Section 23.2.4, “What is New in NDB Cluster”

ndb_data_node_neighbour

Section 23.4.3.9.2, “NDB Cluster System Variables”
Section 13.1.20.12, “Setting NDB Comment Options”

ndb_dbg_check_shares

Section 23.4.3.9.2, “NDB Cluster System Variables”

ndb_default_column_format

Section 23.4.3.9.2, “NDB Cluster System Variables”

ndb_deferred_constraints

Section 23.4.3.9.2, “NDB Cluster System Variables”

ndb_distribution

Section 23.4.3.9.2, “NDB Cluster System Variables”

ndb_eventbuffer_free_percent

Section 23.6.2.3, “Event Buffer Reporting in the Cluster Log”
Section 23.4.3.9.2, “NDB Cluster System Variables”

ndb_eventbuffer_max_alloc

Section 23.6.2.3, “Event Buffer Reporting in the Cluster Log”
Section 23.4.3.9.2, “NDB Cluster System Variables”

ndb_extra_logging

Section 23.4.3.9.2, “NDB Cluster System Variables”

ndb_force_send

Section 23.4.3.9.2, “NDB Cluster System Variables”

ndb_fully_replicated

Section 23.4.3.9.2, “NDB Cluster System Variables”

ndb_index_stat_enable

Section 23.4.3.9.2, “NDB Cluster System Variables”

ndb_index_stat_option

Section 23.4.3.9.2, “NDB Cluster System Variables”

ndb_join_pushdown

Section 8.8.2, “EXPLAIN Output Format”
Section 23.4.3.9.2, “NDB Cluster System Variables”

ndb_log_apply_status

Section 23.7.10, “NDB Cluster Replication: Bidirectional and Circular Replication”
Section 23.4.3.9.2, “NDB Cluster System Variables”

ndb_log_bin

Section 23.4.3.9.2, “NDB Cluster System Variables”
Section 23.3.7, “Upgrading and Downgrading NDB Cluster”
Section 23.2.4, “What is New in NDB Cluster”

ndb_log_binlog_index

Section 23.4.3.9.2, “NDB Cluster System Variables”

ndb_log_empty_epochs

Section 23.4.3.9.2, “NDB Cluster System Variables”

ndb_log_empty_update

Section 23.4.3.9.2, “NDB Cluster System Variables”

ndb_log_exclusive_reads

Section 23.4.3.9.1, “MySQL Server Options for NDB Cluster”
Section 23.7.11, “NDB Cluster Replication Conflict Resolution”
Section 23.4.3.9.2, “NDB Cluster System Variables”

ndb_log_orig

Section 23.4.3.9.2, “NDB Cluster System Variables”

ndb_log_transaction_compression

Section 5.4.4.5, “Binary Log Transaction Compression”
Section 17.1.6.4, “Binary Logging Options and Variables”
Section 23.4.3.9.2, “NDB Cluster System Variables”
Section 23.2.4, “What is New in NDB Cluster”

ndb_log_transaction_compression_level_zstd

Section 5.4.4.5, “Binary Log Transaction Compression”
Section 17.1.6.4, “Binary Logging Options and Variables”
Section 23.4.3.9.2, “NDB Cluster System Variables”
Section 23.2.4, “What is New in NDB Cluster”

ndb_log_transaction_id

Section 23.4.3.9.2, “NDB Cluster System Variables”

ndb_metadata_check

Section 23.4.3.9.2, “NDB Cluster System Variables”
Section 23.5.23, “ndb_restore — Restore an NDB Cluster Backup”
Section 27.12.12, “Performance Schema NDB Cluster Tables”
Section 23.2.4, “What is New in NDB Cluster”

ndb_metadata_check_interval

Section 23.4.3.9.2, “NDB Cluster System Variables”
Section 27.12.12, “Performance Schema NDB Cluster Tables”
Section 23.2.4, “What is New in NDB Cluster”

ndb_metadata_sync

Section 23.4.3.9.2, “NDB Cluster System Variables”
Section 27.12.12, “Performance Schema NDB Cluster Tables”
Section 23.2.4, “What is New in NDB Cluster”

ndb_optimized_node_selection

Section 23.4.3.9.2, “NDB Cluster System Variables”
Section 23.4.3.10, “NDB Cluster TCP/IP Connections”
Section 23.6.3.3, “Using CLUSTERLOG STATISTICS in the NDB Cluster Management Client”

ndb_read_backup

Section 23.4.3.9.2, “NDB Cluster System Variables”
Section 13.1.20.12, “Setting NDB Comment Options”
Section 23.2.4, “What is New in NDB Cluster”

ndb_recv_thread_activation_threshold

Section 23.4.3.9.2, “NDB Cluster System Variables”

ndb_recv_thread_cpu_mask

Section 23.4.3.9.2, “NDB Cluster System Variables”

ndb_replica_batch_size

Section 23.4.3.9.2, “NDB Cluster System Variables”
Section 23.2.4, “What is New in NDB Cluster”

ndb_replica_blob_write_batch_bytes

Section 23.4.3.9.2, “NDB Cluster System Variables”
Section 23.2.4, “What is New in NDB Cluster”

ndb_report_thresh_binlog_epoch_slip

Section 23.6.2.3, “Event Buffer Reporting in the Cluster Log”
Section 23.4.3.9.2, “NDB Cluster System Variables”

ndb_report_thresh_binlog_mem_usage

Section 23.6.2.3, “Event Buffer Reporting in the Cluster Log”
Section 23.4.3.9.2, “NDB Cluster System Variables”

ndb_row_checksum

Section 23.4.3.9.2, “NDB Cluster System Variables”

ndb_schema_dist_lock_wait_timeout

Section 23.4.3.9.2, “NDB Cluster System Variables”

ndb_schema_dist_timeout

Section 23.4.3.9.2, “NDB Cluster System Variables”

ndb_schema_dist_upgrade_allowed

Section 23.4.3.9.2, “NDB Cluster System Variables”

ndb_show_foreign_key_mock_tables

Section 23.4.3.9.2, “NDB Cluster System Variables”

ndb_slave_conflict_role

Section 23.7.11, “NDB Cluster Replication Conflict Resolution”
Section 23.4.3.9.2, “NDB Cluster System Variables”
Section 23.2.4, “What is New in NDB Cluster”

ndb_table_no_logging

Section 23.4.3.9.2, “NDB Cluster System Variables”
Section 13.1.20.12, “Setting NDB Comment Options”

ndb_table_temporary

Section 23.4.3.9.2, “NDB Cluster System Variables”

ndb_use_copying_alter_table

Section 23.4.3.9.2, “NDB Cluster System Variables”

ndb_use_exact_count

Section 23.4.3.9.2, “NDB Cluster System Variables”

ndb_use_transactions

Section 23.6.9, “Importing Data Into MySQL Cluster”
Section 23.4.3.9.2, “NDB Cluster System Variables”

ndb_version

Section 23.4.3.9.2, “NDB Cluster System Variables”

ndb_version_string

Section 23.4.3.9.2, “NDB Cluster System Variables”

ndbinfo_database

Section 23.4.3.9.2, “NDB Cluster System Variables”

ndbinfo_max_bytes

Section 23.4.3.9.2, “NDB Cluster System Variables”

ndbinfo_max_rows

Section 23.4.3.9.2, “NDB Cluster System Variables”

ndbinfo_offline

Section 23.4.3.9.2, “NDB Cluster System Variables”

ndbinfo_show_hidden

Section 23.4.3.9.2, “NDB Cluster System Variables”
Section 23.6.16, “ndbinfo: The NDB Cluster Information Database”
Section 23.6.16.7, “The ndbinfo cluster_operations Table”
Section 23.6.16.8, “The ndbinfo cluster_transactions Table”
Section 23.6.16.54, “The ndbinfo server_operations Table”
Section 23.6.16.55, “The ndbinfo server_transactions Table”

ndbinfo_table_prefix

Section 23.4.3.9.2, “NDB Cluster System Variables”

ndbinfo_version

Section 23.4.3.9.2, “NDB Cluster System Variables”

net_buffer_length

Section 8.12.3.1, “How MySQL Uses Memory”
Section 4.5.4, “mysqldump — A Database Backup Program”
Section 4.5.6, “mysqlpump — A Database Backup Program”
Section 5.1.8, “Server System Variables”

net_read_timeout

Section B.3.2.3, “Lost connection to MySQL server”
Section 5.1.8, “Server System Variables”

net_retry_count

Section 5.1.8, “Server System Variables”

net_write_timeout

Section 5.1.8, “Server System Variables”

new

Section 24.6.2, “Partitioning Limitations Relating to Storage Engines”
Section 5.1.8, “Server System Variables”

ngram_token_size

Section 12.10.2, “Boolean Full-Text Searches”
Section 12.10.6, “Fine-Tuning MySQL Full-Text Search”
Section 12.10.4, “Full-Text Stopwords”
Section 12.10.1, “Natural Language Full-Text Searches”
Section 12.10.8, “ngram Full-Text Parser”
Section 5.1.8, “Server System Variables”

O

[index top]

offline_mode

Section 18.7.7.4, “Exit Action”
Section 18.4.2, “Group Replication Server States”
Section 18.9, “Group Replication System Variables”
Section 6.2.2, “Privileges Provided by MySQL”
Section 5.1.8, “Server System Variables”

old

Section 8.9.4, “Index Hints”
Section 5.1.8, “Server System Variables”

old_alter_table

Section 13.1.9, “ALTER TABLE Statement”
Section 15.12, “InnoDB and Online DDL”
Section 24.3.1, “Management of RANGE and LIST Partitions”
Section 15.12.1, “Online DDL Operations”
Section 15.12.2, “Online DDL Performance and Concurrency”
Section 13.7.3.4, “OPTIMIZE TABLE Statement”
Section 5.1.8, “Server System Variables”
Section 15.12.6, “Simplifying DDL Statements with Online DDL”
Section 1.3, “What Is New in MySQL 8.0”

open_files_limit

Section 5.1.12.1, “Connection Interfaces”
Section B.3.2.16, “File Not Found and Similar Errors”
Section 8.2.1.4, “Hash Join Optimization”
Section 8.4.3.1, “How MySQL Opens and Closes Tables”
Section 2.5.9, “Managing MySQL Server with systemd”
Section 27.15, “Performance Schema System Variables”
Section 24.6, “Restrictions and Limitations on Partitioning”
Section 5.4.1, “Selecting General Query Log and Slow Query Log Output Destinations”
Section 5.1.8, “Server System Variables”
Section 1.3, “What Is New in MySQL 8.0”

optimizer_prune_level

Section 8.9.1, “Controlling Query Plan Evaluation”
Section 8.9.3, “Optimizer Hints”
Section 8.2.2.1, “Optimizing IN and EXISTS Subquery Predicates with Semijoin Transformations”
Section 5.1.8, “Server System Variables”

optimizer_search_depth

Section 8.9.1, “Controlling Query Plan Evaluation”
Section 5.1.8, “Server System Variables”

optimizer_switch

Section 8.2.1.12, “Block Nested-Loop and Batched Key Access Joins”
Section 8.2.1.13, “Condition Filtering”
Section 13.2.15.7, “Correlated Subqueries”
Section 8.2.2.5, “Derived Condition Pushdown Optimization”
Section 8.2.1.5, “Engine Condition Pushdown Optimization”
Section 8.2.1.4, “Hash Join Optimization”
Section 8.2.1.6, “Index Condition Pushdown Optimization”
Section 8.2.1.3, “Index Merge Optimization”
Section 8.3.12, “Invisible Indexes”
Section 8.2.1.19, “LIMIT Query Optimization”
Section 8.2.1.11, “Multi-Range Read Optimization”
Section 8.9.3, “Optimizer Hints”
Section 8.9.6, “Optimizer Statistics”
Section 8.2.2.4, “Optimizing Derived Tables, View References, and Common Table Expressions with Merging or Materialization”
Section 8.2.2.1, “Optimizing IN and EXISTS Subquery Predicates with Semijoin Transformations”
Section 8.2.2.2, “Optimizing Subqueries with Materialization”
Section 8.2.2.3, “Optimizing Subqueries with the EXISTS Strategy”
Section 8.2.1.2, “Range Optimization”
Section 5.1.8, “Server System Variables”
Section 8.9.2, “Switchable Optimizations”
Section 28.4.5.7, “The list_add() Function”
Section 13.2.17, “UPDATE Statement”
Section 8.3.10, “Use of Index Extensions”
Section 25.5.2, “View Processing Algorithms”
Section 1.3, “What Is New in MySQL 8.0”

optimizer_trace

Section 5.1.8, “Server System Variables”
Section 26.3.19, “The INFORMATION_SCHEMA OPTIMIZER_TRACE Table”

optimizer_trace_features

Section 5.1.8, “Server System Variables”

optimizer_trace_limit

Section 5.1.8, “Server System Variables”

optimizer_trace_max_mem_size

Section 2.11.4, “Changes in MySQL 8.0”
Section 5.1.8, “Server System Variables”
Section 26.3.19, “The INFORMATION_SCHEMA OPTIMIZER_TRACE Table”

optimizer_trace_offset

Section 5.1.8, “Server System Variables”

original_commit_timestamp

Section 17.1.6.4, “Binary Logging Options and Variables”
Section 17.3.3.1, “Privileges For The Replication PRIVILEGE_CHECKS_USER Account”

original_server_version

Section 4.6.9, “mysqlbinlog — Utility for Processing Binary Log Files”
Section 17.3.3.1, “Privileges For The Replication PRIVILEGE_CHECKS_USER Account”
Section 17.5.2, “Replication Compatibility Between MySQL Versions”
Section 17.1.6.2, “Replication Source Options and Variables”
Section 5.1.8, “Server System Variables”

P

[index top]

parser_max_mem_size

Section 5.1.8, “Server System Variables”

partial_revokes

Section 6.2.11, “Account Categories”
Section 13.7.1.6, “GRANT Statement”
Section 6.2.12, “Privilege Restriction Using Partial Revokes”
Section 5.1.8, “Server System Variables”
Section 1.3, “What Is New in MySQL 8.0”

password_history

Section 13.7.1.1, “ALTER USER Statement”
Section 13.7.1.3, “CREATE USER Statement”
Section 6.2.15, “Password Management”
Section 5.1.8, “Server System Variables”

password_require_current

Section 13.7.1.1, “ALTER USER Statement”
Section 13.7.1.3, “CREATE USER Statement”
Section 6.2.15, “Password Management”
Section 5.1.8, “Server System Variables”

password_reuse_interval

Section 13.7.1.1, “ALTER USER Statement”
Section 13.7.1.3, “CREATE USER Statement”
Section 6.2.15, “Password Management”
Section 5.1.8, “Server System Variables”

performance_schema

Section 27.1, “Performance Schema Quick Start”
Section 27.3, “Performance Schema Startup Configuration”
Section 27.15, “Performance Schema System Variables”
Section 27.12.21.6, “The processlist Table”

performance_schema_accounts_size

Section 27.12.15, “Performance Schema Status Variable Tables”
Section 27.15, “Performance Schema System Variables”
Section 27.12.20.12, “Status Variable Summary Tables”
Section 27.12.8.1, “The accounts Table”

performance_schema_digests_size

Section 27.10, “Performance Schema Statement Digests and Sampling”
Section 27.16, “Performance Schema Status Variables”
Section 27.15, “Performance Schema System Variables”
Section 27.12.20.3, “Statement Summary Tables”

performance_schema_error_size

Section 27.15, “Performance Schema System Variables”

performance_schema_events_stages_history_long_size

Section 27.15, “Performance Schema System Variables”
Section 27.12.5.3, “The events_stages_history_long Table”

performance_schema_events_stages_history_size

Section 27.15, “Performance Schema System Variables”
Section 27.12.5.2, “The events_stages_history Table”

performance_schema_events_statements_history_long_size

Section 27.15, “Performance Schema System Variables”
Section 27.12.6.3, “The events_statements_history_long Table”

performance_schema_events_statements_history_size

Section 27.15, “Performance Schema System Variables”
Section 27.12.6.2, “The events_statements_history Table”

performance_schema_events_transactions_history_long_size

Section 27.15, “Performance Schema System Variables”
Section 27.12.7.3, “The events_transactions_history_long Table”

performance_schema_events_transactions_history_size

Section 27.15, “Performance Schema System Variables”
Section 27.12.7.2, “The events_transactions_history Table”

performance_schema_events_waits_history_long_size

Section 27.15, “Performance Schema System Variables”
Section 27.12, “Performance Schema Table Descriptions”
Section 13.7.7.15, “SHOW ENGINE Statement”
Section 27.12.4.3, “The events_waits_history_long Table”

performance_schema_events_waits_history_size

Section 27.15, “Performance Schema System Variables”
Section 27.12, “Performance Schema Table Descriptions”
Section 13.7.7.15, “SHOW ENGINE Statement”
Section 27.12.4.2, “The events_waits_history Table”

performance_schema_hosts_size

Section 27.12.15, “Performance Schema Status Variable Tables”
Section 27.15, “Performance Schema System Variables”
Section 27.12.20.12, “Status Variable Summary Tables”
Section 27.12.8.2, “The hosts Table”

performance_schema_max_cond_classes

Section 27.15, “Performance Schema System Variables”

performance_schema_max_cond_instances

Section 27.15, “Performance Schema System Variables”

performance_schema_max_digest_length

Section 27.10, “Performance Schema Statement Digests and Sampling”
Section 27.15, “Performance Schema System Variables”
Section 5.1.8, “Server System Variables”
Section 27.12.6.1, “The events_statements_current Table”

performance_schema_max_digest_sample_age

Section 27.10, “Performance Schema Statement Digests and Sampling”
Section 27.15, “Performance Schema System Variables”

performance_schema_max_file_classes

Section 27.15, “Performance Schema System Variables”

performance_schema_max_file_handles

Section 27.15, “Performance Schema System Variables”

performance_schema_max_file_instances

Section 27.15, “Performance Schema System Variables”

performance_schema_max_index_stat

Section 27.16, “Performance Schema Status Variables”
Section 27.15, “Performance Schema System Variables”

performance_schema_max_memory_classes

Section 27.15, “Performance Schema System Variables”

performance_schema_max_metadata_locks

Section 27.16, “Performance Schema Status Variables”
Section 27.15, “Performance Schema System Variables”
Section 27.12.13.3, “The metadata_locks Table”

performance_schema_max_mutex_classes

Section 27.7, “Performance Schema Status Monitoring”
Section 27.15, “Performance Schema System Variables”

performance_schema_max_mutex_instances

Section 27.15, “Performance Schema System Variables”

performance_schema_max_prepared_statements_instances

Section 27.16, “Performance Schema Status Variables”
Section 27.15, “Performance Schema System Variables”
Section 27.12.6.4, “The prepared_statements_instances Table”

performance_schema_max_program_instances

Section 27.16, “Performance Schema Status Variables”
Section 27.15, “Performance Schema System Variables”

performance_schema_max_rwlock_classes

Section 27.15, “Performance Schema System Variables”

performance_schema_max_rwlock_instances

Section 27.15, “Performance Schema System Variables”

performance_schema_max_socket_classes

Section 27.15, “Performance Schema System Variables”

performance_schema_max_socket_instances

Section 27.15, “Performance Schema System Variables”

performance_schema_max_sql_text_length

Section 27.10, “Performance Schema Statement Digests and Sampling”
Section 27.15, “Performance Schema System Variables”
Section 27.12.20.3, “Statement Summary Tables”
Section 27.12.6.1, “The events_statements_current Table”

performance_schema_max_stage_classes

Section 27.15, “Performance Schema System Variables”
Section 27.12.21.6, “The processlist Table”

performance_schema_max_statement_classes

Section 27.15, “Performance Schema System Variables”

performance_schema_max_statement_stack

Section 27.16, “Performance Schema Status Variables”
Section 27.15, “Performance Schema System Variables”

performance_schema_max_table_handles

Section 27.16, “Performance Schema Status Variables”
Section 27.15, “Performance Schema System Variables”
Section 27.12.13.4, “The table_handles Table”

performance_schema_max_table_instances

Section 27.15, “Performance Schema System Variables”

performance_schema_max_table_lock_stat

Section 27.16, “Performance Schema Status Variables”
Section 27.15, “Performance Schema System Variables”

performance_schema_max_thread_classes

Section 27.15, “Performance Schema System Variables”
Section 27.12.21.6, “The processlist Table”

performance_schema_max_thread_instances

Section 12.22, “Performance Schema Functions”
Section 27.12.15, “Performance Schema Status Variable Tables”
Section 27.16, “Performance Schema Status Variables”
Section 27.15, “Performance Schema System Variables”
Section 13.7.7.15, “SHOW ENGINE Statement”
Section 27.12.21.6, “The processlist Table”

performance_schema_session_connect_attrs_size

Section 27.12.9, “Performance Schema Connection Attribute Tables”
Section 27.16, “Performance Schema Status Variables”
Section 27.15, “Performance Schema System Variables”

performance_schema_setup_actors_size

Section 27.15, “Performance Schema System Variables”
Section 27.12.2.1, “The setup_actors Table”

performance_schema_setup_objects_size

Section 27.15, “Performance Schema System Variables”
Section 27.12.2.4, “The setup_objects Table”

performance_schema_show_processlist

Section 27.15, “Performance Schema System Variables”
Section 27.12.21.6, “The processlist Table”

performance_schema_users_size

Section 27.12.15, “Performance Schema Status Variable Tables”
Section 27.15, “Performance Schema System Variables”
Section 27.12.20.12, “Status Variable Summary Tables”
Section 27.12.8.3, “The users Table”

persist_only_admin_x

Section 5.1.9.4, “Nonpersistible and Persist-Restricted System Variables”
Section 5.1.8, “Server System Variables”
Section 5.1.9.1, “System Variable Privileges”

persist_sensitive_variables_in_plaintext

Section 5.1.9.3, “Persisted System Variables”
Section 5.1.8, “Server System Variables”

persisted_globals_load

Section 5.1.9.4, “Nonpersistible and Persist-Restricted System Variables”
Section 27.12.14.2, “Performance Schema variables_info Table”
Section 5.1.9.3, “Persisted System Variables”
Section 13.7.8.7, “RESET PERSIST Statement”
Section 5.1.8, “Server System Variables”
Section 4.2.2.2, “Using Option Files”

pid

Section 15.8.2, “Configuring InnoDB for Read-Only Operation”

pid_file

Section 2.4.3, “Installing and Using the MySQL Launch Daemon”
Section 5.1.8, “Server System Variables”
Section 1.3, “What Is New in MySQL 8.0”

plugin_dir

Section 6.1.2.2, “Administrator Guidelines for Password Security”
Section 6.4.2.1, “Connection-Control Plugin Installation”
Section 13.7.4.1, “CREATE FUNCTION Statement for Loadable Functions”
Section 6.4.1.11, “FIDO Pluggable Authentication”
Section 6.4.4.15, “General-Purpose Keyring Key-Management Functions”
Section 13.7.4.3, “INSTALL COMPONENT Statement”
Section 13.7.4.4, “INSTALL PLUGIN Statement”
Section 5.6.1, “Installing and Uninstalling Plugins”
Section 2.4.3, “Installing and Using the MySQL Launch Daemon”
Section 2.5.4, “Installing MySQL on Linux Using RPM Packages from Oracle”
Section 5.6.5.1, “Installing or Uninstalling ddl_rewriter”
Section 6.4.5.2, “Installing or Uninstalling MySQL Enterprise Audit”
Section 6.5.2, “Installing or Uninstalling MySQL Enterprise Data Masking and De-Identification”
Section 5.6.6.2, “Installing or Uninstalling Version Tokens”
Section 17.4.10.1, “Installing Semisynchronous Replication”
Section 5.6.7.1, “Installing the Clone Plugin”
Section 6.4.1.8, “Kerberos Pluggable Authentication”
Section 6.4.4.18, “Keyring Command Options”
Section 6.4.4.2, “Keyring Component Installation”
Section 6.4.4.3, “Keyring Plugin Installation”
Section 6.4.1.7, “LDAP Pluggable Authentication”
Section 6.1.3, “Making MySQL Secure Against Attackers”
Section 6.4.4.14, “Migrating Keys Between Keyring Keystores”
Section 6.6.1, “MySQL Enterprise Encryption Installation and Upgrading”
Section 4.6.8, “mysql_migrate_keyring — Keyring Key Migration Utility”
Section 6.4.1.9, “No-Login Pluggable Authentication”
Section 6.4.1.5, “PAM Pluggable Authentication”
Section 6.4.3.1, “Password Validation Component Installation and Uninstallation”
Section 6.2.17, “Pluggable Authentication”
Section 16.11.1, “Pluggable Storage Engine Architecture”
Section 5.1.7, “Server Command Options”
Section 5.1.8, “Server System Variables”
Section 15.20.3, “Setting Up the InnoDB memcached Plugin”
Section 13.7.7.25, “SHOW PLUGINS Statement”
Section 6.4.1.10, “Socket Peer-Credential Pluggable Authentication”
Section 6.4.1.12, “Test Pluggable Authentication”
Section 6.4.6, “The Audit Message Component”
Section 26.3.22, “The INFORMATION_SCHEMA PLUGINS Table”
Section 5.6.9.1.2, “The Locking Service Function Interface”
Section 27.12.21.9, “The user_defined_functions Table”
Section 5.6.3.2, “Thread Pool Installation”
Section 6.4.1.6, “Windows Pluggable Authentication”

port

Section B.3.2.2, “Can't connect to [local] MySQL server”
Section 13.7.5, “CLONE Statement”
Section 5.6.7.3, “Cloning Remote Data”
Section 18.2.1.2, “Configuring an Instance for Group Replication”
Section 18.5.4.1, “Connections for Distributed Recovery”
Section 18.10, “Frequently Asked Questions”
Section 18.9, “Group Replication System Variables”
Section 20.3.1, “MySQL Shell”
Section 20.4.1, “MySQL Shell”
Section 18.6.3, “Securing Distributed Recovery Connections”
Section 18.5.4.1.1, “Selecting addresses for distributed recovery endpoints”
Section 5.1.8, “Server System Variables”
Section 6.7.5.1, “Setting the TCP Port Context for mysqld”
Section 27.12.11.11, “The replication_group_members Table”
Section 20.5.6.2, “X Plugin Options and System Variables”

preload_buffer_size

Section 5.1.8, “Server System Variables”

print_identified_with_as_hex

Section 6.2.8, “Adding Accounts, Assigning Privileges, and Dropping Accounts”
Section 13.7.1.1, “ALTER USER Statement”
Section 13.7.1.3, “CREATE USER Statement”
Section 5.1.8, “Server System Variables”
Section 13.7.7.12, “SHOW CREATE USER Statement”

profiling

Section 5.1.8, “Server System Variables”
Section 13.7.7.30, “SHOW PROFILE Statement”
Section 26.3.24, “The INFORMATION_SCHEMA PROFILING Table”

profiling_history_size

Section 5.1.8, “Server System Variables”
Section 13.7.7.30, “SHOW PROFILE Statement”

protocol_compression_algorithms

Section 13.4.2.1, “CHANGE MASTER TO Statement”
Section 13.4.2.3, “CHANGE REPLICATION SOURCE TO Statement”
Section 4.2.3, “Command Options for Connecting to the Server”
Section 4.2.8, “Connection Compression Control”
Section 20.5.5, “Connection Compression with X Plugin”
Section 18.9, “Group Replication System Variables”
Section 4.5.1.1, “mysql Client Options”
Section 4.4.5, “mysql_upgrade — Check and Upgrade MySQL Tables”
Section 4.5.2, “mysqladmin — A MySQL Server Administration Program”
Section 4.6.9, “mysqlbinlog — Utility for Processing Binary Log Files”
Section 4.5.3, “mysqlcheck — A Table Maintenance Program”
Section 4.5.4, “mysqldump — A Database Backup Program”
Section 4.5.5, “mysqlimport — A Data Import Program”
Section 4.5.6, “mysqlpump — A Database Backup Program”
Section 4.5.7, “mysqlshow — Display Database, Table, and Column Information”
Section 4.5.8, “mysqlslap — A Load Emulation Client”
Section 5.1.10, “Server Status Variables”
Section 5.1.8, “Server System Variables”

protocol_version

Section 5.1.9.4, “Nonpersistible and Persist-Restricted System Variables”
Section 5.1.8, “Server System Variables”

proxy_user

Section 6.2.19, “Proxy Users”
Section 5.1.8, “Server System Variables”

pseudo_replica_mode

Section 4.6.9, “mysqlbinlog — Utility for Processing Binary Log Files”
Section 17.3.3.1, “Privileges For The Replication PRIVILEGE_CHECKS_USER Account”
Section 5.1.8, “Server System Variables”

pseudo_slave_mode

Section 4.6.9, “mysqlbinlog — Utility for Processing Binary Log Files”
Section 17.3.3.1, “Privileges For The Replication PRIVILEGE_CHECKS_USER Account”
Section 5.1.8, “Server System Variables”

pseudo_thread_id

Section 12.16, “Information Functions”
Section 5.4.4.3, “Mixed Binary Logging Format”
Section 17.5.1.39, “Replication and Variables”
Section 17.3.3, “Replication Privilege Checks”
Section 5.1.8, “Server System Variables”

Q

[index top]

query_alloc_block_size

Section 5.1.8, “Server System Variables”

query_prealloc_size

Section 5.1.8, “Server System Variables”

R

[index top]

rand_seed

Section 5.1.8, “Server System Variables”

range_alloc_block_size

Section 5.1.8, “Server System Variables”

range_optimizer_max_mem_size

Section 4.5.1.6, “mysql Client Tips”
Section 8.2.1.2, “Range Optimization”
Section 5.1.8, “Server System Variables”

rbr_exec_mode

Section 5.1.8, “Server System Variables”

read_buffer_size

Section 8.12.3.1, “How MySQL Uses Memory”
Section 8.6.3, “Optimizing REPAIR TABLE Statements”
Section 5.1.8, “Server System Variables”

read_only

Section 13.7.1, “Account Management Statements”
Section 13.7.1.1, “ALTER USER Statement”
Section 6.2.14, “Assigning Account Passwords”
Section 17.4.1.3, “Backing Up a Source or Replica by Making It Read Only”
Section 18.5.1.5, “Configuring Member Actions”
Section 13.7.1.2, “CREATE ROLE Statement”
Section 13.7.1.3, “CREATE USER Statement”
Section 13.7.1.4, “DROP ROLE Statement”
Section 13.7.1.5, “DROP USER Statement”
Section 13.7.8.3, “FLUSH Statement”
Section 13.4.3.7, “Functions to Set and Reset Group Replication Member Actions”
Section 13.4.2.12, “Functions which Configure the Source List”
Section 13.7.1.6, “GRANT Statement”
Section 8.2.3, “Optimizing INFORMATION_SCHEMA Queries”
Section 6.2.2, “Privileges Provided by MySQL”
Section 13.7.1.7, “RENAME USER Statement”
Section 17.5.1.39, “Replication and Variables”
Section 13.7.1.8, “REVOKE Statement”
Section 5.4.1, “Selecting General Query Log and Slow Query Log Output Destinations”
Section 5.1.8, “Server System Variables”
Section 13.7.1.10, “SET PASSWORD Statement”
Section 17.1.3.4, “Setting Up Replication Using GTIDs”
Section 13.3.1, “START TRANSACTION, COMMIT, and ROLLBACK Statements”

read_rnd_buffer_size

Section 8.12.3.1, “How MySQL Uses Memory”
Section 8.2.1.11, “Multi-Range Read Optimization”
Section 8.2.1.16, “ORDER BY Optimization”
Section 5.1.8, “Server System Variables”

regexp_stack_limit

Section 12.8.2, “Regular Expressions”
Section 5.1.8, “Server System Variables”
Section 1.3, “What Is New in MySQL 8.0”

regexp_time_limit

Section 12.8.2, “Regular Expressions”
Section 5.1.8, “Server System Variables”
Section 1.3, “What Is New in MySQL 8.0”

relay

Section 2.11.4, “Changes in MySQL 8.0”
Section 17.2.2.3, “Startup Options and Replication Channels”

relay_log

Section 17.1.2.8, “Adding Replicas to a Replication Environment”
Section 18.10, “Frequently Asked Questions”
Section 17.4.7, “Improving Replication Performance”
Section 17.1.6.3, “Replica Server Options and Variables”
Section 17.2.2.4, “Replication Channel Naming Conventions”
Section 17.2.4.1, “The Relay Log”
Section 1.3, “What Is New in MySQL 8.0”

relay_log_basename

Section 17.1.6.3, “Replica Server Options and Variables”

relay_log_index

Section 17.1.2.8, “Adding Replicas to a Replication Environment”
Section 17.1.6.3, “Replica Server Options and Variables”
Section 17.2.4.1, “The Relay Log”

relay_log_info_file

Section 17.1.6.3, “Replica Server Options and Variables”
Section 17.2.4.2, “Replication Metadata Repositories”

relay_log_info_repository

Section 2.11.4, “Changes in MySQL 8.0”
Section 5.6.7.7, “Cloning for Replication”
Section 18.3.1, “Group Replication Requirements”
Section 17.4.2, “Handling an Unexpected Halt of a Replica”
Section 17.1.6.3, “Replica Server Options and Variables”
Section 17.2.4.2, “Replication Metadata Repositories”
Section 13.4.2.5, “RESET REPLICA Statement”
Section 17.2.2.3, “Startup Options and Replication Channels”
Section 1.3, “What Is New in MySQL 8.0”

relay_log_purge

Section 17.4.2, “Handling an Unexpected Halt of a Replica”
Section 17.1.6.3, “Replica Server Options and Variables”
Section 13.7.7.35, “SHOW REPLICA STATUS Statement”

relay_log_recovery

Section 17.4.2, “Handling an Unexpected Halt of a Replica”
Section 17.1.6.3, “Replica Server Options and Variables”

relay_log_space_limit

Section 17.1.6.3, “Replica Server Options and Variables”
Section 8.14.5, “Replication I/O (Receiver) Thread States”
Section 17.2.2.3, “Startup Options and Replication Channels”

replica

Section 17.2.2.3, “Startup Options and Replication Channels”

replica_allow_batching

Section 23.4.3.9.2, “NDB Cluster System Variables”
Section 23.7.5, “Preparing the NDB Cluster for Replication”
Section 23.7.6, “Starting NDB Cluster Replication (Single Replication Channel)”
Section 23.2.4, “What is New in NDB Cluster”

replica_checkpoint_group

Section 23.7.3, “Known Issues in NDB Cluster Replication”
Section 12.24, “Miscellaneous Functions”
Section 17.1.6.3, “Replica Server Options and Variables”
Section 17.2.2.3, “Startup Options and Replication Channels”

replica_checkpoint_period

Section 12.24, “Miscellaneous Functions”
Section 17.1.6.3, “Replica Server Options and Variables”

replica_compressed_protocol

Section 13.4.2.1, “CHANGE MASTER TO Statement”
Section 13.4.2.3, “CHANGE REPLICATION SOURCE TO Statement”
Section 4.2.8, “Connection Compression Control”
Section 5.4.4.5.3, “Monitoring Binary Log Transaction Compression”
Section 17.1.6.3, “Replica Server Options and Variables”

replica_exec_mode

Section 23.7.3, “Known Issues in NDB Cluster Replication”
Section 17.1.6.3, “Replica Server Options and Variables”
Section 17.5.1.21, “Replication and MEMORY Tables”
Section 17.2.1.2, “Usage of Row-Based Logging and Replication”

replica_load_tmpdir

Section 17.4.1.2, “Backing Up Raw Data from a Replica”
Section 7.2, “Database Backup Methods”
Section 17.1.6.3, “Replica Server Options and Variables”
Section 5.1.7, “Server Command Options”
Section 5.1.8, “Server System Variables”
Section B.3.3.5, “Where MySQL Stores Temporary Files”

replica_max_allowed_packet

Section 5.4.4.5.1, “Behaviors When Binary Log Transaction Compression is Enabled”
Section 18.3.2, “Group Replication Limitations”
Section 18.9, “Group Replication System Variables”
Section 18.7.5, “Message Fragmentation”
Section 17.1.6.3, “Replica Server Options and Variables”
Section 17.5.1.20, “Replication and max_allowed_packet”

replica_net_timeout

Section 13.4.2.1, “CHANGE MASTER TO Statement”
Section 13.4.2.3, “CHANGE REPLICATION SOURCE TO Statement”
Section 17.1.7.1, “Checking Replication Status”
Section 17.1.6.3, “Replica Server Options and Variables”
Section 17.5.1.28, “Replication and Source or Replica Shutdowns”
Section 8.14.5, “Replication I/O (Receiver) Thread States”
Section 5.1.8, “Server System Variables”

replica_parallel_type

Section 5.4.4.5.1, “Behaviors When Binary Log Transaction Compression is Enabled”
Section 17.1.6.4, “Binary Logging Options and Variables”
Section 18.3.1, “Group Replication Requirements”
Section 17.2.3.2, “Monitoring Replication Applier Worker Threads”
Section 17.1.6.3, “Replica Server Options and Variables”
Section 17.5.1.34, “Replication and Transaction Inconsistencies”
Section 1.3, “What Is New in MySQL 8.0”

replica_parallel_workers

Section 17.1.6.4, “Binary Logging Options and Variables”
Section 13.4.2.1, “CHANGE MASTER TO Statement”
Section 13.4.2.3, “CHANGE REPLICATION SOURCE TO Statement”
Section 5.6.7.7, “Cloning for Replication”
Section 18.3.1, “Group Replication Requirements”
Section 17.1.3.2, “GTID Life Cycle”
Section 23.7.3, “Known Issues in NDB Cluster Replication”
Section 17.1.5, “MySQL Multi-Source Replication”
Section 27.12.11, “Performance Schema Replication Tables”
Section 17.1.6.3, “Replica Server Options and Variables”
Section 17.5.1.20, “Replication and max_allowed_packet”
Section 17.5.1.34, “Replication and Transaction Inconsistencies”
Section 17.2.2, “Replication Channels”
Section 8.14.6, “Replication SQL Thread States”
Section 17.2.3, “Replication Threads”
Section 13.4.2.8, “START REPLICA Statement”
Section 13.4.2.10, “STOP REPLICA Statement”
Section 27.12.11.8, “The replication_applier_status_by_worker Table”
Section 1.3, “What Is New in MySQL 8.0”

replica_pending_jobs_size_max

Section 8.12.3.1, “How MySQL Uses Memory”
Section 17.2.3.2, “Monitoring Replication Applier Worker Threads”
Section 17.1.6.3, “Replica Server Options and Variables”
Section 17.5.1.20, “Replication and max_allowed_packet”
Section 8.14.6, “Replication SQL Thread States”

replica_preserve_commit_order

Section 18.3.1, “Group Replication Requirements”
Section 17.1.3.2, “GTID Life Cycle”
Section 17.1.6.3, “Replica Server Options and Variables”
Section 17.5.1.34, “Replication and Transaction Inconsistencies”
Section 8.14.5, “Replication I/O (Receiver) Thread States”
Section 13.4.2.8, “START REPLICA Statement”

replica_skip_errors

Section 17.1.6.3, “Replica Server Options and Variables”

replica_sql_verify_checksum

MySQL Glossary
Section 17.1.6.3, “Replica Server Options and Variables”
Section 5.4.4, “The Binary Log”

replica_transaction_retries

Section 17.1.6.3, “Replica Server Options and Variables”
Section 17.5.1.32, “Replication Retries and Timeouts”
Section 27.12.11.6, “The replication_applier_status Table”

replica_type_conversions

Section 23.7.3, “Known Issues in NDB Cluster Replication”
Section 17.1.6.3, “Replica Server Options and Variables”

replication_optimize_for_static_plugin_config

Section 17.4.10.2, “Configuring Semisynchronous Replication”
Section 17.1.6.3, “Replica Server Options and Variables”
Section 17.4.10, “Semisynchronous Replication”

replication_sender_observe_commit_only

Section 17.4.10.2, “Configuring Semisynchronous Replication”
Section 17.1.6.3, “Replica Server Options and Variables”
Section 17.4.10, “Semisynchronous Replication”

report_host

Section 18.6.1, “Communication Stack for Connection Security Management”
Section 18.2.1.2, “Configuring an Instance for Group Replication”
Section 18.5.4.1, “Connections for Distributed Recovery”
Section 18.2.2, “Deploying Group Replication Locally”
Section 17.1.6.3, “Replica Server Options and Variables”

report_password

Section 17.1.6.3, “Replica Server Options and Variables”

report_port

Section 18.5.4.1, “Connections for Distributed Recovery”
Section 18.10, “Frequently Asked Questions”
Section 18.9, “Group Replication System Variables”
Section 17.1.6.3, “Replica Server Options and Variables”
Section 18.5.4.1.1, “Selecting addresses for distributed recovery endpoints”

report_user

Section 17.1.6.3, “Replica Server Options and Variables”

require_row_format

Section 5.1.8, “Server System Variables”
Section 1.3, “What Is New in MySQL 8.0”

require_secure_transport

Section 18.6.1, “Communication Stack for Connection Security Management”
Section 6.3.1, “Configuring MySQL to Use Encrypted Connections”
Section 4.2.7, “Connection Transport Protocols”
Section 6.8, “FIPS Support”
Section 5.1.8, “Server System Variables”
Section 6.3, “Using Encrypted Connections”
Section 20.5.3, “Using Encrypted Connections with X Plugin”

resultset_metadata

Section 5.1.8, “Server System Variables”

rewriter_enabled

Section 5.6.4.3.3, “Rewriter Query Rewrite Plugin System Variables”
Section 5.6.4.2, “Using the Rewriter Query Rewrite Plugin”

rewriter_enabled_for_threads_without_privilege_checks

Section 5.6.4.3.3, “Rewriter Query Rewrite Plugin System Variables”
Section 5.6.4.2, “Using the Rewriter Query Rewrite Plugin”
Section 1.3, “What Is New in MySQL 8.0”

rewriter_verbose

Section 5.6.4.3.3, “Rewriter Query Rewrite Plugin System Variables”

rpl_read_size

Section 8.12.3.1, “How MySQL Uses Memory”
Section 17.4.7, “Improving Replication Performance”
Section 17.1.6.3, “Replica Server Options and Variables”

rpl_semi_sync_master_enabled

Section 17.4.10.2, “Configuring Semisynchronous Replication”
Section 17.1.6.2, “Replication Source Options and Variables”
Section 17.4.10.3, “Semisynchronous Replication Monitoring”

rpl_semi_sync_master_timeout

Section 17.4.10.2, “Configuring Semisynchronous Replication”
Section 17.1.6.2, “Replication Source Options and Variables”

rpl_semi_sync_master_trace_level

Section 17.1.6.3, “Replica Server Options and Variables”
Section 17.1.6.2, “Replication Source Options and Variables”

rpl_semi_sync_master_wait_for_slave_count

Section 17.4.10.2, “Configuring Semisynchronous Replication”
Section 17.1.6.2, “Replication Source Options and Variables”

rpl_semi_sync_master_wait_no_slave

Section 17.1.6.2, “Replication Source Options and Variables”

rpl_semi_sync_master_wait_point

Section 17.4.10.2, “Configuring Semisynchronous Replication”
Section 17.1.6.2, “Replication Source Options and Variables”
Section 17.4.10, “Semisynchronous Replication”

rpl_semi_sync_replica_enabled

Section 17.4.10.2, “Configuring Semisynchronous Replication”
Section 17.1.6.3, “Replica Server Options and Variables”

rpl_semi_sync_replica_trace_level

Section 17.1.6.3, “Replica Server Options and Variables”

rpl_semi_sync_slave_enabled

Section 17.4.10.2, “Configuring Semisynchronous Replication”
Section 17.1.6.3, “Replica Server Options and Variables”

rpl_semi_sync_slave_trace_level

Section 17.1.6.3, “Replica Server Options and Variables”

rpl_semi_sync_source_enabled

Section 17.4.10.2, “Configuring Semisynchronous Replication”
Section 17.1.6.2, “Replication Source Options and Variables”
Section 17.4.10.3, “Semisynchronous Replication Monitoring”

rpl_semi_sync_source_timeout

Section 17.4.10.2, “Configuring Semisynchronous Replication”
Section 17.1.6.2, “Replication Source Options and Variables”

rpl_semi_sync_source_trace_level

Section 17.1.6.2, “Replication Source Options and Variables”

rpl_semi_sync_source_wait_for_replica_count

Section 17.4.10.2, “Configuring Semisynchronous Replication”
Section 17.1.6.2, “Replication Source Options and Variables”

rpl_semi_sync_source_wait_no_replica

Section 17.1.6.2, “Replication Source Options and Variables”

rpl_semi_sync_source_wait_point

Section 17.4.10.2, “Configuring Semisynchronous Replication”
Section 17.1.6.2, “Replication Source Options and Variables”
Section 17.4.10, “Semisynchronous Replication”

rpl_stop_replica_timeout

Section 17.1.6.3, “Replica Server Options and Variables”
Section 17.5.1.34, “Replication and Transaction Inconsistencies”
Section 13.4.2.10, “STOP REPLICA Statement”

rpl_stop_slave_timeout

Section 17.1.6.3, “Replica Server Options and Variables”
Section 17.5.1.34, “Replication and Transaction Inconsistencies”
Section 13.4.2.10, “STOP REPLICA Statement”

S

[index top]

schema_definition_cache

Section 14.4, “Dictionary Object Cache”
Section 5.1.8, “Server System Variables”

secondary_engine_cost_threshold

Section 5.1.8, “Server System Variables”

secure_file_priv

Section 13.2.6, “IMPORT TABLE Statement”
Section 2.10.1, “Initializing the Data Directory”
Section 2.5.4, “Installing MySQL on Linux Using RPM Packages from Oracle”
Section 13.2.9, “LOAD DATA Statement”
Section 6.1.3, “Making MySQL Secure Against Attackers”
Section 6.5.5, “MySQL Enterprise Data Masking and De-Identification Function Descriptions”
Section 2.9.7, “MySQL Source-Configuration Options”
Section 6.2.2, “Privileges Provided by MySQL”
Section 15.6.5, “Redo Log”
Section 13.2.13.1, “SELECT ... INTO Statement”
Section 6.7.4, “SELinux File Context”
Section 5.1.8, “Server System Variables”
Section 12.8, “String Functions and Operators”
Section 6.5.3, “Using MySQL Enterprise Data Masking and De-Identification”

select_into_buffer_size

Section 13.2.13.1, “SELECT ... INTO Statement”
Section 5.1.8, “Server System Variables”
Section 1.3, “What Is New in MySQL 8.0”

select_into_disk_sync

Section 13.2.13.1, “SELECT ... INTO Statement”
Section 5.1.8, “Server System Variables”
Section 1.3, “What Is New in MySQL 8.0”

select_into_disk_sync_delay

Section 13.2.13.1, “SELECT ... INTO Statement”
Section 5.1.8, “Server System Variables”
Section 1.3, “What Is New in MySQL 8.0”

server

Section 2.11.4, “Changes in MySQL 8.0”

server_id

Section 18.2.1.6.1, “Adding a Second Instance”
Section 17.1.2.8, “Adding Replicas to a Replication Environment”
Section 2.3.3.3.1.7, “Advanced Options”
Section 6.4.5.4, “Audit Log File Formats”
Section 17.1.1, “Binary Log File Position Based Replication Configuration Overview”
Section 17.1.6.4, “Binary Logging Options and Variables”
Section 2.11.4, “Changes in MySQL 8.0”
Section 18.3.1, “Group Replication Requirements”
Section 12.24, “Miscellaneous Functions”
Section 4.6.9, “mysqlbinlog — Utility for Processing Binary Log Files”
Section 23.4.3.9.2, “NDB Cluster System Variables”
Section 27.12.11, “Performance Schema Replication Tables”
Section 17.1.6.3, “Replica Server Options and Variables”
Section 17.1.6, “Replication and Binary Logging Options and Variables”
Section 17.1.6.2, “Replication Source Options and Variables”
Section 17.1.2.2, “Setting the Replica Configuration”
Section 17.1.2.1, “Setting the Replication Source Configuration”
Section 17.1.3.4, “Setting Up Replication Using GTIDs”
Section 13.7.7.35, “SHOW REPLICA STATUS Statement”
Section 5.4.4, “The Binary Log”
Section 17.5.4, “Troubleshooting Replication”
Section 17.2.1.2, “Usage of Row-Based Logging and Replication”

server_id_bits

Section 23.4.3.9.2, “NDB Cluster System Variables”

server_uuid

Section 17.3.2.2, “Binary Log Encryption Keys”
Section 13.4.2.1, “CHANGE MASTER TO Statement”
Section 13.4.2.3, “CHANGE REPLICATION SOURCE TO Statement”
Section 18.5.1.2, “Changing a Group's Mode”
Section 18.5.1.1, “Changing a Group's Primary Member”
Section 17.1.3.1, “GTID Format and Storage”
Section 27.12.11, “Performance Schema Replication Tables”
Section 18.1.3.1.1, “Primary Election Algorithm”
Section 17.1.6, “Replication and Binary Logging Options and Variables”
Section 17.1.3.6, “Replication From a Source Without GTIDs to a Replica With GTIDs”
Section 13.7.7.35, “SHOW REPLICA STATUS Statement”
Section 17.1.3.8, “Stored Function Examples to Manipulate GTIDs”
Section 27.12.21.4, “The log_status Table”
Section 27.12.11.5, “The replication_applier_configuration Table”
Section 27.12.11.2, “The replication_connection_status Table”
Section 18.4.3, “The replication_group_members Table”
Section 18.5.6, “Using MySQL Enterprise Backup with Group Replication”

session_track_gtids

Section 17.1.6.5, “Global Transaction ID System Variables”
Section 17.1.4.1, “Replication Mode Concepts”
Section 5.1.8, “Server System Variables”
Section 5.1.18, “Server Tracking of Client Session State”

session_track_schema

Section 5.1.8, “Server System Variables”
Section 5.1.18, “Server Tracking of Client Session State”

session_track_state_change

Section 5.1.8, “Server System Variables”
Section 5.1.18, “Server Tracking of Client Session State”

session_track_system_variables

Section 5.1.8, “Server System Variables”
Section 5.1.18, “Server Tracking of Client Session State”

session_track_transaction_info

Section 5.1.8, “Server System Variables”
Section 5.1.18, “Server Tracking of Client Session State”

sha

Section 6.3.3.1, “Creating SSL and RSA Certificates and Keys using MySQL”
Section 6.2.19, “Proxy Users”
Section 5.1.10, “Server Status Variables”
Section 5.1.8, “Server System Variables”
Section 6.4.1.3, “SHA-256 Pluggable Authentication”

shared_memory

Section 4.2.3, “Command Options for Connecting to the Server”
Section 4.2.4, “Connecting to the MySQL Server Using Command Options”
Section 4.5.1.1, “mysql Client Options”
Section 4.4.5, “mysql_upgrade — Check and Upgrade MySQL Tables”
Section 4.5.2, “mysqladmin — A MySQL Server Administration Program”
Section 4.6.9, “mysqlbinlog — Utility for Processing Binary Log Files”
Section 4.5.3, “mysqlcheck — A Table Maintenance Program”
Section 4.5.4, “mysqldump — A Database Backup Program”
Section 4.5.5, “mysqlimport — A Data Import Program”
Section 4.5.7, “mysqlshow — Display Database, Table, and Column Information”
Section 4.5.8, “mysqlslap — A Load Emulation Client”
Section 5.1.8, “Server System Variables”
Section 5.8.2.1, “Starting Multiple MySQL Instances at the Windows Command Line”
Section 2.3.4.5, “Starting the Server for the First Time”
Section 1.2.2, “The Main Features of MySQL”
Section 2.3.3.3.1.1, “Type and Networking”

shared_memory_base_name

Section 5.1.8, “Server System Variables”
Section 5.8.2.1, “Starting Multiple MySQL Instances at the Windows Command Line”

show_create_table_skip_secondary_engine

Section 4.5.4, “mysqldump — A Database Backup Program”
Section 5.1.8, “Server System Variables”

show_create_table_verbosity

Section 5.1.8, “Server System Variables”

show_gipk_in_create_table_and_information_schema

Section 13.1.20.11, “Generated Invisible Primary Keys”
Section 26.1, “Introduction”
Section 5.1.8, “Server System Variables”
Section 13.7.7.5, “SHOW COLUMNS Statement”
Section 13.7.7.10, “SHOW CREATE TABLE Statement”
Section 13.7.7.22, “SHOW INDEX Statement”
Section 26.3.8, “The INFORMATION_SCHEMA COLUMNS Table”
Section 26.3.34, “The INFORMATION_SCHEMA STATISTICS Table”
Section 1.3, “What Is New in MySQL 8.0”

show_old_temporals

Section 5.1.8, “Server System Variables”

skip_external_locking

Section 8.11.5, “External Locking”
Section 5.1.8, “Server System Variables”

skip_name_resolve

Section 5.1.12.3, “DNS Lookups and the Host Cache”
Section 18.10, “Frequently Asked Questions”
Section 2.10.1, “Initializing the Data Directory”
Section 5.1.14, “Network Namespace Support”
Section 5.1.8, “Server System Variables”
Section 2.3.4.9, “Testing The MySQL Installation”
Section 6.2.22, “Troubleshooting Problems Connecting to MySQL”

skip_networking

Section B.3.2.2, “Can't connect to [local] MySQL server”
Section 5.1.12.3, “DNS Lookups and the Host Cache”
Section A.14, “MySQL 8.0 FAQ: Replication”
Section B.3.2.7, “MySQL server has gone away”
Section 6.2.17, “Pluggable Authentication”
Section B.3.3.2.3, “Resetting the Root Password: Generic Instructions”
Section 5.1.7, “Server Command Options”
Section 5.1.8, “Server System Variables”
Section 17.1.2.1, “Setting the Replication Source Configuration”
Section 23.6.16.50, “The ndbinfo processes Table”
Section 6.2.22, “Troubleshooting Problems Connecting to MySQL”
Section 17.5.4, “Troubleshooting Replication”
Section 17.5.3, “Upgrading a Replication Topology”
Section 20.5.6.3, “X Plugin Status Variables”

skip_replica_start

Section 23.7.5, “Preparing the NDB Cluster for Replication”
Section 17.1.6.3, “Replica Server Options and Variables”
Section 17.1.3.4, “Setting Up Replication Using GTIDs”
Section 23.7.6, “Starting NDB Cluster Replication (Single Replication Channel)”
Section 17.2.2.3, “Startup Options and Replication Channels”

skip_show_database

Section 5.1.7, “Server Command Options”
Section 5.1.8, “Server System Variables”

skip_slave_start

Section 17.1.2.8, “Adding Replicas to a Replication Environment”
Section 23.7.9, “NDB Cluster Backups With NDB Cluster Replication”
Section 23.7.5, “Preparing the NDB Cluster for Replication”
Section 17.1.6.3, “Replica Server Options and Variables”
Section 17.1.3.4, “Setting Up Replication Using GTIDs”
Section 17.1.2.6.2, “Setting Up Replication with Existing Data”
Section 13.4.2.8, “START REPLICA Statement”
Section 23.7.6, “Starting NDB Cluster Replication (Single Replication Channel)”
Section 17.2.2.3, “Startup Options and Replication Channels”
Section 17.5.4, “Troubleshooting Replication”
Section 17.5.3, “Upgrading a Replication Topology”

slave

Section 17.1.3.6, “Replication From a Source Without GTIDs to a Replica With GTIDs”
Section 17.2.2.3, “Startup Options and Replication Channels”

slave_allow_batching

Section 23.4.3.9.2, “NDB Cluster System Variables”
Section 23.7.5, “Preparing the NDB Cluster for Replication”
Section 23.7.6, “Starting NDB Cluster Replication (Single Replication Channel)”
Section 23.2.4, “What is New in NDB Cluster”

slave_checkpoint_group

Section 23.7.3, “Known Issues in NDB Cluster Replication”
Section 12.24, “Miscellaneous Functions”
Section 17.1.6.3, “Replica Server Options and Variables”
Section 17.2.2.3, “Startup Options and Replication Channels”

slave_checkpoint_period

Section 12.24, “Miscellaneous Functions”
Section 17.1.6.3, “Replica Server Options and Variables”

slave_compressed_protocol

Section 13.4.2.1, “CHANGE MASTER TO Statement”
Section 13.4.2.3, “CHANGE REPLICATION SOURCE TO Statement”
Section 4.2.8, “Connection Compression Control”
Section 5.4.4.5.3, “Monitoring Binary Log Transaction Compression”
Section 17.1.6.3, “Replica Server Options and Variables”
Section 1.3, “What Is New in MySQL 8.0”

slave_exec_mode

Section 23.7.3, “Known Issues in NDB Cluster Replication”
Section 17.1.6.3, “Replica Server Options and Variables”
Section 17.5.1.21, “Replication and MEMORY Tables”
Section 17.2.1.2, “Usage of Row-Based Logging and Replication”

slave_load_tmpdir

Section 17.4.1.2, “Backing Up Raw Data from a Replica”
Section 7.2, “Database Backup Methods”
Section 17.1.6.3, “Replica Server Options and Variables”
Section 5.1.7, “Server Command Options”
Section 5.1.8, “Server System Variables”
Section B.3.3.5, “Where MySQL Stores Temporary Files”

slave_max_allowed_packet

Section 5.4.4.5.1, “Behaviors When Binary Log Transaction Compression is Enabled”
Section 18.3.2, “Group Replication Limitations”
Section 18.9, “Group Replication System Variables”
Section 18.7.5, “Message Fragmentation”
Section 17.1.6.3, “Replica Server Options and Variables”
Section 17.5.1.20, “Replication and max_allowed_packet”

slave_net_timeout

Section 13.4.2.1, “CHANGE MASTER TO Statement”
Section 13.4.2.3, “CHANGE REPLICATION SOURCE TO Statement”
Section 17.1.7.1, “Checking Replication Status”
Section 17.1.6.3, “Replica Server Options and Variables”
Section 17.5.1.28, “Replication and Source or Replica Shutdowns”
Section 8.14.5, “Replication I/O (Receiver) Thread States”
Section 5.1.8, “Server System Variables”

slave_parallel_type

Section 5.4.4.5.1, “Behaviors When Binary Log Transaction Compression is Enabled”
Section 17.1.6.4, “Binary Logging Options and Variables”
Section 18.3.1, “Group Replication Requirements”
Section 17.2.3.2, “Monitoring Replication Applier Worker Threads”
Section 17.1.6.3, “Replica Server Options and Variables”
Section 17.5.1.34, “Replication and Transaction Inconsistencies”

slave_parallel_workers

Section 17.1.6.4, “Binary Logging Options and Variables”
Section 13.4.2.1, “CHANGE MASTER TO Statement”
Section 5.6.7.7, “Cloning for Replication”
Section 18.3.1, “Group Replication Requirements”
Section 17.1.3.2, “GTID Life Cycle”
Section 23.7.3, “Known Issues in NDB Cluster Replication”
Section 17.1.5, “MySQL Multi-Source Replication”
Section 27.12.11, “Performance Schema Replication Tables”
Section 17.1.6.3, “Replica Server Options and Variables”
Section 17.5.1.20, “Replication and max_allowed_packet”
Section 17.5.1.34, “Replication and Transaction Inconsistencies”
Section 17.2.2, “Replication Channels”
Section 8.14.6, “Replication SQL Thread States”
Section 17.2.3, “Replication Threads”
Section 13.4.2.8, “START REPLICA Statement”
Section 13.4.2.10, “STOP REPLICA Statement”
Section 27.12.11.8, “The replication_applier_status_by_worker Table”

slave_pending_jobs_size_max

Section 2.11.4, “Changes in MySQL 8.0”
Section 8.12.3.1, “How MySQL Uses Memory”
Section 17.2.3.2, “Monitoring Replication Applier Worker Threads”
Section 17.1.6.3, “Replica Server Options and Variables”
Section 17.5.1.20, “Replication and max_allowed_packet”
Section 8.14.6, “Replication SQL Thread States”

slave_preserve_commit_order

Section 17.1.6.4, “Binary Logging Options and Variables”
Section 18.3.1, “Group Replication Requirements”
Section 17.1.3.2, “GTID Life Cycle”
Section 17.1.6.3, “Replica Server Options and Variables”
Section 17.5.1.34, “Replication and Transaction Inconsistencies”
Section 8.14.5, “Replication I/O (Receiver) Thread States”
Section 13.4.2.8, “START REPLICA Statement”

slave_rows_search_algorithms

Section 2.11.4, “Changes in MySQL 8.0”
Section 13.1.20.10, “Invisible Columns”
Section 17.1.6.3, “Replica Server Options and Variables”
Section 17.5.1.27, “Replication and Row Searches”
Section 5.1.10, “Server Status Variables”

slave_skip_errors

Section 17.1.6.3, “Replica Server Options and Variables”

slave_sql_verify_checksum

MySQL Glossary
Section 17.1.6.3, “Replica Server Options and Variables”
Section 5.4.4, “The Binary Log”

slave_transaction_retries

Section 17.1.6.3, “Replica Server Options and Variables”
Section 17.5.1.32, “Replication Retries and Timeouts”
Section 27.12.11.6, “The replication_applier_status Table”

slave_type_conversions

Section 23.7.3, “Known Issues in NDB Cluster Replication”
Section 17.1.6.3, “Replica Server Options and Variables”

slow_launch_time

Section 5.1.10, “Server Status Variables”
Section 5.1.8, “Server System Variables”

slow_query_log

Section 5.4.1, “Selecting General Query Log and Slow Query Log Output Destinations”
Section 5.1.8, “Server System Variables”
Section 5.4.5, “The Slow Query Log”

slow_query_log_file

Section 5.4.1, “Selecting General Query Log and Slow Query Log Output Destinations”
Section 5.1.8, “Server System Variables”
Section 5.4.5, “The Slow Query Log”
Section 1.3, “What Is New in MySQL 8.0”

socket

Section 5.1.8, “Server System Variables”
Section 20.5.6.2, “X Plugin Options and System Variables”

sort_buffer_size

Section 7.6.3, “How to Repair MyISAM Tables”
Section 8.2.1.16, “ORDER BY Optimization”
Section 5.1.7, “Server Command Options”
Section 5.1.10, “Server Status Variables”
Section 5.1.8, “Server System Variables”
Section 13.7.6.1, “SET Syntax for Variable Assignment”
Section 5.1.9, “Using System Variables”

source_verify_checksum

Section 17.1.6.4, “Binary Logging Options and Variables”
MySQL Glossary
Section 5.4.4, “The Binary Log”

sql_auto_is_null

Section 12.4.2, “Comparison Functions and Operators”
Section 13.1.20, “CREATE TABLE Statement”
Section 5.4.4.3, “Mixed Binary Logging Format”
Section 17.5.1.39, “Replication and Variables”
Section 5.1.8, “Server System Variables”
Section 5.4.4, “The Binary Log”

sql_big_selects

Section 5.1.8, “Server System Variables”

sql_buffer_result

Section 5.1.8, “Server System Variables”

sql_generate_invisible_primary_key

Section 13.1.20.11, “Generated Invisible Primary Keys”
Section 5.1.8, “Server System Variables”
Section 1.3, “What Is New in MySQL 8.0”

sql_log_bin

Section 17.1.6.4, “Binary Logging Options and Variables”
Section 18.4.1, “GTIDs and Group Replication”
Section 23.2.7.8, “Issues Exclusive to NDB Cluster”
Section 23.7.3, “Known Issues in NDB Cluster Replication”
Section 4.6.9, “mysqlbinlog — Utility for Processing Binary Log Files”
Section 23.7.4, “NDB Cluster Replication Schema and Tables”
Section 6.2.2, “Privileges Provided by MySQL”
Section 13.4.1.3, “SET sql_log_bin Statement”
Section 5.1.9.1, “System Variable Privileges”
Section 28.4.4.2, “The diagnostics() Procedure”
Section 28.4.4.12, “The ps_setup_reload_saved() Procedure”
Section 28.4.4.14, “The ps_setup_save() Procedure”
Section 28.4.4.22, “The ps_trace_statement_digest() Procedure”
Section 28.4.4.23, “The ps_trace_thread() Procedure”
Section 28.4.4.25, “The statement_performance_analyzer() Procedure”
Section 17.5.3, “Upgrading a Replication Topology”
Section 1.3, “What Is New in MySQL 8.0”

sql_log_off

MySQL Glossary
Section 6.2.2, “Privileges Provided by MySQL”
Section 5.4.1, “Selecting General Query Log and Slow Query Log Output Destinations”
Section 5.1.8, “Server System Variables”
Section 5.4.3, “The General Query Log”

SQL_MODE

Section 15.12.1, “Online DDL Operations”

sql_mode

Section 15.1.2, “Best Practices for InnoDB Tables”
Section 2.11.4, “Changes in MySQL 8.0”
Section 13.1.13, “CREATE EVENT Statement”
Section 13.1.17, “CREATE PROCEDURE and CREATE FUNCTION Statements”
Section 13.1.22, “CREATE TRIGGER Statement”
Section 12.25.3, “Expression Handling”
Section 1.5, “How to Report Bugs or Problems”
Section 13.2.9, “LOAD DATA Statement”
Section 5.4.4.3, “Mixed Binary Logging Format”
Section 1.6, “MySQL Standards Compliance”
Section 2.11.5, “Preparing Your Installation for Upgrade”
Section B.3.4.2, “Problems Using DATE Columns”
Section 17.5.1.39, “Replication and Variables”
Section 5.1.11, “Server SQL Modes”
Section 5.1.8, “Server System Variables”
Section 13.7.7.13, “SHOW CREATE VIEW Statement”
Section 13.6.7.5, “SIGNAL Statement”
Section 5.4.4, “The Binary Log”
Section 26.3.48, “The INFORMATION_SCHEMA VIEWS Table”
Section 28.4.5.7, “The list_add() Function”
Section 4.2.2.2, “Using Option Files”
Section 5.1.9, “Using System Variables”

sql_notes

Section B.2, “Error Information Interfaces”
Section 5.1.8, “Server System Variables”
Section 13.7.7.42, “SHOW WARNINGS Statement”
Section 13.6.7.7, “The MySQL Diagnostics Area”

sql_quote_show_create

Section 12.16, “Information Functions”
Section 5.1.8, “Server System Variables”
Section 13.7.7.6, “SHOW CREATE DATABASE Statement”
Section 13.7.7.10, “SHOW CREATE TABLE Statement”

sql_replica_skip_counter

Section 5.4.4.5.1, “Behaviors When Binary Log Transaction Compression is Enabled”
Section 17.1.6.3, “Replica Server Options and Variables”
Section 17.1.3.7, “Restrictions on Replication with GTIDs”
Section 17.1.7.3.2.1, “Skipping Transactions With SET GLOBAL sql_slave_skip_counter

sql_require_primary_key

Section 13.1.9, “ALTER TABLE Statement”
Section 13.4.2.1, “CHANGE MASTER TO Statement”
Section 13.4.2.3, “CHANGE REPLICATION SOURCE TO Statement”
Section 18.3.1, “Group Replication Requirements”
Section 17.3.3.2, “Privilege Checks For Group Replication Channels”
Section 17.3.3.1, “Privileges For The Replication PRIVILEGE_CHECKS_USER Account”
Section 17.3.3, “Replication Privilege Checks”
Section 5.1.8, “Server System Variables”
Section 18.5.6, “Using MySQL Enterprise Backup with Group Replication”

sql_safe_updates

Section 4.5.1.6, “mysql Client Tips”
Section 8.2.1.2, “Range Optimization”
Section 5.1.8, “Server System Variables”

sql_select_limit

Section 4.5.1.6, “mysql Client Tips”
Section 5.1.8, “Server System Variables”

sql_slave_skip_counter

Section 5.4.4.5.1, “Behaviors When Binary Log Transaction Compression is Enabled”
Section 17.1.6.3, “Replica Server Options and Variables”
Section 17.1.3.7, “Restrictions on Replication with GTIDs”
Section 13.7.7.35, “SHOW REPLICA STATUS Statement”
Section 17.1.7.3.2.1, “Skipping Transactions With SET GLOBAL sql_slave_skip_counter

sql_warnings

Section 5.1.8, “Server System Variables”

ssl_ca

Section 4.2.3, “Command Options for Connecting to the Server”
Section 6.3.1, “Configuring MySQL to Use Encrypted Connections”
Section 6.3.3.1, “Creating SSL and RSA Certificates and Keys using MySQL”
Section 6.3.3.2, “Creating SSL Certificates and Keys Using openssl”
Section 18.6.2, “Securing Group Communication Connections with Secure Socket Layer (SSL)”
Section 5.1.10, “Server Status Variables”
Section 5.1.8, “Server System Variables”
Section 17.3.1, “Setting Up Replication to Use Encrypted Connections”
Section 20.5.6.2, “X Plugin Options and System Variables”

ssl_capath

Section 4.2.3, “Command Options for Connecting to the Server”
Section 6.3.1, “Configuring MySQL to Use Encrypted Connections”
Section 18.6.2, “Securing Group Communication Connections with Secure Socket Layer (SSL)”
Section 5.1.10, “Server Status Variables”
Section 5.1.8, “Server System Variables”
Section 17.3.1, “Setting Up Replication to Use Encrypted Connections”
Section 20.5.6.2, “X Plugin Options and System Variables”

ssl_cert

Section 4.2.3, “Command Options for Connecting to the Server”
Section 6.3.1, “Configuring MySQL to Use Encrypted Connections”
Section 6.3.3.1, “Creating SSL and RSA Certificates and Keys using MySQL”
Section 6.3.3.2, “Creating SSL Certificates and Keys Using openssl”
Section 6.3.2, “Encrypted Connection TLS Protocols and Ciphers”
Section 18.6.2, “Securing Group Communication Connections with Secure Socket Layer (SSL)”
Section 5.1.7, “Server Command Options”
Section 5.1.10, “Server Status Variables”
Section 5.1.8, “Server System Variables”
Section 17.3.1, “Setting Up Replication to Use Encrypted Connections”
Section 20.5.6.2, “X Plugin Options and System Variables”

ssl_cipher

Section 4.2.3, “Command Options for Connecting to the Server”
Section 6.3.1, “Configuring MySQL to Use Encrypted Connections”
Section 6.3.2, “Encrypted Connection TLS Protocols and Ciphers”
Section 4.4.3, “mysql_ssl_rsa_setup — Create SSL/RSA Files”
Section 18.6.2, “Securing Group Communication Connections with Secure Socket Layer (SSL)”
Section 5.1.10, “Server Status Variables”
Section 5.1.8, “Server System Variables”
Section 20.5.6.2, “X Plugin Options and System Variables”

ssl_crl

Section 4.2.3, “Command Options for Connecting to the Server”
Section 6.3.1, “Configuring MySQL to Use Encrypted Connections”
Section 18.6.2, “Securing Group Communication Connections with Secure Socket Layer (SSL)”
Section 5.1.10, “Server Status Variables”
Section 5.1.8, “Server System Variables”
Section 20.5.6.2, “X Plugin Options and System Variables”

ssl_crlpath

Section 4.2.3, “Command Options for Connecting to the Server”
Section 6.3.1, “Configuring MySQL to Use Encrypted Connections”
Section 18.6.2, “Securing Group Communication Connections with Secure Socket Layer (SSL)”
Section 5.1.10, “Server Status Variables”
Section 5.1.8, “Server System Variables”
Section 20.5.6.2, “X Plugin Options and System Variables”

ssl_fips_mode

Section 4.2.3, “Command Options for Connecting to the Server”
Section 6.8, “FIPS Support”
Section 5.1.8, “Server System Variables”

ssl_key

Section 4.2.3, “Command Options for Connecting to the Server”
Section 6.3.1, “Configuring MySQL to Use Encrypted Connections”
Section 6.3.3.1, “Creating SSL and RSA Certificates and Keys using MySQL”
Section 6.3.3.2, “Creating SSL Certificates and Keys Using openssl”
Section 18.6.2, “Securing Group Communication Connections with Secure Socket Layer (SSL)”
Section 5.1.7, “Server Command Options”
Section 5.1.10, “Server Status Variables”
Section 5.1.8, “Server System Variables”
Section 17.3.1, “Setting Up Replication to Use Encrypted Connections”
Section 20.5.6.2, “X Plugin Options and System Variables”

ssl_session_cache_mode

Section 6.3.5, “Reusing SSL Sessions”
Section 5.1.10, “Server Status Variables”
Section 5.1.8, “Server System Variables”

ssl_session_cache_timeout

Section 6.3.5, “Reusing SSL Sessions”
Section 5.1.8, “Server System Variables”

storage_engine

Section 13.1.16, “CREATE LOGFILE GROUP Statement”

stored_program_cache

Section 8.10.3, “Caching of Prepared Statements and Stored Programs”
Section 14.4, “Dictionary Object Cache”
Section 5.1.8, “Server System Variables”

stored_program_definition_cache

Section 14.4, “Dictionary Object Cache”
Section 5.1.8, “Server System Variables”

super_read_only

Section 18.2.1.6.1, “Adding a Second Instance”
Section 25.4.2, “Event Scheduler Configuration”
Section 18.7.7.4, “Exit Action”
Section 13.7.8.3, “FLUSH Statement”
Section 18.8.3.3, “Group Replication Online Upgrade Methods”
Section 18.4.2, “Group Replication Server States”
Section 18.9, “Group Replication System Variables”
Section 18.8.1.1, “Member Versions During Upgrades”
Section 18.8.3.1, “Online Upgrade Considerations”
Section 8.2.3, “Optimizing INFORMATION_SCHEMA Queries”
Section 5.1.8, “Server System Variables”
Section 18.1.3.1, “Single-Primary Mode”
Section 13.4.3.1, “START GROUP_REPLICATION Statement”
Section 13.4.3.2, “STOP GROUP_REPLICATION Statement”
Section 18.8.3.2, “Upgrading a Group Replication Member”

sync_binlog

Section 17.1.6.4, “Binary Logging Options and Variables”
Section 17.1.3.3, “GTID Auto-Positioning”
Section 15.2, “InnoDB and the ACID Model”
Section 15.14, “InnoDB Startup Options and System Variables”
Section 17.5.1.28, “Replication and Source or Replica Shutdowns”
Section 5.4.4, “The Binary Log”

sync_master_info

Section 17.1.6.3, “Replica Server Options and Variables”

sync_relay_log

Section 17.4.2, “Handling an Unexpected Halt of a Replica”
Section 17.1.6.3, “Replica Server Options and Variables”

sync_relay_log_info

Section 17.1.6.3, “Replica Server Options and Variables”
Section 17.5.1.28, “Replication and Source or Replica Shutdowns”

sync_source_info

Section 17.1.6.3, “Replica Server Options and Variables”

syseventlog

Section 5.4.2.8, “Error Logging to the System Log”
Section 5.1.8, “Server System Variables”

system_time_zone

Section 5.1.15, “MySQL Server Time Zone Support”
Section 17.5.1.33, “Replication and Time Zones”
Section 5.1.7, “Server Command Options”
Section 5.1.8, “Server System Variables”

T

[index top]

table_definition_cache

Section 14.4, “Dictionary Object Cache”
Section 8.12.3.1, “How MySQL Uses Memory”
Section 5.1.8, “Server System Variables”

table_encryption_privilege_check

Section 13.1.2, “ALTER DATABASE Statement”
Section 13.1.9, “ALTER TABLE Statement”
Section 13.1.10, “ALTER TABLESPACE Statement”
Section 13.1.12, “CREATE DATABASE Statement”
Section 13.1.20, “CREATE TABLE Statement”
Section 13.1.21, “CREATE TABLESPACE Statement”
Section 15.13, “InnoDB Data-at-Rest Encryption”
Section 17.3.3.1, “Privileges For The Replication PRIVILEGE_CHECKS_USER Account”
Section 6.2.2, “Privileges Provided by MySQL”
Section 13.1.36, “RENAME TABLE Statement”
Section 5.1.8, “Server System Variables”
Section 1.3, “What Is New in MySQL 8.0”