2020-12-04 18:24:05 +00:00
---
toc_priority: 39
toc_title: EXPLAIN
---
# EXPLAIN Statement {#explain}
2021-04-21 17:49:18 +00:00
Shows the execution plan of a statement.
2020-12-04 18:24:05 +00:00
Syntax:
```sql
2021-12-16 12:23:03 +00:00
EXPLAIN [AST | SYNTAX | PLAN | PIPELINE | TABLE OVERRIDE] [setting = value, ...]
[
SELECT ... |
tableFunction(...) [COLUMNS (...)] [ORDER BY ...] [PARTITION BY ...] [PRIMARY KEY] [SAMPLE BY ...] [TTL ...]
]
[FORMAT ...]
2020-12-04 18:24:05 +00:00
```
Example:
```sql
EXPLAIN SELECT sum(number) FROM numbers(10) UNION ALL SELECT sum(number) FROM numbers(10) ORDER BY sum(number) ASC FORMAT TSV;
```
```sql
Union
Expression (Projection)
Expression (Before ORDER BY and SELECT)
Aggregating
Expression (Before GROUP BY)
SettingQuotaAndLimits (Set limits and quota after reading from storage)
ReadFromStorage (SystemNumbers)
Expression (Projection)
MergingSorted (Merge sorted streams for ORDER BY)
MergeSorting (Merge sorted blocks for ORDER BY)
PartialSorting (Sort each block for ORDER BY)
Expression (Before ORDER BY and SELECT)
Aggregating
Expression (Before GROUP BY)
SettingQuotaAndLimits (Set limits and quota after reading from storage)
ReadFromStorage (SystemNumbers)
```
## EXPLAIN Types {#explain-types}
- `AST` — Abstract syntax tree.
- `SYNTAX` — Query text after AST-level optimizations.
- `PLAN` — Query execution plan.
- `PIPELINE` — Query execution pipeline.
### EXPLAIN AST {#explain-ast}
2021-05-01 16:50:57 +00:00
Dump query AST. Supports all types of queries, not only `SELECT` .
2020-12-04 18:24:05 +00:00
2021-05-01 16:50:57 +00:00
Examples:
2020-12-04 18:24:05 +00:00
```sql
EXPLAIN AST SELECT 1;
```
```sql
SelectWithUnionQuery (children 1)
ExpressionList (children 1)
SelectQuery (children 1)
ExpressionList (children 1)
Literal UInt64_1
```
2021-04-27 16:32:48 +00:00
```sql
EXPLAIN AST ALTER TABLE t1 DELETE WHERE date = today();
```
```sql
2021-05-01 16:50:57 +00:00
explain
AlterQuery t1 (children 1)
ExpressionList (children 1)
AlterCommand 27 (children 1)
Function equals (children 1)
ExpressionList (children 2)
Identifier date
Function today (children 1)
ExpressionList
2021-04-27 16:32:48 +00:00
```
2020-12-04 18:24:05 +00:00
### EXPLAIN SYNTAX {#explain-syntax}
2021-04-21 17:49:18 +00:00
Returns query after syntax optimizations.
2020-12-04 18:24:05 +00:00
Example:
```sql
EXPLAIN SYNTAX SELECT * FROM system.numbers AS a, system.numbers AS b, system.numbers AS c;
```
```sql
SELECT
`--a.number` AS `a.number` ,
`--b.number` AS `b.number` ,
number AS `c.number`
FROM
(
SELECT
number AS `--a.number` ,
b.number AS `--b.number`
FROM system.numbers AS a
CROSS JOIN system.numbers AS b
) AS `--.s`
CROSS JOIN system.numbers AS c
```
2021-04-21 17:49:18 +00:00
2020-12-04 18:24:05 +00:00
### EXPLAIN PLAN {#explain-plan}
Dump query plan steps.
Settings:
2021-05-19 10:25:33 +00:00
- `header` — Prints output header for step. Default: 0.
- `description` — Prints step description. Default: 1.
2021-05-27 17:41:25 +00:00
- `indexes` — Shows used indexes, the number of filtered parts and the number of filtered granules for every index applied. Default: 0. Supported for [MergeTree ](../../engines/table-engines/mergetree-family/mergetree.md ) tables.
2021-05-19 10:25:33 +00:00
- `actions` — Prints detailed information about step actions. Default: 0.
- `json` — Prints query plan steps as a row in [JSON ](../../interfaces/formats.md#json ) format. Default: 0. It is recommended to use [TSVRaw ](../../interfaces/formats.md#tabseparatedraw ) format to avoid unnecessary escaping.
2020-12-04 18:24:05 +00:00
Example:
```sql
EXPLAIN SELECT sum(number) FROM numbers(10) GROUP BY number % 4;
```
```sql
Union
Expression (Projection)
Expression (Before ORDER BY and SELECT)
Aggregating
Expression (Before GROUP BY)
SettingQuotaAndLimits (Set limits and quota after reading from storage)
ReadFromStorage (SystemNumbers)
```
!!! note "Note"
2021-04-21 17:49:18 +00:00
Step and query cost estimation is not supported.
2020-12-04 18:24:05 +00:00
2021-05-25 20:21:16 +00:00
When `json = 1` , the query plan is represented in JSON format. Every node is a dictionary that always has the keys `Node Type` and `Plans` . `Node Type` is a string with a step name. `Plans` is an array with child step descriptions. Other optional keys may be added depending on node type and settings.
2021-05-19 10:25:33 +00:00
Example:
```sql
EXPLAIN json = 1, description = 0 SELECT 1 UNION ALL SELECT 2 FORMAT TSVRaw;
```
2021-05-25 20:51:59 +00:00
```json
2021-05-19 10:25:33 +00:00
[
{
"Plan": {
"Node Type": "Union",
"Plans": [
{
"Node Type": "Expression",
"Plans": [
{
"Node Type": "SettingQuotaAndLimits",
"Plans": [
{
"Node Type": "ReadFromStorage"
}
]
}
]
},
{
"Node Type": "Expression",
"Plans": [
{
"Node Type": "SettingQuotaAndLimits",
"Plans": [
{
"Node Type": "ReadFromStorage"
}
]
}
]
}
]
}
}
]
```
With `description` = 1, the `Description` key is added to the step:
2021-05-25 20:51:59 +00:00
```json
2021-05-19 10:25:33 +00:00
{
"Node Type": "ReadFromStorage",
"Description": "SystemOne"
}
```
With `header` = 1, the `Header` key is added to the step as an array of columns.
Example:
```sql
EXPLAIN json = 1, description = 0, header = 1 SELECT 1, 2 + dummy;
```
2021-05-25 20:51:59 +00:00
```json
2021-05-19 10:25:33 +00:00
[
{
"Plan": {
"Node Type": "Expression",
"Header": [
{
"Name": "1",
"Type": "UInt8"
},
{
"Name": "plus(2, dummy)",
"Type": "UInt16"
}
],
"Plans": [
{
"Node Type": "SettingQuotaAndLimits",
"Header": [
{
"Name": "dummy",
"Type": "UInt8"
}
],
"Plans": [
{
"Node Type": "ReadFromStorage",
"Header": [
{
"Name": "dummy",
"Type": "UInt8"
}
]
}
]
}
]
}
}
]
```
2021-07-29 15:27:50 +00:00
2021-05-19 10:25:33 +00:00
With `indexes` = 1, the `Indexes` key is added. It contains an array of used indexes. Each index is described as JSON with `Type` key (a string `MinMax` , `Partition` , `PrimaryKey` or `Skip` ) and optional keys:
- `Name` — An index name (for now, is used only for `Skip` index).
- `Keys` — An array of columns used by the index.
- `Condition` — A string with condition used.
- `Description` — An index (for now, is used only for `Skip` index).
- `Initial Parts` — A number of parts before the index is applied.
- `Selected Parts` — A number of parts after the index is applied.
- `Initial Granules` — A number of granules before the index is applied.
- `Selected Granulesis` — A number of granules after the index is applied.
Example:
2021-05-25 20:51:59 +00:00
```json
2021-05-19 10:25:33 +00:00
"Node Type": "ReadFromMergeTree",
"Indexes": [
{
"Type": "MinMax",
"Keys": ["y"],
"Condition": "(y in [1, +inf))",
"Initial Parts": 5,
"Selected Parts": 4,
"Initial Granules": 12,
"Selected Granules": 11
},
{
"Type": "Partition",
"Keys": ["y", "bitAnd(z, 3)"],
"Condition": "and((bitAnd(z, 3) not in [1, 1]), and((y in [1, +inf)), (bitAnd(z, 3) not in [1, 1])))",
"Initial Parts": 4,
"Selected Parts": 3,
"Initial Granules": 11,
"Selected Granules": 10
},
{
"Type": "PrimaryKey",
"Keys": ["x", "y"],
"Condition": "and((x in [11, +inf)), (y in [1, +inf)))",
"Initial Parts": 3,
"Selected Parts": 2,
"Initial Granules": 10,
"Selected Granules": 6
},
{
"Type": "Skip",
"Name": "t_minmax",
"Description": "minmax GRANULARITY 2",
"Initial Parts": 2,
"Selected Parts": 1,
"Initial Granules": 6,
"Selected Granules": 2
},
{
"Type": "Skip",
"Name": "t_set",
"Description": "set GRANULARITY 2",
"Initial Parts": 1,
"Selected Parts": 1,
"Initial Granules": 2,
"Selected Granules": 1
}
]
```
With `actions` = 1, added keys depend on step type.
Example:
```sql
EXPLAIN json = 1, actions = 1, description = 0 SELECT 1 FORMAT TSVRaw;
```
2021-05-25 20:51:59 +00:00
```json
2021-05-19 10:25:33 +00:00
[
{
"Plan": {
"Node Type": "Expression",
"Expression": {
"Inputs": [],
"Actions": [
{
"Node Type": "Column",
"Result Type": "UInt8",
"Result Type": "Column",
"Column": "Const(UInt8)",
"Arguments": [],
"Removed Arguments": [],
"Result": 0
}
],
"Outputs": [
{
"Name": "1",
"Type": "UInt8"
}
],
"Positions": [0],
"Project Input": true
},
"Plans": [
{
"Node Type": "SettingQuotaAndLimits",
"Plans": [
{
"Node Type": "ReadFromStorage"
}
]
}
]
}
}
]
```
2020-12-04 18:24:05 +00:00
### EXPLAIN PIPELINE {#explain-pipeline}
Settings:
2021-04-21 17:49:18 +00:00
- `header` — Prints header for each output port. Default: 0.
2021-04-21 20:30:09 +00:00
- `graph` — Prints a graph described in the [DOT ](https://en.wikipedia.org/wiki/DOT_(graph_description_language )) graph description language. Default: 0.
2021-04-23 19:55:36 +00:00
- `compact` — Prints graph in compact mode if `graph` setting is enabled. Default: 1.
2020-12-04 18:24:05 +00:00
Example:
```sql
EXPLAIN PIPELINE SELECT sum(number) FROM numbers_mt(100000) GROUP BY number % 4;
```
```sql
(Union)
(Expression)
ExpressionTransform
(Expression)
ExpressionTransform
(Aggregating)
Resize 2 → 1
AggregatingTransform × 2
(Expression)
ExpressionTransform × 2
(SettingQuotaAndLimits)
(ReadFromStorage)
NumbersMt × 2 0 → 1
```
2021-08-10 18:48:49 +00:00
### EXPLAIN ESTIMATE {#explain-estimate}
2021-08-14 06:06:01 +00:00
Shows the estimated number of rows, marks and parts to be read from the tables while processing the query. Works with tables in the [MergeTree ](../../engines/table-engines/mergetree-family/mergetree.md#table_engines-mergetree ) family.
2021-08-10 18:48:49 +00:00
2021-08-14 06:05:03 +00:00
**Example**
2021-08-10 18:48:49 +00:00
2021-08-13 12:15:45 +00:00
Creating a table:
2021-08-10 18:48:49 +00:00
```sql
2021-08-13 12:15:45 +00:00
CREATE TABLE ttt (i Int64) ENGINE = MergeTree() ORDER BY i SETTINGS index_granularity = 16, write_final_mark = 0;
INSERT INTO ttt SELECT number FROM numbers(128);
OPTIMIZE TABLE ttt;
2021-08-10 18:48:49 +00:00
```
2021-08-13 12:15:45 +00:00
Query:
```sql
EXPLAIN ESTIMATE SELECT * FROM ttt;
```
Result:
2021-08-10 18:48:49 +00:00
```text
2021-08-13 12:15:45 +00:00
┌─database─┬─table─┬─parts─┬─rows─┬─marks─┐
│ default │ ttt │ 1 │ 128 │ 8 │
└──────────┴───────┴───────┴──────┴───────┘
2021-08-10 18:48:49 +00:00
```
2020-12-04 18:24:05 +00:00
2021-12-16 12:23:03 +00:00
### EXPLAIN TABLE OVERRIDE {#explain-table-override}
Shows the result of a table override on a table schema accessed through a table function.
Also does some validation, throwing an exception if the override would have caused some kind of failure.
**Example**
Assume you have a remote MySQL table like this:
```sql
CREATE TABLE db.tbl (
id INT PRIMARY KEY,
created DATETIME DEFAULT now()
)
```
```sql
EXPLAIN TABLE OVERRIDE mysql('127.0.0.1:3306', 'db', 'tbl', 'root', 'clickhouse')
PARTITION BY toYYYYMM(assumeNotNull(created))
```
Result:
```text
┌─explain─────────────────────────────────────────────────┐
│ PARTITION BY uses columns: `created` Nullable(DateTime) │
└─────────────────────────────────────────────────────────┘
```
!!! note "Note"
The validation is not complete, so a successfull query does not guarantee that the override would
not cause issues.
2021-09-19 20:05:54 +00:00
[О riginal article ](https://clickhouse.com/docs/en/sql-reference/statements/explain/ ) <!--hide-->