+---------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| plan_type     | plan                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
+---------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| logical_plan  | Sort: supplier.s_name ASC NULLS LAST                                                                                                                                                                                                                                                                                                                                                                                                                      |
|               |   Projection: supplier.s_name, supplier.s_address                                                                                                                                                                                                                                                                                                                                                                                                         |
|               |     LeftSemi Join: supplier.s_suppkey = __correlated_sq_1.ps_suppkey                                                                                                                                                                                                                                                                                                                                                                                      |
|               |       Projection: supplier.s_suppkey, supplier.s_name, supplier.s_address                                                                                                                                                                                                                                                                                                                                                                                 |
|               |         Inner Join: supplier.s_nationkey = nation.n_nationkey                                                                                                                                                                                                                                                                                                                                                                                             |
|               |           TableScan: supplier projection=[s_suppkey, s_name, s_address, s_nationkey]                                                                                                                                                                                                                                                                                                                                                                      |
|               |           Projection: nation.n_nationkey                                                                                                                                                                                                                                                                                                                                                                                                                  |
|               |             Filter: nation.n_name = Utf8("CANADA")                                                                                                                                                                                                                                                                                                                                                                                                        |
|               |               TableScan: nation projection=[n_nationkey, n_name]                                                                                                                                                                                                                                                                                                                                                                                          |
|               |       SubqueryAlias: __correlated_sq_1                                                                                                                                                                                                                                                                                                                                                                                                                    |
|               |         Projection: partsupp.ps_suppkey                                                                                                                                                                                                                                                                                                                                                                                                                   |
|               |           Inner Join: partsupp.ps_partkey = __scalar_sq_1.l_partkey, partsupp.ps_suppkey = __scalar_sq_1.l_suppkey Filter: CAST(partsupp.ps_availqty AS Float64) > __scalar_sq_1.__value                                                                                                                                                                                                                                                                  |
|               |             LeftSemi Join: partsupp.ps_partkey = __correlated_sq_2.p_partkey                                                                                                                                                                                                                                                                                                                                                                              |
|               |               TableScan: partsupp projection=[ps_partkey, ps_suppkey, ps_availqty]                                                                                                                                                                                                                                                                                                                                                                        |
|               |               SubqueryAlias: __correlated_sq_2                                                                                                                                                                                                                                                                                                                                                                                                            |
|               |                 Projection: part.p_partkey                                                                                                                                                                                                                                                                                                                                                                                                                |
|               |                   Filter: part.p_name LIKE Utf8("forest%")                                                                                                                                                                                                                                                                                                                                                                                                |
|               |                     TableScan: part projection=[p_partkey, p_name]                                                                                                                                                                                                                                                                                                                                                                                        |
|               |             SubqueryAlias: __scalar_sq_1                                                                                                                                                                                                                                                                                                                                                                                                                  |
|               |               Projection: lineitem.l_partkey, lineitem.l_suppkey, Float64(0.5) * CAST(SUM(lineitem.l_quantity) AS Float64) AS __value                                                                                                                                                                                                                                                                                                                     |
|               |                 Aggregate: groupBy=[[lineitem.l_partkey, lineitem.l_suppkey]], aggr=[[SUM(lineitem.l_quantity)]]                                                                                                                                                                                                                                                                                                                                          |
|               |                   Projection: lineitem.l_partkey, lineitem.l_suppkey, lineitem.l_quantity                                                                                                                                                                                                                                                                                                                                                                 |
|               |                     Filter: lineitem.l_shipdate >= Date32("8766") AND lineitem.l_shipdate < Date32("9131")                                                                                                                                                                                                                                                                                                                                                |
|               |                       TableScan: lineitem projection=[l_partkey, l_suppkey, l_quantity, l_shipdate]                                                                                                                                                                                                                                                                                                                                                       |
| physical_plan | SortPreservingMergeExec: [s_name@0 ASC NULLS LAST]                                                                                                                                                                                                                                                                                                                                                                                                        |
|               |   SortExec: expr=[s_name@0 ASC NULLS LAST]                                                                                                                                                                                                                                                                                                                                                                                                                |
|               |     ProjectionExec: expr=[s_name@1 as s_name, s_address@2 as s_address]                                                                                                                                                                                                                                                                                                                                                                                   |
|               |       CoalesceBatchesExec: target_batch_size=8192                                                                                                                                                                                                                                                                                                                                                                                                         |
|               |         HashJoinExec: mode=Partitioned, join_type=LeftSemi, on=[(Column { name: "s_suppkey", index: 0 }, Column { name: "ps_suppkey", index: 0 })]                                                                                                                                                                                                                                                                                                        |
|               |           CoalesceBatchesExec: target_batch_size=8192                                                                                                                                                                                                                                                                                                                                                                                                     |
|               |             RepartitionExec: partitioning=Hash([Column { name: "s_suppkey", index: 0 }], 2), input_partitions=2                                                                                                                                                                                                                                                                                                                                           |
|               |               RepartitionExec: partitioning=RoundRobinBatch(2), input_partitions=2                                                                                                                                                                                                                                                                                                                                                                        |
|               |                 ProjectionExec: expr=[s_suppkey@0 as s_suppkey, s_name@1 as s_name, s_address@2 as s_address]                                                                                                                                                                                                                                                                                                                                             |
|               |                   CoalesceBatchesExec: target_batch_size=8192                                                                                                                                                                                                                                                                                                                                                                                             |
|               |                     HashJoinExec: mode=Partitioned, join_type=Inner, on=[(Column { name: "s_nationkey", index: 3 }, Column { name: "n_nationkey", index: 0 })]                                                                                                                                                                                                                                                                                            |
|               |                       CoalesceBatchesExec: target_batch_size=8192                                                                                                                                                                                                                                                                                                                                                                                         |
|               |                         RepartitionExec: partitioning=Hash([Column { name: "s_nationkey", index: 3 }], 2), input_partitions=0                                                                                                                                                                                                                                                                                                                             |
|               |                           MemoryExec: partitions=0, partition_sizes=[]                                                                                                                                                                                                                                                                                                                                                                                    |
|               |                       CoalesceBatchesExec: target_batch_size=8192                                                                                                                                                                                                                                                                                                                                                                                         |
|               |                         RepartitionExec: partitioning=Hash([Column { name: "n_nationkey", index: 0 }], 2), input_partitions=2                                                                                                                                                                                                                                                                                                                             |
|               |                           RepartitionExec: partitioning=RoundRobinBatch(2), input_partitions=0                                                                                                                                                                                                                                                                                                                                                            |
|               |                             ProjectionExec: expr=[n_nationkey@0 as n_nationkey]                                                                                                                                                                                                                                                                                                                                                                           |
|               |                               CoalesceBatchesExec: target_batch_size=8192                                                                                                                                                                                                                                                                                                                                                                                 |
|               |                                 FilterExec: n_name@1 = CANADA                                                                                                                                                                                                                                                                                                                                                                                             |
|               |                                   MemoryExec: partitions=0, partition_sizes=[]                                                                                                                                                                                                                                                                                                                                                                            |
|               |           CoalesceBatchesExec: target_batch_size=8192                                                                                                                                                                                                                                                                                                                                                                                                     |
|               |             RepartitionExec: partitioning=Hash([Column { name: "ps_suppkey", index: 0 }], 2), input_partitions=2                                                                                                                                                                                                                                                                                                                                          |
|               |               ProjectionExec: expr=[ps_suppkey@1 as ps_suppkey]                                                                                                                                                                                                                                                                                                                                                                                           |
|               |                 CoalesceBatchesExec: target_batch_size=8192                                                                                                                                                                                                                                                                                                                                                                                               |
|               |                   HashJoinExec: mode=Partitioned, join_type=Inner, on=[(Column { name: "ps_partkey", index: 0 }, Column { name: "l_partkey", index: 0 }), (Column { name: "ps_suppkey", index: 1 }, Column { name: "l_suppkey", index: 1 })], filter=BinaryExpr { left: CastExpr { expr: Column { name: "ps_availqty", index: 0 }, cast_type: Float64, cast_options: CastOptions { safe: false } }, op: Gt, right: Column { name: "__value", index: 1 } } |
|               |                     CoalesceBatchesExec: target_batch_size=8192                                                                                                                                                                                                                                                                                                                                                                                           |
|               |                       RepartitionExec: partitioning=Hash([Column { name: "ps_partkey", index: 0 }, Column { name: "ps_suppkey", index: 1 }], 2), input_partitions=2                                                                                                                                                                                                                                                                                       |
|               |                         RepartitionExec: partitioning=RoundRobinBatch(2), input_partitions=2                                                                                                                                                                                                                                                                                                                                                              |
|               |                           CoalesceBatchesExec: target_batch_size=8192                                                                                                                                                                                                                                                                                                                                                                                     |
|               |                             HashJoinExec: mode=Partitioned, join_type=LeftSemi, 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                                                                                                                                                                                                                                                                                                                                                    |
|               |                                     ProjectionExec: expr=[p_partkey@0 as p_partkey]                                                                                                                                                                                                                                                                                                                                                                       |
|               |                                       CoalesceBatchesExec: target_batch_size=8192                                                                                                                                                                                                                                                                                                                                                                         |
|               |                                         FilterExec: p_name@1 LIKE forest%                                                                                                                                                                                                                                                                                                                                                                                 |
|               |                                           MemoryExec: partitions=0, partition_sizes=[]                                                                                                                                                                                                                                                                                                                                                                    |
|               |                     ProjectionExec: expr=[l_partkey@0 as l_partkey, l_suppkey@1 as l_suppkey, 0.5 * CAST(SUM(lineitem.l_quantity)@2 AS Float64) as __value]                                                                                                                                                                                                                                                                                               |
|               |                       AggregateExec: mode=FinalPartitioned, gby=[l_partkey@0 as l_partkey, l_suppkey@1 as l_suppkey], aggr=[SUM(lineitem.l_quantity)]                                                                                                                                                                                                                                                                                                     |
|               |                         CoalesceBatchesExec: target_batch_size=8192                                                                                                                                                                                                                                                                                                                                                                                       |
|               |                           RepartitionExec: partitioning=Hash([Column { name: "l_partkey", index: 0 }, Column { name: "l_suppkey", index: 1 }], 2), input_partitions=2                                                                                                                                                                                                                                                                                     |
|               |                             AggregateExec: mode=Partial, gby=[l_partkey@0 as l_partkey, l_suppkey@1 as l_suppkey], aggr=[SUM(lineitem.l_quantity)]                                                                                                                                                                                                                                                                                                        |
|               |                               RepartitionExec: partitioning=RoundRobinBatch(2), input_partitions=0                                                                                                                                                                                                                                                                                                                                                        |
|               |                                 ProjectionExec: expr=[l_partkey@0 as l_partkey, l_suppkey@1 as l_suppkey, l_quantity@2 as l_quantity]                                                                                                                                                                                                                                                                                                                     |
|               |                                   CoalesceBatchesExec: target_batch_size=8192                                                                                                                                                                                                                                                                                                                                                                             |
|               |                                     FilterExec: l_shipdate@3 >= 8766 AND l_shipdate@3 < 9131                                                                                                                                                                                                                                                                                                                                                              |
|               |                                       MemoryExec: partitions=0, partition_sizes=[]                                                                                                                                                                                                                                                                                                                                                                        |
|               |                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
+---------------+-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+