删除数据

此页面将使用 DELETE SQL 语句，对 TiDB 中的数据进行删除。如果需要周期性地删除过期数据，可以考虑使用 TiDB 的 TTL 功能。

在开始之前

在阅读本页面之前，你需要准备以下事项：

SQL 语法

在 SQL 中，DELETE 语句一般为以下形式：

  1. DELETE FROM {table} WHERE {filter}
参数描述
{table}表名
{filter}过滤器匹配条件

此处仅展示 DELETE 的简单用法，详细文档可参考 TiDB 的 DELETE 语法。

最佳实践

以下是删除行时需要遵循的一些最佳实践：

  • 始终在删除语句中指定 WHERE 子句。如果 DELETE 没有 WHERE 子句，TiDB 将删除这个表内的所有行。
  • 需要删除大量行(数万或更多)的时候，使用批量删除，这是因为 TiDB 单个事务大小限制为 txn-total-size-limit（默认为 100MB）。
  • 如果你需要删除表内的所有数据，请勿使用 DELETE 语句，而应该使用 TRUNCATE 语句。
  • 查看性能注意事项。
  • 在需要大批量删除数据的场景下，非事务批量删除对性能的提升十分明显。但与之相对的，这将丢失删除的事务性，因此无法进行回滚，请务必正确进行操作选择。

例子

假设在开发中发现在特定时间段内，发生了业务错误，需要删除这期间内的所有 rating 的数据，例如，2022-04-15 00:00:00 至 2022-04-15 00:15:00 的数据。此时，可使用 SELECT 语句查看需删除的数据条数：

  1. SELECT COUNT(*) FROM `ratings` WHERE `rated_at` >= "2022-04-15 00:00:00" AND  `rated_at` <= "2022-04-15 00:15:00";
  • 若返回数量大于 1 万条，请参考批量删除。

  • 若返回数量小于 1 万条，可参考下面的示例进行删除：

  • SQL

  • Java
  • Golang
  • Python

在 SQL 中，删除数据的示例如下：

  1. DELETE FROM `ratings` WHERE `rated_at` >= "2022-04-15 00:00:00" AND  `rated_at` <= "2022-04-15 00:15:00";

在 Java 中，删除数据的示例如下：

  1. // ds is an entity of com.mysql.cj.jdbc.MysqlDataSource
  3. try (Connection connection = ds.getConnection()) {
  4.     String sql = "DELETE FROM `bookshop`.`ratings` WHERE `rated_at` >= ? AND  `rated_at` <= ?";
  5.     PreparedStatement preparedStatement = connection.prepareStatement(sql);
  6.     Calendar calendar = Calendar.getInstance();
  7.     calendar.set(Calendar.MILLISECOND, 0);
  9.     calendar.set(2022, Calendar.APRIL, 15, 0, 0, 0);
  10.     preparedStatement.setTimestamp(1, new Timestamp(calendar.getTimeInMillis()));
  12.     calendar.set(2022, Calendar.APRIL, 15, 0, 15, 0);
  13.     preparedStatement.setTimestamp(2, new Timestamp(calendar.getTimeInMillis()));
  15.     preparedStatement.executeUpdate();
  16. } catch (SQLException e) {
  17.     e.printStackTrace();
  18. }

在 Golang 中，删除数据的示例如下：

  1. package main
  3. import (
  4.     "database/sql"
  5.     "fmt"
  6.     "time"
  8.     _ "github.com/go-sql-driver/mysql"
  9. )
  11. func main() {
  12.     db, err := sql.Open("mysql", "root:@tcp(127.0.0.1:4000)/bookshop")
  13.     if err != nil {
  14.         panic(err)
  15.     }
  16.     defer db.Close()
  18.     startTime := time.Date(2022, 04, 15, 0, 0, 0, 0, time.UTC)
  19.     endTime := time.Date(2022, 04, 15, 0, 15, 0, 0, time.UTC)
  21.     bulkUpdateSql := fmt.Sprintf("DELETE FROM `bookshop`.`ratings` WHERE `rated_at` >= ? AND  `rated_at` <= ?")
  22.     result, err := db.Exec(bulkUpdateSql, startTime, endTime)
  23.     if err != nil {
  24.         panic(err)
  25.     }
  26.     _, err = result.RowsAffected()
  27.     if err != nil {
  28.         panic(err)
  29.     }
  30. }

在 Python 中，删除数据的示例如下：

  1. import MySQLdb
  2. import datetime
  3. import time
  5. connection = MySQLdb.connect(
  6.     host="127.0.0.1",
  7.     port=4000,
  8.     user="root",
  9.     password="",
  10.     database="bookshop",
  11.     autocommit=True
  12. )
  14. with connection:
  15.     with connection.cursor() as cursor:
  16.         start_time = datetime.datetime(2022, 4, 15)
  17.         end_time = datetime.datetime(2022, 4, 15, 0, 15)
  18.         delete_sql = "DELETE FROM `bookshop`.`ratings` WHERE `rated_at` >= %s AND `rated_at` <= %s"
  19.         affect_rows = cursor.execute(delete_sql, (start_time, end_time))
  20.         print(f'delete {affect_rows} data')

