diff --git a/optimizer-fix-controls.md b/optimizer-fix-controls.md index 73af599f5777c..af1a6093716f3 100644 --- a/optimizer-fix-controls.md +++ b/optimizer-fix-controls.md @@ -57,3 +57,10 @@ SET SESSION tidb_opt_fix_control = '44262:ON,44389:ON'; - In some scenarios, when the `Probe` side of an `IndexJoin` operator contains a `Selection` operator, TiDB severely overestimates the row count of `IndexScan`. This might cause suboptimal query plans to be selected instead of `IndexJoin`. - To mitigate this issue, TiDB has introduced an improvement. However, due to potential query plan fallback risks, this improvement is disabled by default. - This variable controls whether to enable the preceding improvement. + +### [`45132`](https://github.com/pingcap/tidb/issues/45132) New in v7.4.0 + +- Default value: `1000` +- Possible values: `[0, 2147483647]` +- This variable sets the threshold for the optimizer's heuristic strategy to select access paths. If the estimated rows for an access path (such as `Index_A`) is much smaller than that of other access paths (default `1000` times), the optimizer skips the cost comparison and directly selects `Index_A`. +- `0` means to disable this heuristic strategy. \ No newline at end of file diff --git a/sql-non-prepared-plan-cache.md b/sql-non-prepared-plan-cache.md index 4feafee98d97d..028ad610a25d8 100644 --- a/sql-non-prepared-plan-cache.md +++ b/sql-non-prepared-plan-cache.md @@ -5,12 +5,10 @@ summary: Learn about the principle, usage, and examples of the SQL non-prepared # SQL Non-Prepared Execution Plan Cache -> **Warning:** -> -> The non-prepared execution plan cache is an experimental feature. It is not recommended that you use it in the production environment. This feature might be changed or removed without prior notice. If you find a bug, you can report an [issue](https://github.com/pingcap/tidb/issues) on GitHub. - TiDB supports execution plan caching for some non-`PREPARE` statements, similar to the [`Prepare`/`Execute` statements](/sql-prepared-plan-cache.md). This feature allows these statements to skip the optimization phase and improve performance. +Enabling the non-prepared plan cache might incur additional memory and CPU overhead and might not be suitable for all situations. To determine whether to enable this feature in your scenario, refer to the [Performance benefits](#performance-benefits) and [Memory monitoring](#monitoring) sections. + ## Principle The non-prepared plan cache is a session-level feature that shares a cache with the [prepared plan cache](/sql-prepared-plan-cache.md). The basic principle of the non-prepared plan cache is as follows: @@ -97,7 +95,9 @@ After you enable this feature, the optimizer quickly evaluates the query. If it ## Performance benefits -In internal tests, enabling the non-prepared plan cache feature can achieve significant performance benefits in most TP scenarios. However, it also introduces some additional performance overhead, including determining whether the query is supported and parameterizing the query. If this feature cannot support the majority of queries in your workload, enabling it might actually adversely affect performance. +In internal tests, enabling the non-prepared plan cache feature can achieve significant performance benefits in most TP scenarios. For example, a performance improvement of about 4% in TPC-C tests, over 10% in some banking workloads, and 15% in Sysbench RangeScan. + +However, this feature also introduces some additional memory and CPU overhead, including determining whether the query is supported, parameterizing the query, and searching for a plan in the cache. If the cache cannot hit the majority of queries in your workload, enabling it might actually adversely affect performance. In this case, you need to observe the `non-prepared` metric in the **Queries Using Plan Cache OPS** panel and the `non-prepared-unsupported` metric in the **Plan Cache Miss OPS** panel on Grafana. If most queries are not supported and only a few can hit the plan cache, you can disable this feature. diff --git a/sql-prepared-plan-cache.md b/sql-prepared-plan-cache.md index 62ec6a62c4694..2c3bb789993f3 100644 --- a/sql-prepared-plan-cache.md +++ b/sql-prepared-plan-cache.md @@ -23,7 +23,7 @@ In the current version of TiDB, if a `Prepare` statement meets any of the follow - The query accesses partitioned tables or temporary tables, or a table that contains generated columns. - The query contains non-correlated sub-queries, such as `SELECT * FROM t1 WHERE t1.a > (SELECT 1 FROM t2 WHERE t2.b < 1)`. - The query contains correlated sub-queries with `PhysicalApply` operators in the execution plan, such as `SELECT * FROM t1 WHERE t1.a > (SELECT a FROM t2 WHERE t1.b > t2.b)`. -- The query contains the `ignore_plan_cache` hint, such as `select /*+ ignore_plan_cache() */ * from t`. +- The query contains the `ignore_plan_cache` or `set_var` hint, such as `SELECT /*+ ignore_plan_cache() */ * FROM t` or `SELECT /*+ set_var(max_execution_time=1) */ * FROM t`. - The query contains variables other than `?` (including system variables or user-defined variables), such as `select * from t where a>? and b>@x`. - The query contains the functions that cannot be cached: `database()`, `current_user`, `current_role`, `user`, `connection_id`, `last_insert_id`, `row_count`, `version`, and `like`. - The query uses a variable as the `LIMIT` parameter (such as `LIMIT ?` and `LIMIT 10, ?`) and the variable value is greater than 10000. @@ -33,6 +33,9 @@ In the current version of TiDB, if a `Prepare` statement meets any of the follow - The query contains parameters for comparing `int` and `string`, such as `c_int >= ?` or `c_int in (?, ?)`, in which `?` indicates the string type, such as `set @x='123'`. To ensure that the query result is compatible with MySQL, parameters need to be adjusted in each query, so such queries are not cached. - The plan attempts to access `TiFlash`. - In most cases, the plan that contains `TableDual` is not cached, unless the current `Prepare` statement does not have parameters. +- The query accesses TiDB system views, such as `information_schema.columns`. It is not recommended to use `Prepare` and `Execute` statements to access system views. + +TiDB has a limitation on the number of `?` in a query. If a query contains more than 65535 `?`, an error `Prepared statement contains too many placeholders` is reported. The LRU linked list is designed as a session-level cache because `Prepare`/`Execute` cannot be executed across sessions. Each element of the LRU list is a key-value pair. The value is the execution plan, and the key is composed of the following parts: diff --git a/system-variables.md b/system-variables.md index 0408f54cde55f..2e9e5f5be6733 100644 --- a/system-variables.md +++ b/system-variables.md @@ -1943,22 +1943,19 @@ mysql> SELECT job_info FROM mysql.analyze_jobs ORDER BY end_time DESC LIMIT 1; ### tidb_enable_non_prepared_plan_cache -> **Warning:** -> -> The non-prepared execution plan cache is an experimental feature. It is not recommended that you use it in the production environment. This feature might be changed or removed without prior notice. If you find a bug, you can report an [issue](https://github.com/pingcap/tidb/issues) on GitHub. - - Scope: SESSION | GLOBAL - Persists to cluster: Yes - Applies to hint [SET_VAR](/optimizer-hints.md#set_varvar_namevar_value): Yes - Type: Boolean -- Default value: `ON` +- Default value: `OFF` - This variable controls whether to enable the [Non-prepared plan cache](/sql-non-prepared-plan-cache.md) feature. +- Enabling this feature might incur additional memory and CPU overhead and might not be suitable for all situations. Please determine whether to enable this feature according to your actual scenario. ### tidb_enable_non_prepared_plan_cache_for_dml New in v7.1.0 > **Warning:** > -> The non-prepared execution plan cache is an experimental feature. It is not recommended that you use it in the production environment. This feature might be changed or removed without prior notice. If you find a bug, you can report an [issue](https://github.com/pingcap/tidb/issues) on GitHub. +> The non-prepared execution plan cache for DML statements is an experimental feature. It is not recommended that you use it in the production environment. This feature might be changed or removed without prior notice. If you find a bug, you can report an [issue](https://github.com/pingcap/tidb/issues) on GitHub. - Scope: SESSION | GLOBAL - Persists to cluster: Yes