alamb opened a new issue #1786:
URL: https://github.com/apache/arrow-datafusion/issues/1786
**Is your feature request related to a problem or challenge? Please describe
what you are trying to do.**
While working in IOx it is often helpful to see the physical plan at this
level:
```
SortExec: [time@0 ASC NULLS LAST,state@1 ASC NULLS LAST,city@2 ASC NULLS
LAST]
CoalescePartitionsExec
ProjectionExec: expr=[time@5 as time, state@4 as state, city@1 as city,
min_temp@3 as min_temp, max_temp@2 as max_temp, area@0 as area]
UnionExec
RepartitionExec: partitioning=RoundRobinBatch(4)
DeduplicateExec: [state@4 ASC,city@1 ASC,time@5 ASC]
SortPreservingMergeExec: [state@4 ASC,city@1 ASC,time@5 ASC]
UnionExec
<---- union maintains relative orders of 2 (repartition) ioputs
RepartitionExec: partitioning=RoundRobinBatch(4)
<--- repartition happens below union (on single partition)
IOxReadFilterNode: table_name=h2o, chunks=1
predicate=Predicate
RepartitionExec: partitioning=RoundRobinBatch(4)
IOxReadFilterNode: table_name=h2o, chunks=1
predicate=Predicate
RepartitionExec: partitioning=RoundRobinBatch(4)
IOxReadFilterNode: table_name=h2o, chunks=2 predicate=Predicate
```
However, at `debug!` level dataufusion will print out the full `Debug` impl
of the physical plan. An example of what this means:
```
2022-02-04T15:39:56.303402Z DEBUG datafusion::physical_plan::planner:
Physical plan:
SortPreservingMergeExec { input: UnionExec { inputs: [DeduplicateExec {
input: SortExec { input: IOxReadFilterNode { table_name: "h2o", iox_schema:
Schema { inner: Schema { fields: [Field { name: "city", data_type:
Dictionary(Int32, Utf8), nullable: true, dict_id: 0, dict_is_ordered: false,
metadata: Some({"iox::column::type": "iox::column_type::tag"}) }, Field { name:
"max_temp", data_type: Float64, nullable: true, dict_id: 0, dict_is_ordered:
false, metadata: Some({"iox::column::type": "iox::column_type::field::float"})
}, Field { name: "min_temp", data_type: Float64, nullable: true, dict_id: 0,
dict_is_ordered: false, metadata: Some({"iox::column::type":
"iox::column_type::field::float"}) }, Field { name: "state", data_type:
Dictionary(Int32, Utf8), nullable: true, dict_id: 0, dict_is_ordered: false,
metadata: Some({"iox::column::type": "iox::column_type::tag"}) }, Field { name:
"time", data_type: Timestamp(Nanosecond, None), nullable: false, dict_id: 0,
dict_is_ordered: false,
metadata: Some({"iox::column::type": "iox::column_type::timestamp"}) }],
metadata: {} } }, chunks: [DbChunk { addr: ChunkAddr { db_name: "placeholder",
table_name: "h2o", partition_key: "1970-01-01T00", chunk_id:
ChunkId(1d09c13a-aa09-4e92-95c5-f2eba2c5b76c) }, access_recorder:
AccessRecorder { time_provider: SystemProvider, state: RwLock { data:
AccessMetrics { count: 1, last_access: 2022-02-04T15:39:56.121557+00:00 } } },
state: MutableBuffer { chunk: ChunkSnapshot { schema: Schema { inner: Schema {
fields: [Field { name: "city", data_type: Dictionary(Int32, Utf8), nullable:
true, dict_id: 0, dict_is_ordered: false, metadata: Some({"iox::column::type":
"iox::column_type::tag"}) }, Field { name: "max_temp", data_type: Float64,
nullable: true, dict_id: 0, dict_is_ordered: false, metadata:
Some({"iox::column::type": "iox::column_type::field::float"}) }, Field { name:
"min_temp", data_type: Float64, nullable: true, dict_id: 0, dict_is_ordered:
false, metadata: Some({"iox::column::typ
e": "iox::column_type::field::float"}) }, Field { name: "state", data_type:
Dictionary(Int32, Utf8), nullable: true, dict_id: 0, dict_is_ordered: false,
metadata: Some({"iox::column::type": "iox::column_type::tag"}) }, Field { name:
"time", data_type: Timestamp(Nanosecond, None), nullable: false, dict_id: 0,
dict_is_ordered: false, metadata: Some({"iox::column::type":
"iox::column_type::timestamp"}) }], metadata: {} } }, batch: RecordBatch {
schema: Schema { fields: [Field { name: "city", data_type: Dictionary(Int32,
Utf8), nullable: true, dict_id: 0, dict_is_ordered: false, metadata:
Some({"iox::column::type": "iox::column_type::tag"}) }, Field { name:
"max_temp", data_type: Float64, nullable: true, dict_id: 0, dict_is_ordered:
false, metadata: Some({"iox::column::type": "iox::column_type::field::float"})
}, Field { name: "min_temp", data_type: Float64, nullable: true, dict_id: 0,
dict_is_ordered: false, metadata: Some({"iox::column::type":
"iox::column_type::field::float"}) }, Fie
ld { name: "state", data_type: Dictionary(Int32, Utf8), nullable: true,
dict_id: 0, dict_is_ordered: false, metadata: Some({"iox::column::type":
"iox::column_type::tag"}) }, Field { name: "time", data_type:
Timestamp(Nanosecond, None), nullable: false, dict_id: 0, dict_is_ordered:
false, metadata: Some({"iox::column::type": "iox::column_type::timestamp"}) }],
metadata: {} }, columns: [DictionaryArray {keys: PrimitiveArray<Int32>
[
0,
1,
0,
2,
] values: StringArray
[
"Boston",
"Bedford",
"Andover",
]}
, PrimitiveArray<Float64>
[
null,
null,
75.4,
69.2,
], PrimitiveArray<Float64>
[
70.4,
71.59,
null,
null,
], DictionaryArray {keys: PrimitiveArray<Int32>
[
0,
0,
0,
0,
] values: StringArray
[
"MA",
]}
, PrimitiveArray<Timestamp(Nanosecond, None)>
[
1970-01-01T00:00:00.000000050,
1970-01-01T00:00:00.000000150,
1970-01-01T00:00:00.000000250,
1970-01-01T00:00:00.000000250,
]] }, table_name: "h2o", summary: TableSummary { name: "h2o", columns:
[ColumnSummary { name: "city", influxdb_type: Some(Tag), stats:
String(StatValues { min: Some("Andover"), max: Some("Boston"), total_count: 4,
null_count: 0, distinct_count: Some(3) }) }, ColumnSummary { name: "max_temp",
influxdb_type: Some(Field), stats: F64(StatValues { min: Some(69.2), max:
Some(75.4), total_count: 4, null_count: 2, distinct_count: None }) },
ColumnSummary { name: "min_temp", influxdb_type: Some(Field), stats:
F64(StatValues { min: Some(70.4), max: Some(71.59), total_count: 4, null_count:
2, distinct_count: None }) }, ColumnSummary { name: "state", influxdb_type:
Some(Tag), stats: String(StatValues { min: Some("MA"), max: Some("MA"),
total_count: 4, null_count: 0, distinct_count: Some(1) }) }, ColumnSummary {
name: "time", influxdb_type: Some(Timestamp), stats: I64(StatValues { min:
Some(50), max: Some(250), total_count: 4, null_count: 0, distinct_count: None
}) }] } } }, meta: ChunkMetadat
a { table_summary: TableSummary { name: "h2o", columns: [ColumnSummary { name:
"city", influxdb_type: Some(Tag), stats: String(StatValues { min:
Some("Andover"), max: Some("Boston"), total_count: 4, null_count: 0,
distinct_count: Some(3) }) }, ColumnSummary { name: "max_temp", influxdb_type:
Some(Field), stats: F64(StatValues { min: Some(69.2), max: Some(75.4),
total_count: 4, null_count: 2, distinct_count: None }) }, ColumnSummary { name:
"min_temp", influxdb_type: Some(Field), stats: F64(StatValues { min:
Some(70.4), max: Some(71.59), total_count: 4, null_count: 2, distinct_count:
None }) }, ColumnSummary { name: "state", influxdb_type: Some(Tag), stats:
String(StatValues { min: Some("MA"), max: Some("MA"), total_count: 4,
null_count: 0, distinct_count: Some(1) }) }, ColumnSummary { name: "time",
influxdb_type: Some(Timestamp), stats: I64(StatValues { min: Some(50), max:
Some(250), total_count: 4, null_count: 0, distinct_count: None }) }] }, schema:
Schema { inner: Schema { fields
: [Field { name: "city", data_type: Dictionary(Int32, Utf8), nullable: true,
dict_id: 0, dict_is_ordered: false, metadata: Some({"iox::column::type":
"iox::column_type::tag"}) }, Field { name: "max_temp", data_type: Float64,
nullable: true, dict_id: 0, dict_is_ordered: false, metadata:
Some({"iox::column::type": "iox::column_type::field::float"}) }, Field { name:
"min_temp", data_type: Float64, nullable: true, dict_id: 0, dict_is_ordered:
false, metadata: Some({"iox::column::type": "iox::column_type::field::float"})
}, Field { name: "state", data_type: Dictionary(Int32, Utf8), nullable: true,
dict_id: 0, dict_is_ordered: false, metadata: Some({"iox::column::type":
"iox::column_type::tag"}) }, Field { name: "time", data_type:
Timestamp(Nanosecond, None), nullable: false, dict_id: 0, dict_is_ordered:
false, metadata: Some({"iox::column::type": "iox::column_type::timestamp"}) }],
metadata: {} } }, delete_predicates: [] }, time_of_first_write:
2022-02-04T15:39:56.121518+00:00, time_of_l
ast_write: 2022-02-04T15:39:56.121558+00:00, order: ChunkOrder(1) }],
predicate: Predicate { field_columns: None, partition_key: None, range: None,
exprs: [], value_expr: [] }, metrics: ExecutionPlanMetricsSet { inner: Mutex {
data: MetricsSet { metrics: [] } } } }, expr: [PhysicalSortExpr { expr: Column
{ name: "state", index: 3 }, options: SortOptions { descending: false,
nulls_first: true } }, PhysicalSortExpr { expr: Column { name: "city", index: 0
}, options: SortOptions { descending: false, nulls_first: true } },
PhysicalSortExpr { expr: Column { name: "time", index: 4 }, options:
SortOptions { descending: false, nulls_first: true } }], metrics_set:
CompositeMetricsSet { mid: ExecutionPlanMetricsSet { inner: Mutex { data:
MetricsSet { metrics: [] } } }, final_: ExecutionPlanMetricsSet { inner: Mutex
{ data: MetricsSet { metrics: [] } } } }, preserve_partitioning: false },
sort_keys: [PhysicalSortExpr { expr: Column { name: "state", index: 3 },
options: SortOptions { descending
: false, nulls_first: true } }, PhysicalSortExpr { expr: Column { name:
"city", index: 0 }, options: SortOptions { descending: false, nulls_first: true
} }, PhysicalSortExpr { expr: Column { name: "time", index: 4 }, options:
SortOptions { descending: false, nulls_first: true } }], metrics:
ExecutionPlanMetricsSet { inner: Mutex { data: MetricsSet { metrics: [] } } }
}, IOxReadFilterNode { table_name: "h2o", iox_schema: Schema { inner: Schema {
fields: [Field { name: "city", data_type: Dictionary(Int32, Utf8), nullable:
true, dict_id: 0, dict_is_ordered: false, metadata: Some({"iox::column::type":
"iox::column_type::tag"}) }, Field { name: "max_temp", data_type: Float64,
nullable: true, dict_id: 0, dict_is_ordered: false, metadata:
Some({"iox::column::type": "iox::column_type::field::float"}) }, Field { name:
"min_temp", data_type: Float64, nullable: true, dict_id: 0, dict_is_ordered:
false, metadata: Some({"iox::column::type": "iox::column_type::field::float"})
}, Field { name: "st
ate", data_type: Dictionary(Int32, Utf8), nullable: true, dict_id: 0,
dict_is_ordered: false, metadata: Some({"iox::column::type":
"iox::column_type::tag"}) }, Field { name: "time", data_type:
Timestamp(Nanosecond, None), nullable: false, dict_id: 0, dict_is_ordered:
false, metadata: Some({"iox::column::type": "iox::column_type::timestamp"}) }],
metadata: {} } }, chunks: [], predicate: Predicate { field_columns: None,
partition_key: None, range: None, exprs: [], value_expr: [] }, metrics:
ExecutionPlanMetricsSet { inner: Mutex { data: MetricsSet { metrics: [] } } }
}], metrics: ExecutionPlanMetricsSet { inner: Mutex { data: MetricsSet {
metrics: [] } } } }, expr: [PhysicalSortExpr { expr: Column { name: "state",
index: 3 }, options: SortOptions { descending: false, nulls_first: true } },
PhysicalSortExpr { expr: Column { name: "city", index: 0 }, options:
SortOptions { descending: false, nulls_first: true } }, PhysicalSortExpr {
expr: Column { name: "time", index: 4 }, options: Sort
Options { descending: false, nulls_first: true } }], metrics:
ExecutionPlanMetricsSet { inner: Mutex { data: MetricsSet { metrics: [] } } } }
2022-02-04T15:39:57.127969Z DEBUG datafusion::physical_plan::planner:
Optimized physical plan short version:
SortPreservingMergeExec: [state@3 ASC,city@0 ASC,time@4 ASC]
RepartitionExec: partitioning=RoundRobinBatch(4)
UnionExec
DeduplicateExec: [state@3 ASC,city@0 ASC,time@4 ASC]
SortExec: [state@3 ASC,city@0 ASC,time@4 ASC]
IOxReadFilterNode: table_name=h2o, chunks=1 predicate=Predicate
IOxReadFilterNode: table_name=h2o, chunks=0 predicate=Predicate
2022-02-04T15:39:57.204456Z DEBUG datafusion::physical_plan::planner:
Optimized physical plan:
SortPreservingMergeExec { input: RepartitionExec { input: UnionExec {
inputs: [DeduplicateExec { input: SortExec { input: IOxReadFilterNode {
table_name: "h2o", iox_schema: Schema { inner: Schema { fields: [Field { name:
"city", data_type: Dictionary(Int32, Utf8), nullable: true, dict_id: 0,
dict_is_ordered: false, metadata: Some({"iox::column::type":
"iox::column_type::tag"}) }, Field { name: "max_temp", data_type: Float64,
nullable: true, dict_id: 0, dict_is_ordered: false, metadata:
Some({"iox::column::type": "iox::column_type::field::float"}) }, Field { name:
"min_temp", data_type: Float64, nullable: true, dict_id: 0, dict_is_ordered:
false, metadata: Some({"iox::column::type": "iox::column_type::field::float"})
}, Field { name: "state", data_type: Dictionary(Int32, Utf8), nullable: true,
dict_id: 0, dict_is_ordered: false, metadata: Some({"iox::column::type":
"iox::column_type::tag"}) }, Field { name: "time", data_type:
Timestamp(Nanosecond, None), nullable: false, dict_id: 0
, dict_is_ordered: false, metadata: Some({"iox::column::type":
"iox::column_type::timestamp"}) }], metadata: {} } }, chunks: [DbChunk { addr:
ChunkAddr { db_name: "placeholder", table_name: "h2o", partition_key:
"1970-01-01T00", chunk_id: ChunkId(1d09c13a-aa09-4e92-95c5-f2eba2c5b76c) },
access_recorder: AccessRecorder { time_provider: SystemProvider, state: RwLock
{ data: AccessMetrics { count: 1, last_access: 2022-02-04T15:39:56.121557+00:00
} } }, state: MutableBuffer { chunk: ChunkSnapshot { schema: Schema { inner:
Schema { fields: [Field { name: "city", data_type: Dictionary(Int32, Utf8),
nullable: true, dict_id: 0, dict_is_ordered: false, metadata:
Some({"iox::column::type": "iox::column_type::tag"}) }, Field { name:
"max_temp", data_type: Float64, nullable: true, dict_id: 0, dict_is_ordered:
false, metadata: Some({"iox::column::type": "iox::column_type::field::float"})
}, Field { name: "min_temp", data_type: Float64, nullable: true, dict_id: 0,
dict_is_ordered: false, metadata
: Some({"iox::column::type": "iox::column_type::field::float"}) }, Field {
name: "state", data_type: Dictionary(Int32, Utf8), nullable: true, dict_id: 0,
dict_is_ordered: false, metadata: Some({"iox::column::type":
"iox::column_type::tag"}) }, Field { name: "time", data_type:
Timestamp(Nanosecond, None), nullable: false, dict_id: 0, dict_is_ordered:
false, metadata: Some({"iox::column::type": "iox::column_type::timestamp"}) }],
metadata: {} } }, batch: RecordBatch { schema: Schema { fields: [Field { name:
"city", data_type: Dictionary(Int32, Utf8), nullable: true, dict_id: 0,
dict_is_ordered: false, metadata: Some({"iox::column::type":
"iox::column_type::tag"}) }, Field { name: "max_temp", data_type: Float64,
nullable: true, dict_id: 0, dict_is_ordered: false, metadata:
Some({"iox::column::type": "iox::column_type::field::float"}) }, Field { name:
"min_temp", data_type: Float64, nullable: true, dict_id: 0, dict_is_ordered:
false, metadata: Some({"iox::column::type": "iox::column_typ
e::field::float"}) }, Field { name: "state", data_type: Dictionary(Int32,
Utf8), nullable: true, dict_id: 0, dict_is_ordered: false, metadata:
Some({"iox::column::type": "iox::column_type::tag"}) }, Field { name: "time",
data_type: Timestamp(Nanosecond, None), nullable: false, dict_id: 0,
dict_is_ordered: false, metadata: Some({"iox::column::type":
"iox::column_type::timestamp"}) }], metadata: {} }, columns: [DictionaryArray
{keys: PrimitiveArray<Int32>
[
0,
1,
0,
2,
] values: StringArray
[
"Boston",
"Bedford",
"Andover",
]}
, PrimitiveArray<Float64>
[
null,
null,
75.4,
69.2,
], PrimitiveArray<Float64>
[
70.4,
71.59,
null,
null,
], DictionaryArray {keys: PrimitiveArray<Int32>
[
0,
0,
0,
0,
] values: StringArray
[
"MA",
]}
, PrimitiveArray<Timestamp(Nanosecond, None)>
[
1970-01-01T00:00:00.000000050,
1970-01-01T00:00:00.000000150,
1970-01-01T00:00:00.000000250,
1970-01-01T00:00:00.000000250,
]] }, table_name: "h2o", summary: TableSummary { name: "h2o", columns:
[ColumnSummary { name: "city", influxdb_type: Some(Tag), stats:
String(StatValues { min: Some("Andover"), max: Some("Boston"), total_count: 4,
null_count: 0, distinct_count: Some(3) }) }, ColumnSummary { name: "max_temp",
influxdb_type: Some(Field), stats: F64(StatValues { min: Some(69.2), max:
Some(75.4), total_count: 4, null_count: 2, distinct_count: None }) },
ColumnSummary { name: "min_temp", influxdb_type: Some(Field), stats:
F64(StatValues { min: Some(70.4), max: Some(71.59), total_count: 4, null_count:
2, distinct_count: None }) }, ColumnSummary { name: "state", influxdb_type:
Some(Tag), stats: String(StatValues { min: Some("MA"), max: Some("MA"),
total_count: 4, null_count: 0, distinct_count: Some(1) }) }, ColumnSummary {
name: "time", influxdb_type: Some(Timestamp), stats: I64(StatValues { min:
Some(50), max: Some(250), total_count: 4, null_count: 0, distinct_count: None
}) }] } } }, meta: ChunkMetadat
a { table_summary: TableSummary { name: "h2o", columns: [ColumnSummary { name:
"city", influxdb_type: Some(Tag), stats: String(StatValues { min:
Some("Andover"), max: Some("Boston"), total_count: 4, null_count: 0,
distinct_count: Some(3) }) }, ColumnSummary { name: "max_temp", influxdb_type:
Some(Field), stats: F64(StatValues { min: Some(69.2), max: Some(75.4),
total_count: 4, null_count: 2, distinct_count: None }) }, ColumnSummary { name:
"min_temp", influxdb_type: Some(Field), stats: F64(StatValues { min:
Some(70.4), max: Some(71.59), total_count: 4, null_count: 2, distinct_count:
None }) }, ColumnSummary { name: "state", influxdb_type: Some(Tag), stats:
String(StatValues { min: Some("MA"), max: Some("MA"), total_count: 4,
null_count: 0, distinct_count: Some(1) }) }, ColumnSummary { name: "time",
influxdb_type: Some(Timestamp), stats: I64(StatValues { min: Some(50), max:
Some(250), total_count: 4, null_count: 0, distinct_count: None }) }] }, schema:
Schema { inner: Schema { fields
: [Field { name: "city", data_type: Dictionary(Int32, Utf8), nullable: true,
dict_id: 0, dict_is_ordered: false, metadata: Some({"iox::column::type":
"iox::column_type::tag"}) }, Field { name: "max_temp", data_type: Float64,
nullable: true, dict_id: 0, dict_is_ordered: false, metadata:
Some({"iox::column::type": "iox::column_type::field::float"}) }, Field { name:
"min_temp", data_type: Float64, nullable: true, dict_id: 0, dict_is_ordered:
false, metadata: Some({"iox::column::type": "iox::column_type::field::float"})
}, Field { name: "state", data_type: Dictionary(Int32, Utf8), nullable: true,
dict_id: 0, dict_is_ordered: false, metadata: Some({"iox::column::type":
"iox::column_type::tag"}) }, Field { name: "time", data_type:
Timestamp(Nanosecond, None), nullable: false, dict_id: 0, dict_is_ordered:
false, metadata: Some({"iox::column::type": "iox::column_type::timestamp"}) }],
metadata: {} } }, delete_predicates: [] }, time_of_first_write:
2022-02-04T15:39:56.121518+00:00, time_of_l
ast_write: 2022-02-04T15:39:56.121558+00:00, order: ChunkOrder(1) }],
predicate: Predicate { field_columns: None, partition_key: None, range: None,
exprs: [], value_expr: [] }, metrics: ExecutionPlanMetricsSet { inner: Mutex {
data: MetricsSet { metrics: [] } } } }, expr: [PhysicalSortExpr { expr: Column
{ name: "state", index: 3 }, options: SortOptions { descending: false,
nulls_first: true } }, PhysicalSortExpr { expr: Column { name: "city", index: 0
}, options: SortOptions { descending: false, nulls_first: true } },
PhysicalSortExpr { expr: Column { name: "time", index: 4 }, options:
SortOptions { descending: false, nulls_first: true } }], metrics_set:
CompositeMetricsSet { mid: ExecutionPlanMetricsSet { inner: Mutex { data:
MetricsSet { metrics: [] } } }, final_: ExecutionPlanMetricsSet { inner: Mutex
{ data: MetricsSet { metrics: [] } } } }, preserve_partitioning: false },
sort_keys: [PhysicalSortExpr { expr: Column { name: "state", index: 3 },
options: SortOptions { descending
: false, nulls_first: true } }, PhysicalSortExpr { expr: Column { name:
"city", index: 0 }, options: SortOptions { descending: false, nulls_first: true
} }, PhysicalSortExpr { expr: Column { name: "time", index: 4 }, options:
SortOptions { descending: false, nulls_first: true } }], metrics:
ExecutionPlanMetricsSet { inner: Mutex { data: MetricsSet { metrics: [] } } }
}, IOxReadFilterNode { table_name: "h2o", iox_schema: Schema { inner: Schema {
fields: [Field { name: "city", data_type: Dictionary(Int32, Utf8), nullable:
true, dict_id: 0, dict_is_ordered: false, metadata: Some({"iox::column::type":
"iox::column_type::tag"}) }, Field { name: "max_temp", data_type: Float64,
nullable: true, dict_id: 0, dict_is_ordered: false, metadata:
Some({"iox::column::type": "iox::column_type::field::float"}) }, Field { name:
"min_temp", data_type: Float64, nullable: true, dict_id: 0, dict_is_ordered:
false, metadata: Some({"iox::column::type": "iox::column_type::field::float"})
}, Field { name: "st
ate", data_type: Dictionary(Int32, Utf8), nullable: true, dict_id: 0,
dict_is_ordered: false, metadata: Some({"iox::column::type":
"iox::column_type::tag"}) }, Field { name: "time", data_type:
Timestamp(Nanosecond, None), nullable: false, dict_id: 0, dict_is_ordered:
false, metadata: Some({"iox::column::type": "iox::column_type::timestamp"}) }],
metadata: {} } }, chunks: [], predicate: Predicate { field_columns: None,
partition_key: None, range: None, exprs: [], value_expr: [] }, metrics:
ExecutionPlanMetricsSet { inner: Mutex { data: MetricsSet { metrics: [] } } }
}], metrics: ExecutionPlanMetricsSet { inner: Mutex { data: MetricsSet {
metrics: [] } } } }, partitioning: RoundRobinBatch(4), state: Mutex { data:
RepartitionExecState { channels: {}, abort_helper: AbortOnDropMany([]) } },
metrics: ExecutionPlanMetricsSet { inner: Mutex { data: MetricsSet { metrics:
[] } } } }, expr: [PhysicalSortExpr { expr: Column { name: "state", index: 3 },
options: SortOptions { descending: false,
nulls_first: true } }, PhysicalSortExpr { expr: Column { name: "city", index:
0 }, options: SortOptions { descending: false, nulls_first: true } },
PhysicalSortExpr { expr: Column { name: "time", index: 4 }, options:
SortOptions { descending: false, nulls_first: true } }], metrics:
ExecutionPlanMetricsSet { inner: Mutex { data: MetricsSet { metrics: [] } } } }
```
**Describe the solution you'd like**
Print out the summarized plan in `debug!` and print the entire details in
`trace!`
**Describe alternatives you've considered**
A clear and concise description of any alternative solutions or features
you've considered.
**Additional context**
Add any other context or screenshots about the feature request here.
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: [email protected]
For queries about this service, please contact Infrastructure at:
[email protected]