删除数据 - 图1

注意

rated_at 字段为日期和时间类型 中的 DATETIME 类型，你可以认为它在 TiDB 保存时，存储为一个字面量，与时区无关。而 TIMESTAMP 类型，将会保存一个时间戳，从而在不同的时区配置时，展示不同的时间字符串。

另外，和 MySQL 一样，TIMESTAMP 数据类型受 2038 年问题的影响。如果存储的值大于 2038，建议使用 DATETIME 类型。

性能注意事项

TiDB GC 机制

DELETE 语句运行之后 TiDB 并非立刻删除数据，而是将这些数据标记为可删除。然后等待 TiDB GC (Garbage Collection) 来清理不再需要的旧数据。因此，你的 DELETE 语句并不会立即减少磁盘用量。

GC 在默认配置中，为 10 分钟触发一次，每次 GC 都会计算出一个名为 safe_point 的时间点，这个时间点前的数据，都不会再被使用到，因此，TiDB 可以安全的对数据进行清除。

GC 的具体实现方案和细节此处不再展开，请参考 GC 机制简介 了解更详细的 GC 说明。

更新统计信息

TiDB 使用常规统计信息来决定索引的选择，因此，在大批量的数据删除之后，很有可能会导致索引选择不准确的情况发生。你可以使用手动收集的办法，更新统计信息。用以给 TiDB 优化器以更准确的统计信息来提供 SQL 性能优化。

批量删除

需要删除表中多行的数据，可选择 DELETE 示例，并使用 WHERE 子句过滤需要删除的数据。

但如果你需要删除大量行（数万或更多）的时候，建议使用一个迭代，每次都只删除一部分数据，直到删除全部完成。这是因为 TiDB 单个事务大小限制为 txn-total-size-limit（默认为 100MB）。你可以在程序或脚本中使用循环来完成操作。

本页提供了编写脚本来处理循环删除的示例，该示例演示了应如何进行 SELECT 和 DELETE 的组合，完成循环删除。

编写批量删除循环

在你的应用或脚本的循环中，编写一个 DELETE 语句，使用 WHERE 子句过滤需要删除的行，并使用 LIMIT 限制单次删除的数据条数。

批量删除例子

假设发现在特定时间段内，发生了业务错误，需要删除这期间内的所有 rating 的数据，例如，2022-04-15 00:00:00 至 2022-04-15 00:15:00 的数据。并且在 15 分钟内，有大于 1 万条数据被写入，此时请使用循环删除的方式进行删除：

  • Java
  • Golang
  • Python

在 Java 中，批量删除程序类似于以下内容：

  1. package com.pingcap.bulkDelete;
  3. import com.mysql.cj.jdbc.MysqlDataSource;
  5. import java.sql.Connection;
  6. import java.sql.PreparedStatement;
  7. import java.sql.SQLException;
  8. import java.sql.Timestamp;
  9. import java.util.Calendar;
  10. import java.util.concurrent.TimeUnit;
  12. public class BatchDeleteExample
  13. {
  14.     public static void main(String[] args) throws InterruptedException {
  15.         // Configure the example database connection.
  17.         // Create a mysql data source instance.
  18.         MysqlDataSource mysqlDataSource = new MysqlDataSource();
  20.         // Set server name, port, database name, username and password.
  21.         mysqlDataSource.setServerName("localhost");
  22.         mysqlDataSource.setPortNumber(4000);
  23.         mysqlDataSource.setDatabaseName("bookshop");
  24.         mysqlDataSource.setUser("root");
  25.         mysqlDataSource.setPassword("");
  27.         Integer updateCount = -1;
  28.         while (updateCount != 0) {
  29.             updateCount = batchDelete(mysqlDataSource);
  30.         }
  31.     }
  33.     public static Integer batchDelete (MysqlDataSource ds) {
  34.         try (Connection connection = ds.getConnection()) {
  35.             String sql = "DELETE FROM `bookshop`.`ratings` WHERE `rated_at` >= ? AND  `rated_at` <= ? LIMIT 1000";
  36.             PreparedStatement preparedStatement = connection.prepareStatement(sql);
  37.             Calendar calendar = Calendar.getInstance();
  38.             calendar.set(Calendar.MILLISECOND, 0);
  40.             calendar.set(2022, Calendar.APRIL, 15, 0, 0, 0);
  41.             preparedStatement.setTimestamp(1, new Timestamp(calendar.getTimeInMillis()));
  43.             calendar.set(2022, Calendar.APRIL, 15, 0, 15, 0);
  44.             preparedStatement.setTimestamp(2, new Timestamp(calendar.getTimeInMillis()));
  46.             int count = preparedStatement.executeUpdate();
  47.             System.out.println("delete " + count + " data");
  49.             return count;
  50.         } catch (SQLException e) {
  51.             e.printStackTrace();
  52.         }
  54.         return -1;
  55.     }
  56. }

