OBKV-HBase implements the time to live (TTL) capability at the column family and cell levels in the HBase model. This topic describes how to delete expired data at the column family or cell level by using commands or periodic tasks.
Notice
The TTL feature is available only in the KV scenario of OceanBase AI Database. It is disabled in SQL scenarios; otherwise, data may be deleted unexpectedly.
Classification
Currently, OBKV-HBase supports TTL at the column family and cell levels.
TTL type |
Description |
How to enable |
Supported versions |
|---|---|---|---|
| Column family level | Sets a TTL at the column family level. All data written to the column family expires after the specified time. | Specify the KV_ATTRIBUTES parameter in the table creation statement to enable this feature. |
|
| Cell level | Cell-level TTL allows you to set an independent expiration time for each cell. This means that even within the same column family, different cells can have different lifetimes. In this way, you can manage data lifecycles more flexibly and ensure that only the most relevant data is retained. | Create a TTL column when you define the table to enable this feature. The default value of the TTL column is NULL. |
|
Notice
You can enable both column family-level and cell-level TTL. The actual TTL value is the smaller of the two.
Usage instructions
The basic process for using the TTL feature is as follows:
- Enable TTL: Set
enable_kv_ttl = trueto enable TTL tasks for the tenant. - Define a TTL table: Specify the TTL attribute (column family level or cell level) when you create a table. You can modify or remove the TTL attribute.
- Trigger a deletion task: Trigger the deletion of expired data by running commands manually or by configuring periodic tasks. You can pause, resume, or cancel ongoing tasks.
- View the task status: Monitor task execution by using system views.
Notice
The column family-level and cell-level TTL features are used in the same way, except for the table definition syntax.
The following sections describe the details.
Step 1: Enable the TTL feature
To enable the TTL feature, set the tenant-level parameter enable_kv_ttl to true.
ALTER SYSTEM SET enable_kv_ttl= true; -- Tenant-level parameter. The default value is false.
Step 2: Define a TTL table
This section describes the table definition syntax and provides examples for column family-level and cell-level TTL.
The column family-level TTL feature is configured by using the TimeToLive and MaxVersions parameters in the KV_ATTRIBUTES attribute. For example, the following statement creates an OBKV-HBase table named t1$cf1, for which the expiration time of each row is 3600 seconds and the maximum number of versions of each row is 3.
CREATE TABLE t1$cf1 (
K VARBINARY(1024),
Q VARBINARY(256),
T BIGINT,
V VARBINARY(1048576) NOT NULL,
PRIMARY KEY(K, Q, T))
-- TimeToLive in seconds
KV_ATTRIBUTES ='{"Hbase": {"TimeToLive": 3600, "MaxVersions": 3}}'
PARTITION BY KEY(K) PARTITIONS 97;
Modify the OBKV-HBase table t1$cf1 by removing the TimeToLive attribute and changing the maximum version count to 4.
ALTER TABLE t1$cf1 KV_ATTRIBUTES ='{"Hbase": {"MaxVersions": 4}}';
Remove the expired attributes from the OBKV-HBase table t1$cf1.
ALTER TABLE t1$cf1 KV_ATTRIBUTES ='{"Hbase": {}}';
The cell-level TTL feature is enabled by creating a TTL column in the table. For example, the following statement creates an OBKV-HBase table named t1$cf1 that contains a TTL column.
CREATE TABLE `t1$cf1` (
`K` VARBINARY(1024) NOT NULL,
`Q` VARBINARY(256) NOT NULL,
`T` BIGINT(20) NOT NULL,
`V` VARBINARY(1024) DEFAULT NULL,
-- The cell-level TTL is specified when you perform DML operations such as put, increment, append, get, scan, and delete. The unit is milliseconds.
-- The TTL column must be the fifth column.
`TTL` BIGINT(20) DEFAULT NULL,
PRIMARY KEY (`K`, `Q`, `T`)
);
Step 3: Trigger a task
You can trigger a TTL deletion task in two ways:
- Trigger by using a management command: Log on to the sys tenant to trigger TTL tasks for all tenants. In addition to triggering tasks, the sys tenant also supports pausing, resuming, and canceling ongoing TTL tasks.
- Trigger by using a scheduled task: Log on to the user tenant for which you want to perform the TTL task and set the daily trigger time of the TTL task.
TTL commands are valid only in a user tenant or the sys tenant. In a user tenant, they can manage only the TTL tasks of the current tenant. In the sys tenant, they can manage the TTL tasks of all user tenants.
Log on to the sys tenant and run the following command to trigger TTL tasks for all tenants.
ALTER SYSTEM TRIGGER TTL;
To pause an ongoing TTL task, run the following command:
ALTER SYSTEM SUSPEND TTL;
To resume a paused TTL task, run the following command:
ALTER SYSTEM RESUME TTL;
To cancel an ongoing TTL task, run the following command:
ALTER SYSTEM CANCEL TTL;
Log on to the tenant for which you want to perform the TTL task and run the following command to set the daily trigger time of the TTL task.
-- The default value is an empty string (""), which indicates that the periodic TTL task is not triggered.
ALTER SYSTEM SET kv_ttl_duty_duration = '[22:00:00, 24:00:00]';
Step 4: View the task status
You can view the status and related information of current and historical TTL tasks through views. Four views are related to TTL tasks. For more information, see OBKV-HBase views.
Task types
OBKV-HBase currently has two types of TTL tasks: normal TTL tasks and HBase rowkey TTL tasks. They correspond to the task_type column in the task status view.
- Normal TTL tasks
Triggered by commands or periodic tasks, a normal TTL task first generates a tenant-level TTL task (corresponding to the record whose table ID is -1). It also generates tablet-level TTL tasks for all tables that have expiration rules defined and executes them. Each tablet-level task performs a full scan of the corresponding tablet to identify and delete expired data. After all tablet-level tasks are completed, all task records of the tenant-level TTL task are moved to the history table.
- HBase rowkey TTL tasks
Triggered at fixed intervals, an HBase rowkey TTL task moves old HBase rowkey TTL task records to the history table every day, generates a new tenant-level HBase rowkey TTL task (corresponding to the record whose table ID is -2), and generates tablet-level TTL tasks for all tables that have expiration rules defined. The execution of these tablet-level tasks is triggered by user requests. They collect expired rows involved in scan or get operations (that is, rows that have expired based on TTL or MaxVersion) and generate TTL tasks that scan only those rows. After a task is executed, the results (scan_cnt, max_version_del_cnt, and ttl_del_cnt) are summarized in the corresponding tablet-level task.
Task status description
TTL tasks are divided into two categories: tenant-level tasks and tablet-level tasks, each with different statuses. These statuses can be viewed in the task views DBA_OB_KV_TTL_TASKS and CDB_OB_KV_TTL_TASKS, and in the historical task views DBA_OB_KV_TTL_TASK_HISTORY and CDB_OB_KV_TTL_TASK_HISTORY.
Notice
The TABLE_NAME for a tenant-level task is NULL, and both TABLET_ID and TABLE_ID are -1.
Tablet-level task status:
Task status |
Description |
|---|---|
| PREPARED | Prepared. Expired data has not been deleted yet. |
| RUNNING | Running. The system is deleting expired data in the partition. |
| PENDING | Pending. You can resume the task by using commands. |
| CANCELED | Canceled. The task cannot be resumed. |
| FINISHED | Finished. The task will be moved to the history table. |
| INVALID | Invalid. |
Tenant-level task status:
Task status |
Description |
|---|---|
| RS_TRIGGERING | The TTL task of the tenant is being executed. |
| RS_SUSPENDING | The TTL task of the tenant is suspended. |
| RS_CANCELING | The TTL task of the tenant is canceled. |
| RS_MOVING | All TTL task records are being moved to the history table. |
| INVALID | Invalid. |
Set the history task retention period (optional)
To prevent historical TTL tasks from accumulating and occupying unnecessary storage space, you can use the kv_ttl_history_recycle_interval parameter to set the retention period of historical TTL task records of a tenant. The default value is 7 days.
For example, to automatically delete historical TTL task records that have been retained for more than 30 days, run the following command:
ALTER SYSTEM SET kv_ttl_history_recycle_interval= '30d';
Performance optimization
Set the degree of parallelism
You can use the tenant-level parameter ttl_thread_score to set the number of worker threads for TTL tasks. The default value is 2.
For example, to change the number of worker threads for TTL tasks to 10:
ALTER SYSTEM SET ttl_thread_score = 10;
TTL task throttling
TTL tasks continuously consume CPU and log write bandwidth during deletion. When the tenant specifications are limited or the write pressure from the business frontend is high, excessive TTL throughput may affect frontend request latency. To balance background cleanup efficiency and online business stability, OBKV-HBase provides the TTL deletion throughput throttling capability.
You can use the tenant-level parameter kv_ttl_delete_max_ops to limit the maximum number of delete operations per second for all TTL tasks in a tenant. This capability controls the upper limit of the deletion rate rather than guaranteeing a fixed rate. The actual throughput fluctuates with the system load, resources, and task distribution.
When throttling is disabled, TTL deletion tasks use available resources to execute as efficiently as possible. After throttling is enabled:
- The throttling value applies to the total deletion throughput of all concurrent TTL subtasks in the current tenant.
- The upper limit of the throughput that a single subtask can achieve depends on the concurrency level ttl_thread_score and is dynamically allocated among multiple concurrent tasks. For example, when
kv_ttl_delete_max_ops=1000andttl_thread_score=2, the concurrency level of TTL tasks is 2, and at most two TTL tasks run at the same time. The maximum total deletion throughput of all TTL tasks does not exceed 1000, and the average maximum deletion throughput of each TTL task does not exceed 1000/2 = 500. - In most scenarios, this reduces the impact of TTL tasks on CPU and log write bandwidth, but it prolongs the execution of TTL tasks accordingly.
We recommend that you enable or tighten throttling in the following scenarios:
- The tenant has limited resource specifications and a large amount of data in TTL tables.
- During business peak hours, frontend write and update requests are frequent, and the business is sensitive to latency jitter.
- Frontend request latency must be prioritized while background cleanup efficiency is also considered.
You can evaluate the throttling effect and gradually tune it based on the changes in the deletion count and task duration in DBA_OB_KV_TTL_TASK_HISTORY.
Considerations
Filter change logs
Notice
This feature is supported since OceanBase AI Database V4.6.3 and requires liboblog V4.6.3 or later.
TTL tasks generate a large number of change logs (CLOGs) when deleting expired data. By default, CDC (liboblog) captures and consumes these change logs and then synchronizes them to downstream components. When a large amount of expired data exists, the large number of logs generated by TTL deletion imposes additional processing pressure and resource overhead on the CDC link.
To reduce the resource pressure on the CDC link, you can enable TTL change log filtering on the CDC side (filter_ttl_delete_log). After filtering is enabled, the change logs generated by TTL tasks are filtered by CDC and are no longer output downstream. By default, filtering is disabled, and TTL change logs are consumed by CDC as usual. Filtering affects only the change logs of TTL tasks and does not change the execution logic of the TTL tasks.
Visibility of expired data
If you use the OBKV-HBase interface to operate on an expired record, the behavior is the same as if the record did not exist. For example, if a record whose primary key is k1 in a relational table has expired, inserting another record whose primary key is k1 succeeds instead of reporting a primary key conflict.
Action |
Expired |
Return code |
Affected rows |
Others |
|---|---|---|---|---|
| insert | N | -5024 OB_ERR_PRIMARY_KEY_DUPLICATE |
0 | |
| insert | Y | 0 OB_SUCCESS |
1 | |
| delete | N | 0 OB_SUCCESS |
1 | |
| delete | Y | 0 OB_SUCCESS |
0 | |
| update | N | 0 OB_SUCCESS |
1 | |
| update | Y | 0 OB_SUCCESS |
0 | |
| replace | N | 0 OB_SUCCESS |
2 | |
| replace | Y | 0 OB_SUCCESS |
1 | |
| insert_or_update | N | 0 OB_SUCCESS |
1 | |
| insert_or_update | Y | 0 OB_SUCCESS |
1 | |
| increment | N | 0 OB_SUCCESS |
1 | |
| increment | Y | 0 OB_SUCCESS |
1 | All columns except the incremented column are set to their default values. |
| append | N | 0 OB_SUCCESS |
1 | |
| append | Y | 0 OB_SUCCESS |
1 | All columns except the appended column are set to their default values. |
| query/get | N | 0 OB_SUCCESS |
/ | Data is read. |
| query/get | Y | 0 OB_SUCCESS |
/ | No data is read. |
Note
The SQL interface does not mask expired data. Expired data remains visible until it is deleted by the TTL task.
Task execution mechanism
A TTL deletion task is a background low-priority task, and it cannot guarantee that expired data is deleted immediately. To avoid a significant impact on system performance, the task automatically pauses in the following circumstances:
- Memory pressure: When the MemStore memory usage
MEMSTORE_USEDexceeds the thresholdFREEZE_TRIGGER, the task pauses until the memory usage drops below the threshold. You can view the memory usage in the GV$OB_MEMSTORE view. - Physical restore: For a tenant that is being physically restored, the TTL task pauses until the restore is completed.
Storage space release
Because OceanBase AI Database uses an LSM-tree architecture, a delete operation is essentially an append write (writing a delete marker). Therefore, after a TTL task deletes expired data, the storage space is not released immediately and may even increase temporarily. The final release of storage space depends on major compaction.
To ensure that storage space is released promptly, we recommend that you use TTL tasks together with major freeze:
- Set the execution time window of TTL tasks (kv_ttl_duty_duration).
- Set the execution time of major freeze (major_freeze_duty_time) to a time after the TTL task window.
In this way, major compaction is automatically triggered after the TTL task is completed, and the storage space is released.
Examples
Column family level
The following is a complete example of column family-level TTL:
Enable the TTL feature.
ALTER SYSTEM SET enable_kv_ttl= true;Create an OBKV-HBase table.
CREATE TABLE t1$cf1 ( K VARBINARY(1024), Q VARBINARY(256), T BIGINT, V VARBINARY(1048576) NOT NULL, PRIMARY KEY(K, Q, T)) KV_ATTRIBUTES ='{"Hbase": {"TimeToLive": 3600, "MaxVersions": 3}}' PARTITION BY KEY(K) PARTITIONS 3;Simulate data insertion into the OBKV-HBase table.
For more information about how to insert data in OBKV-HBase, see Connect to a cluster by using the OBKV-HBase Java client. Example:
INSERT INTO t1$cf1 VALUES ("row1", "cq1", -truncate(time_to_usec(date_sub(now(), interval +1 hour))/1000, 0), "del"), ("row1", "cq1", -truncate(time_to_usec(now())/1000, 0), "no del"), ("row2", "cq1", -truncate(time_to_usec(date_sub(now(), interval +1 hour))/1000, 0), "del"), ("row2", "cq1", -truncate(time_to_usec(now())/1000, 0), "no del"), ("row3", "cq1", -truncate(time_to_usec(date_sub(now(), interval +1 hour))/1000, 0), "del"), ("row3", "cq1", -truncate(time_to_usec(now())/1000, 0), "no del"), ("row4", "cq1", -truncate(time_to_usec(date_sub(now(), interval +1 hour))/1000, 0), "del"), ("row4", "cq1", -truncate(time_to_usec(now())/1000, 0), "no del");Set the daily TTL task time for the tenant so that the task is automatically triggered.
-- A TTL task is triggered once starting from 00:00. ALTER SYSTEM SET kv_ttl_duty_duration = '[00:00:00, 23:59:59]';View the task execution status.
View the current task. The execution result depends on the actual task status.
obclient> SELECT * FROM oceanbase.dba_ob_kv_ttl_tasks;The return result is as follows:
+------------+----------+-----------+---------+----------------------------+----------------------------+--------------+---------------+-------------+---------------------+----------+------------+ | TABLE_NAME | TABLE_ID | TABLET_ID | TASK_ID | START_TIME | END_TIME | TRIGGER_TYPE | STATUS | TTL_DEL_CNT | MAX_VERSION_DEL_CNT | SCAN_CNT | RET_CODE | +------------+----------+-----------+---------+----------------------------+----------------------------+--------------+---------------+-------------+---------------------+----------+------------+ | NULL | -1 | -1 | 1 | 2023-09-28 11:35:02.695292 | 2023-09-28 11:35:17.720627 | PERIODIC | RS_TRIGGERING | 0 | 0 | 0 | OB_SUCCESS | | t1$cf1 | 500002 | 200001 | 1 | 2023-09-28 11:35:06.612708 | 2023-09-28 11:35:06.612708 | PERIODIC | PREPARED | 0 | 0 | 0 | OB_SUCCESS | | t1$cf1 | 500002 | 200002 | 1 | 2023-09-28 11:35:06.612711 | 2023-09-28 11:35:06.612711 | PERIODIC | PREPARED | 0 | 0 | 0 | OB_SUCCESS | | t1$cf1 | 500002 | 200003 | 1 | 2023-09-28 11:35:06.612712 | 2023-09-28 11:35:06.612712 | PERIODIC | PREPARED | 0 | 0 | 0 | OB_SUCCESS | +------------+----------+-----------+---------+----------------------------+----------------------------+--------------+---------------+-------------+---------------------+----------+------------+ 4 rows in setView historical tasks. The execution result depends on the actual task status.
obclient> SELECT * FROM oceanbase.dba_ob_kv_ttl_task_history;The return result is as follows:
+------------+----------+-----------+---------+----------------------------+----------------------------+--------------+----------+-------------+---------------------+----------+------------+ | TABLE_NAME | TABLE_ID | TABLET_ID | TASK_ID | START_TIME | END_TIME | TRIGGER_TYPE | STATUS | TTL_DEL_CNT | MAX_VERSION_DEL_CNT | SCAN_CNT | RET_CODE | +------------+----------+-----------+---------+----------------------------+----------------------------+--------------+----------+-------------+---------------------+----------+------------+ | NULL | -1 | -1 | 1 | 2023-09-28 11:35:02.695292 | 2023-09-28 11:35:17.720627 | PERIODIC | FINISHED | 0 | 0 | 0 | OB_SUCCESS | | t1$cf1 | 500002 | 200001 | 1 | 2023-09-28 11:35:06.612708 | 2023-09-28 11:35:11.634029 | PERIODIC | FINISHED | 1 | 0 | 2 | OB_SUCCESS | | t1$cf1 | 500002 | 200002 | 1 | 2023-09-28 11:35:06.612711 | 2023-09-28 11:35:11.632463 | PERIODIC | FINISHED | 1 | 0 | 2 | OB_SUCCESS | | t1$cf1 | 500002 | 200003 | 1 | 2023-09-28 11:35:06.612712 | 2023-09-28 11:35:11.627921 | PERIODIC | FINISHED | 2 | 0 | 4 | OB_SUCCESS | +------------+----------+-----------+---------+----------------------------+----------------------------+--------------+----------+-------------+---------------------+----------+------------+ 4 rows in set
View the data in the current OBKV-HBase table.
obclient> SELECT * FROM t1$cf1;The return result is as follows:
+------+-----+----------------+--------+ | K | Q | T | V | +------+-----+----------------+--------+ | row3 | cq1 | -1695872081000 | no del | | row4 | cq1 | -1695872081000 | no del | | row1 | cq1 | -1695872081000 | no del | | row2 | cq1 | -1695872081000 | no del | +------+-----+----------------+--------+ 4 rows in set
Cell level
The following is a complete example of cell-level TTL:
Create an OBKV-HBase table named t1$cf1 that contains a TTL column.
CREATE TABLE `t1$cf1` (
`K` VARBINARY(1024) NOT NULL,
`Q` VARBINARY(256) NOT NULL,
`T` BIGINT(20) NOT NULL,
`V` VARBINARY(1024) DEFAULT NULL,
-- The cell-level TTL is specified when you perform DML operations such as put, increment, append, get, scan, and delete. The unit is milliseconds.
-- The TTL column must be the fifth column.
`TTL` BIGINT(20) DEFAULT NULL,
PRIMARY KEY (`K`, `Q`, `T`)
);
Examples of data operations are as follows:
put operation
Put put1 = new Put(key1.getBytes()); put1.addColumn(family.getBytes(), column1.getBytes(), toBytes(11L)); put1.addColumn(family.getBytes(), column2.getBytes(), toBytes(11L)); // In this put operation, the TTL of each cell is set to 300 milliseconds, indicating that the cells expire after 300 milliseconds. // The deletion of expired data depends on the execution of the TTL background task. If the rowkey TTL task is not enabled, you can still query these expired cells by using SQL before they are flushed. If the rowkey TTL task is enabled, you can query the data of these cells by using SQL until the next scan, but you cannot retrieve it by using a get operation, because a get operation automatically filters out expired cells. put1.setTTL(300); hTable.put(put1);increment operation
Increment increment = new Increment(key1.getBytes()); increment.addColumn(family.getBytes(), column1.getBytes(), 1L); increment.addColumn(family.getBytes(), column2.getBytes(), 2L); // If TTL is not set for the increment, the new cell generated by the increment uses the TTL value of the queried cell. // If TTL is set for the increment, the TTL value of the new cell generated by the increment is the value set for the increment. // After this increment operation, if you query the table within 500 milliseconds, the newly inserted cell is expected to be returned. If you query the table after 500 milliseconds, the cell is expected not to be returned. increment.setTTL(500); hTable.increment(increment);append operation
Append append = new Append(key1.getBytes()); append.add(family.getBytes(), column1.getBytes(), toBytes(11L)); append.add(family.getBytes(), column2.getBytes(), toBytes(11L)); // Same as the increment operation. append.setTTL(500); hTable.append(append);get/scan operation
A get or scan operation does not support setting a TTL, but automatically filters out expired cells during queries. In addition, the scanned cells record the expiration status of their rowkeys. If a rowkey contains an expired cell, the rowkey TTL is triggered to promptly delete the expired cell.
delete operation
A delete operation has a
setTTLinterface, and a delete operation with a TTL set reports an error. The delete operation deletes the latest version that has not expired. If the latest version has expired, it deletes the cell of the second version. For example, if the latest version of a cell has a TTL set and has expired, the delete operation removes the cell of the next version. Here is a code example:hTable.put(put1); hTable.put(put2); Delete del = new Delete(key1.getBytes()); del.addColumn(family.getBytes(), column1.getBytes()); hTable.delete(del);The table data before the delete operation is as follows:
+------+-----+----------------+--------+--------+ | K | Q | T | V | TTL | +------+-----+----------------+--------+--------+ | key1 | cf1 | -1741157319257 | value | 5 | | key1 | cf1 | -1741157319182 | value | NULL | +------+-----+----------------+--------+--------+ 2 rows in setThe table data after the delete operation is as follows:
+------+-----+----------------+--------+--------+ | K | Q | T | V | TTL | +------+-----+----------------+--------+--------+ | key1 | cf1 | -1741157319257 | value | 5 | +------+-----+----------------+--------+--------+ 1 row in setThe output shows that the data of the second version is deleted, but the expired data is not deleted.
Set a rate limit for TTL tasks
Create an OBKV-HBase table and set a TTL (in seconds) for the column family.
CREATE TABLE `test$family` ( `K` varbinary(1024) NOT NULL, `Q` varbinary(256) NOT NULL, `T` bigint(20) NOT NULL, `V` varbinary(1024) DEFAULT NULL, PRIMARY KEY (`K`, `Q`, `T`) ) ORGANIZATION INDEX DEFAULT CHARSET = utf8mb4 ROW_FORMAT = DYNAMIC COMPRESSION = 'zstd_1.3.8' REPLICA_NUM = 1 BLOCK_SIZE = 16384 USE_BLOOM_FILTER = FALSE ENABLE_MACRO_BLOCK_BLOOM_FILTER = FALSE TABLET_SIZE = 134217728 PCTFREE = 0 KV_ATTRIBUTES = '{"HBase": {"TimeToLive": 1}}' PARTITION BY KEY(`K`) PARTITIONS 20;Import data by using the YCSB tool to simulate the generation of expired data. For more information, see Performance testing of OBKV-HBase.
Set a rate limit for TTL tasks.
ALTER SYSTEM SET kv_ttl_delete_max_ops = 20000;Calculate the average deletion throughput of TTL tasks over a period of time by using a view.
SELECT TABLE_NAME, sum(TTL_DEL_CNT) + sum(MAX_VERSION_DEL_CNT) as total_ttl_del_cnt, min(START_TIME) as START_TIME, max(END_TIME) as END_TIME, CASE WHEN TIMESTAMPDIFF(MICROSECOND, min(START_TIME), max(END_TIME)) > 0 THEN (sum(TTL_DEL_CNT) + sum(MAX_VERSION_DEL_CNT)) * 1000000.0 / TIMESTAMPDIFF(MICROSECOND, min(START_TIME), max(END_TIME)) ELSE -1 END as avg_ops FROM oceanbase.DBA_OB_KV_TTL_TASK_HISTORY WHERE STATUS = 'FINISHED' AND START_TIME >= '2026-03-19 15:49:00' -- Replace with your start time. AND END_TIME <= '2026-03-19 16:10:00' -- Replace with your end time. GROUP BY TABLE_NAME; -- Group and count by table name.View throttling information in the log.
During TTL task execution, the OBServer log prints throttling-related information about every 30 seconds.
grep "TTL TASK DELETE RATE" -rn observer.log*