+---------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| plan_type     | plan                                                                                                                                                                                                                                                                                                                                                                                              |
+---------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| logical_plan  | Sort: supplier_cnt DESC NULLS FIRST, part.p_brand ASC NULLS LAST, part.p_type ASC NULLS LAST, part.p_size ASC NULLS LAST                                                                                                                                                                                                                                                                          |
|               |   Projection: group_alias_0 AS part.p_brand, group_alias_1 AS part.p_type, group_alias_2 AS part.p_size, COUNT(alias1) AS supplier_cnt                                                                                                                                                                                                                                                            |
|               |     Aggregate: groupBy=[[group_alias_0, group_alias_1, group_alias_2]], aggr=[[COUNT(alias1)]]                                                                                                                                                                                                                                                                                                    |
|               |       Aggregate: groupBy=[[part.p_brand AS group_alias_0, part.p_type AS group_alias_1, part.p_size AS group_alias_2, partsupp.ps_suppkey AS alias1]], aggr=[[]]                                                                                                                                                                                                                                  |
|               |         LeftAnti Join: partsupp.ps_suppkey = __correlated_sq_1.s_suppkey                                                                                                                                                                                                                                                                                                                          |
|               |           Projection: partsupp.ps_suppkey, part.p_brand, part.p_type, part.p_size                                                                                                                                                                                                                                                                                                                 |
|               |             Inner Join: partsupp.ps_partkey = part.p_partkey                                                                                                                                                                                                                                                                                                                                      |
|               |               TableScan: partsupp projection=[ps_partkey, ps_suppkey]                                                                                                                                                                                                                                                                                                                             |
|               |               Filter: part.p_brand != Utf8("Brand#45") AND part.p_type NOT LIKE Utf8("MEDIUM POLISHED%") AND part.p_size IN ([Int32(49), Int32(14), Int32(23), Int32(45), Int32(19), Int32(3), Int32(36), Int32(9)])                                                                                                                                                                              |
|               |                 TableScan: part projection=[p_partkey, p_brand, p_type, p_size]                                                                                                                                                                                                                                                                                                                   |
|               |           SubqueryAlias: __correlated_sq_1                                                                                                                                                                                                                                                                                                                                                        |
|               |             Projection: supplier.s_suppkey AS s_suppkey                                                                                                                                                                                                                                                                                                                                           |
|               |               Filter: supplier.s_comment LIKE Utf8("%Customer%Complaints%")                                                                                                                                                                                                                                                                                                                       |
|               |                 TableScan: supplier projection=[s_suppkey, s_comment]                                                                                                                                                                                                                                                                                                                             |
| physical_plan | SortPreservingMergeExec: [supplier_cnt@3 DESC,p_brand@0 ASC NULLS LAST,p_type@1 ASC NULLS LAST,p_size@2 ASC NULLS LAST]                                                                                                                                                                                                                                                                           |
|               |   SortExec: expr=[supplier_cnt@3 DESC,p_brand@0 ASC NULLS LAST,p_type@1 ASC NULLS LAST,p_size@2 ASC NULLS LAST]                                                                                                                                                                                                                                                                                   |
|               |     ProjectionExec: expr=[group_alias_0@0 as part.p_brand, group_alias_1@1 as part.p_type, group_alias_2@2 as part.p_size, COUNT(alias1)@3 as supplier_cnt]                                                                                                                                                                                                                                       |
|               |       AggregateExec: mode=FinalPartitioned, gby=[group_alias_0@0 as group_alias_0, group_alias_1@1 as group_alias_1, group_alias_2@2 as group_alias_2], aggr=[COUNT(alias1)]                                                                                                                                                                                                                      |
|               |         CoalesceBatchesExec: target_batch_size=8192                                                                                                                                                                                                                                                                                                                                               |
|               |           RepartitionExec: partitioning=Hash([Column { name: "group_alias_0", index: 0 }, Column { name: "group_alias_1", index: 1 }, Column { name: "group_alias_2", index: 2 }], 2), input_partitions=2                                                                                                                                                                                         |
|               |             AggregateExec: mode=Partial, gby=[group_alias_0@0 as group_alias_0, group_alias_1@1 as group_alias_1, group_alias_2@2 as group_alias_2], aggr=[COUNT(alias1)]                                                                                                                                                                                                                         |
|               |               AggregateExec: mode=FinalPartitioned, gby=[group_alias_0@0 as group_alias_0, group_alias_1@1 as group_alias_1, group_alias_2@2 as group_alias_2, alias1@3 as alias1], aggr=[]                                                                                                                                                                                                       |
|               |                 CoalesceBatchesExec: target_batch_size=8192                                                                                                                                                                                                                                                                                                                                       |
|               |                   RepartitionExec: partitioning=Hash([Column { name: "group_alias_0", index: 0 }, Column { name: "group_alias_1", index: 1 }, Column { name: "group_alias_2", index: 2 }, Column { name: "alias1", index: 3 }], 2), input_partitions=2                                                                                                                                            |
|               |                     AggregateExec: mode=Partial, gby=[p_brand@1 as group_alias_0, p_type@2 as group_alias_1, p_size@3 as group_alias_2, ps_suppkey@0 as alias1], aggr=[]                                                                                                                                                                                                                          |
|               |                       CoalesceBatchesExec: target_batch_size=8192                                                                                                                                                                                                                                                                                                                                 |
|               |                         HashJoinExec: mode=Partitioned, join_type=LeftAnti, on=[(Column { name: "ps_suppkey", index: 0 }, Column { name: "s_suppkey", index: 0 })]                                                                                                                                                                                                                                |
|               |                           CoalesceBatchesExec: target_batch_size=8192                                                                                                                                                                                                                                                                                                                             |
|               |                             RepartitionExec: partitioning=Hash([Column { name: "ps_suppkey", index: 0 }], 2), input_partitions=2                                                                                                                                                                                                                                                                  |
|               |                               RepartitionExec: partitioning=RoundRobinBatch(2), input_partitions=2                                                                                                                                                                                                                                                                                                |
|               |                                 ProjectionExec: expr=[ps_suppkey@1 as ps_suppkey, p_brand@3 as p_brand, p_type@4 as p_type, p_size@5 as p_size]                                                                                                                                                                                                                                                   |
|               |                                   CoalesceBatchesExec: target_batch_size=8192                                                                                                                                                                                                                                                                                                                     |
|               |                                     HashJoinExec: mode=Partitioned, join_type=Inner, on=[(Column { name: "ps_partkey", index: 0 }, Column { name: "p_partkey", index: 0 })]                                                                                                                                                                                                                       |
|               |                                       CoalesceBatchesExec: target_batch_size=8192                                                                                                                                                                                                                                                                                                                 |
|               |                                         RepartitionExec: partitioning=Hash([Column { name: "ps_partkey", index: 0 }], 2), input_partitions=0                                                                                                                                                                                                                                                      |
|               |                                           MemoryExec: partitions=0, partition_sizes=[]                                                                                                                                                                                                                                                                                                            |
|               |                                       CoalesceBatchesExec: target_batch_size=8192                                                                                                                                                                                                                                                                                                                 |
|               |                                         RepartitionExec: partitioning=Hash([Column { name: "p_partkey", index: 0 }], 2), input_partitions=2                                                                                                                                                                                                                                                       |
|               |                                           RepartitionExec: partitioning=RoundRobinBatch(2), input_partitions=0                                                                                                                                                                                                                                                                                    |
|               |                                             CoalesceBatchesExec: target_batch_size=8192                                                                                                                                                                                                                                                                                                           |
|               |                                               FilterExec: p_brand@1 != Brand#45 AND p_type@2 NOT LIKE MEDIUM POLISHED% AND Use p_size@3 IN (SET) ([Literal { value: Int32(49) }, Literal { value: Int32(14) }, Literal { value: Int32(23) }, Literal { value: Int32(45) }, Literal { value: Int32(19) }, Literal { value: Int32(3) }, Literal { value: Int32(36) }, Literal { value: Int32(9) }]) |
|               |                                                 MemoryExec: partitions=0, partition_sizes=[]                                                                                                                                                                                                                                                                                                      |
|               |                           CoalesceBatchesExec: target_batch_size=8192                                                                                                                                                                                                                                                                                                                             |
|               |                             RepartitionExec: partitioning=Hash([Column { name: "s_suppkey", index: 0 }], 2), input_partitions=2                                                                                                                                                                                                                                                                   |
|               |                               RepartitionExec: partitioning=RoundRobinBatch(2), input_partitions=0                                                                                                                                                                                                                                                                                                |
|               |                                 ProjectionExec: expr=[s_suppkey@0 as s_suppkey]                                                                                                                                                                                                                                                                                                                   |
|               |                                   CoalesceBatchesExec: target_batch_size=8192                                                                                                                                                                                                                                                                                                                     |
|               |                                     FilterExec: s_comment@1 LIKE %Customer%Complaints%                                                                                                                                                                                                                                                                                                            |
|               |                                       MemoryExec: partitions=0, partition_sizes=[]                                                                                                                                                                                                                                                                                                                |
|               |                                                                                                                                                                                                                                                                                                                                                                                                   |
+---------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+