每次迭代中，DELETE 最多删除 1000 行时间段为 2022-04-15 00:00:00 至 2022-04-15 00:15:00 的数据。

在 Golang 中，批量删除程序类似于以下内容：

  1. package main
  3. import (
  4.     "database/sql"
  5.     "fmt"
  6.     "time"
  8.     _ "github.com/go-sql-driver/mysql"
  9. )
  11. func main() {
  12.     db, err := sql.Open("mysql", "root:@tcp(127.0.0.1:4000)/bookshop")
  13.     if err != nil {
  14.         panic(err)
  15.     }
  16.     defer db.Close()
  18.     affectedRows := int64(-1)
  19.     startTime := time.Date(2022, 04, 15, 0, 0, 0, 0, time.UTC)
  20.     endTime := time.Date(2022, 04, 15, 0, 15, 0, 0, time.UTC)
  22.     for affectedRows != 0 {
  23.         affectedRows, err = deleteBatch(db, startTime, endTime)
  24.         if err != nil {
  25.             panic(err)
  26.         }
  27.     }
  28. }
  30. // deleteBatch delete at most 1000 lines per batch
  31. func deleteBatch(db *sql.DB, startTime, endTime time.Time) (int64, error) {
  32.     bulkUpdateSql := fmt.Sprintf("DELETE FROM `bookshop`.`ratings` WHERE `rated_at` >= ? AND  `rated_at` <= ? LIMIT 1000")
  33.     result, err := db.Exec(bulkUpdateSql, startTime, endTime)
  34.     if err != nil {
  35.         return -1, err
  36.     }
  37.     affectedRows, err := result.RowsAffected()
  38.     if err != nil {
  39.         return -1, err
  40.     }
  42.     fmt.Printf("delete %d data\n", affectedRows)
  43.     return affectedRows, nil
  44. }

每次迭代中，DELETE 最多删除 1000 行时间段为 2022-04-15 00:00:00 至 2022-04-15 00:15:00 的数据。

在 Python 中，批量删除程序类似于以下内容：

  1. import MySQLdb
  2. import datetime
  3. import time
  5. connection = MySQLdb.connect(
  6.     host="127.0.0.1",
  7.     port=4000,
  8.     user="root",
  9.     password="",
  10.     database="bookshop",
  11.     autocommit=True
  12. )
  14. with connection:
  15.     with connection.cursor() as cursor:
  16.         start_time = datetime.datetime(2022, 4, 15)
  17.         end_time = datetime.datetime(2022, 4, 15, 0, 15)
  18.         affect_rows = -1
  19.         while affect_rows != 0:
  20.             delete_sql = "DELETE FROM `bookshop`.`ratings` WHERE `rated_at` >= %s AND  `rated_at` <= %s LIMIT 1000"
  21.             affect_rows = cursor.execute(delete_sql, (start_time, end_time))
  22.             print(f'delete {affect_rows} data')
  23.             time.sleep(1)

每次迭代中，DELETE 最多删除 1000 行时间段为 2022-04-15 00:00:00 至 2022-04-15 00:15:00 的数据。

非事务批量删除

删除数据 - 图2

注意

TiDB 从 v6.1.0 版本开始支持非事务 DML 语句特性。在 TiDB v6.1.0 以下版本中无法使用此特性。

使用前提

在使用非事务批量删除前，请先仔细阅读非事务 DML 语句。非事务批量删除，本质是以牺牲事务的原子性、隔离性为代价，增强批量数据处理场景下的性能和易用性。

因此在使用过程中，需要极为小心，否则，因为操作的非事务特性，在误操作时会导致严重的后果（如数据丢失等）。

非事务批量删除 SQL 语法

非事务批量删除的 SQL 语法如下：

  1. BATCH ON {shard_column} LIMIT {batch_size} {delete_statement};
参数描述
{shard_column}非事务批量删除的划分列
{batch_size}非事务批量删除的每批大小
{delete_statement}删除语句

此处仅展示非事务批量删除的简单用法，详细文档可参考 TiDB 的非事务 DML 语句。

非事务批量删除使用示例

以上方批量删除例子场景为例，可使用以下 SQL 语句进行非事务批量删除：

  1. BATCH ON `rated_at` LIMIT 1000 DELETE FROM `ratings` WHERE `rated_at` >= "2022-04-15 00:00:00" AND `rated_at` <= "2022-04-15 00:15:00";