What are generated columns in MySQL?

Generated columns in MySQL are a feature introduced in MySQL 5.7.8, allowing users to define a column that is calculated from an expression using other columns in the same table. These columns can be either virtual or stored. Virtual generated columns are computed at the time they are read, whereas stored generated columns are calculated when the row is inserted or updated and then stored in the row.

The syntax for creating a generated column is as follows:

CREATE TABLE t1 (
  a INT,
  b INT,
  c INT AS (a   b) VIRTUAL,
  d INT AS (a   b) STORED
);

In this example, c is a virtual generated column, and d is a stored generated column, both calculated from the sum of columns a and b.

How can generated columns improve database performance in MySQL?

Generated columns can significantly improve database performance in MySQL in several ways:

1. Reduced Storage Requirements: By using virtual generated columns, you can reduce storage requirements since the values are computed on the fly rather than being stored on disk. This is particularly useful for calculations that do not need to be stored.
2. Improved Query Performance: Generated columns can be used in indexes, which can speed up query performance. For example, if you frequently query a table based on the sum of two columns, you can create a stored generated column for this sum and index it, thereby speeding up queries that use this column in their WHERE clause.
3. Simplified Queries: By pre-calculating values with generated columns, you can simplify your SQL queries, which can lead to better performance. For instance, instead of repeatedly calculating a complex expression in a SELECT statement, you can store the result of the expression in a generated column.
4. Efficient Updates: When using stored generated columns, updates to the source columns will automatically update the generated column, ensuring data consistency without additional overhead in most cases.

What types of generated columns does MySQL support and how do they differ?

MySQL supports two types of generated columns: virtual and stored.

• Virtual Generated Columns: These columns are not stored on disk; instead, they are calculated on the fly whenever the row is read. The advantage of virtual generated columns is that they save disk space because they do not store the calculated value. However, they may incur a performance cost each time they are accessed because the calculation must be performed at read time.
• Stored Generated Columns: These columns store the calculated value on disk. The value is computed and stored when the row is inserted or updated. Stored generated columns can be beneficial when the calculation is expensive or when the column is frequently accessed in queries, as the calculation is done only at the time of write operations, not at read time. However, they require additional storage space.

The choice between virtual and stored generated columns depends on the specific use case and performance considerations, such as the frequency of read and write operations, the complexity of the calculation, and the storage constraints of your database.

What are some practical use cases for implementing generated columns in MySQL?

Generated columns have several practical use cases in MySQL:

1. Calculating Age from Date of Birth: If you have a date_of_birth column in a users table, you can create a generated column to calculate the age in years. For instance:

   CREATE TABLE users (
     id INT,
     date_of_birth DATE,
     age INT AS (TIMESTAMPDIFF(YEAR, date_of_birth, CURDATE())) VIRTUAL
   );

2. Full Name Concatenation: If you have separate columns for first and last names, you can create a generated column to combine them into a full name:

   CREATE TABLE employees (
     id INT,
     first_name VARCHAR(50),
     last_name VARCHAR(50),
     full_name VARCHAR(101) AS (CONCAT(first_name, ' ', last_name)) STORED
   );

3. Geographic Calculations: For a table with latitude and longitude columns, you can create a generated column to calculate the distance from a fixed point:

   CREATE TABLE locations (
     id INT,
     lat DECIMAL(10, 8),
     lon DECIMAL(11, 8),
     distance_from_home DECIMAL(10, 2) AS (
       3959 * acos (
         cos ( radians(40.7128) )
         * cos( radians( lat ) )
         * cos( radians( lon ) - radians(-74.0060) )
           sin ( radians(40.7128) )
         * sin( radians( lat ) )
       )
     ) VIRTUAL
   );

4. Inventory Management: You can use generated columns to keep track of the total value of inventory items based on quantity and unit price:

   CREATE TABLE inventory (
     id INT,
     item_name VARCHAR(100),
     quantity INT,
     unit_price DECIMAL(10, 2),
     total_value DECIMAL(10, 2) AS (quantity * unit_price) STORED
   );

   These examples illustrate how generated columns can simplify data management and improve query performance by pre-calculating values that are frequently used in queries.

   The above is the detailed content of What are generated columns in MySQL?. For more information, please follow other related articles on the PHP Chinese website!