Enum ExplainFormat 

pub enum ExplainFormat {
    Indent,
    Tree,
    PostgresJSON,
    Graphviz,
}

Output formats for controlling for Explain plans

Variants

Indent

Indent mode

Example:

> explain format indent select x from values (1) t(x);
+---------------+-----------------------------------------------------+
| plan_type     | plan                                                |
+---------------+-----------------------------------------------------+
| logical_plan  | SubqueryAlias: t                                    |
|               |   Projection: column1 AS x                          |
|               |     Values: (Int64(1))                              |
| physical_plan | ProjectionExec: expr=[column1@0 as x]               |
|               |   DataSourceExec: partitions=1, partition_sizes=[1] |
|               |                                                     |
+---------------+-----------------------------------------------------+

Tree

Tree mode

Example:

> explain format tree select x from values (1) t(x);
+---------------+-------------------------------+
| plan_type     | plan                          |
+---------------+-------------------------------+
| physical_plan | ┌───────────────────────────┐ |
|               | │       ProjectionExec      │ |
|               | │    --------------------   │ |
|               | │        x: column1@0       │ |
|               | └─────────────┬─────────────┘ |
|               | ┌─────────────┴─────────────┐ |
|               | │       DataSourceExec      │ |
|               | │    --------------------   │ |
|               | │         bytes: 128        │ |
|               | │       format: memory      │ |
|               | │          rows: 1          │ |
|               | └───────────────────────────┘ |
|               |                               |
+---------------+-------------------------------+

PostgresJSON

Postgres Json mode

A displayable structure that produces plan in postgresql JSON format.

Users can use this format to visualize the plan in existing plan visualization tools, for example dalibo

Example:

> explain format pgjson select x from values (1) t(x);
+--------------+--------------------------------------+
| plan_type    | plan                                 |
+--------------+--------------------------------------+
| logical_plan | [                                    |
|              |   {                                  |
|              |     "Plan": {                        |
|              |       "Alias": "t",                  |
|              |       "Node Type": "Subquery",       |
|              |       "Output": [                    |
|              |         "x"                          |
|              |       ],                             |
|              |       "Plans": [                     |
|              |         {                            |
|              |           "Expressions": [           |
|              |             "column1 AS x"           |
|              |           ],                         |
|              |           "Node Type": "Projection", |
|              |           "Output": [                |
|              |             "x"                      |
|              |           ],                         |
|              |           "Plans": [                 |
|              |             {                        |
|              |               "Node Type": "Values", |
|              |               "Output": [            |
|              |                 "column1"            |
|              |               ],                     |
|              |               "Plans": [],           |
|              |               "Values": "(Int64(1))" |
|              |             }                        |
|              |           ]                          |
|              |         }                            |
|              |       ]                              |
|              |     }                                |
|              |   }                                  |
|              | ]                                    |
+--------------+--------------------------------------+

Graphviz

Graphviz mode

Example:

> explain format graphviz select x from values (1) t(x);
+--------------+------------------------------------------------------------------------+
| plan_type    | plan                                                                   |
+--------------+------------------------------------------------------------------------+
| logical_plan |                                                                        |
|              | // Begin DataFusion GraphViz Plan,                                     |
|              | // display it online here: https://dreampuf.github.io/GraphvizOnline   |
|              |                                                                        |
|              | digraph {                                                              |
|              |   subgraph cluster_1                                                   |
|              |   {                                                                    |
|              |     graph[label="LogicalPlan"]                                         |
|              |     2[shape=box label="SubqueryAlias: t"]                              |
|              |     3[shape=box label="Projection: column1 AS x"]                      |
|              |     2 -> 3 [arrowhead=none, arrowtail=normal, dir=back]                |
|              |     4[shape=box label="Values: (Int64(1))"]                            |
|              |     3 -> 4 [arrowhead=none, arrowtail=normal, dir=back]                |
|              |   }                                                                    |
|              |   subgraph cluster_5                                                   |
|              |   {                                                                    |
|              |     graph[label="Detailed LogicalPlan"]                                |
|              |     6[shape=box label="SubqueryAlias: t\nSchema: [x:Int64;N]"]         |
|              |     7[shape=box label="Projection: column1 AS x\nSchema: [x:Int64;N]"] |
|              |     6 -> 7 [arrowhead=none, arrowtail=normal, dir=back]                |
|              |     8[shape=box label="Values: (Int64(1))\nSchema: [column1:Int64;N]"] |
|              |     7 -> 8 [arrowhead=none, arrowtail=normal, dir=back]                |
|              |   }                                                                    |
|              | }                                                                      |
|              | // End DataFusion GraphViz Plan                                        |
|              |                                                                        |
+--------------+------------------------------------------------------------------------+

Trait Implementations

impl Clone for ExplainFormat

fn clone(&self) -> ExplainFormat

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl ConfigField for ExplainFormat

fn visit<V>(&self, v: &mut V, key: &str, description: &'static str)

where V: Visit,

fn set(&mut self, _: &str, value: &str) -> Result<(), DataFusionError>

fn reset(&mut self, key: &str) -> Result<(), DataFusionError>

impl Debug for ExplainFormat

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl Display for ExplainFormat

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl Eq for ExplainFormat

impl FromStr for ExplainFormat

Implement parsing strings to ExplainFormat

type Err = DataFusionError

The associated error which can be returned from parsing.

fn from_str( format: &str, ) -> Result<ExplainFormat, <ExplainFormat as FromStr>::Err>

Parses a string s to return a value of this type.

impl Hash for ExplainFormat

fn hash<__H>(&self, state: &mut __H)

where __H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for ExplainFormat

fn eq(&self, other: &ExplainFormat) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for ExplainFormat