== Physical Plan ==
VeloxColumnarToRow (28)
+- ^ SortExecTransformer (26)
   +- ^ InputIteratorTransformer (25)
      +- ColumnarExchange (23)
         +- VeloxResizeBatches (22)
            +- ^ ProjectExecTransformer (20)
               +- ^ BroadcastHashJoinExecTransformer Inner BuildRight (19)
                  :- ^ FilterExecTransformer (2)
                  :  +- ^ FileSourceScanExecTransformer parquet spark_catalog.default.supplier (1)
                  +- ^ InputIteratorTransformer (18)
                     +- ColumnarBroadcastExchange (16)
                        +- ^ FilterExecTransformer (14)
                           +- ^ RegularHashAggregateExecTransformer (13)
                              +- ^ InputIteratorTransformer (12)
                                 +- ColumnarExchange (10)
                                    +- VeloxResizeBatches (9)
                                       +- ^ ProjectExecTransformer (7)
                                          +- ^ FlushableHashAggregateExecTransformer (6)
                                             +- ^ ProjectExecTransformer (5)
                                                +- ^ FilterExecTransformer (4)
                                                   +- ^ FileSourceScanExecTransformer parquet spark_catalog.default.lineitem (3)


(1) FileSourceScanExecTransformer parquet spark_catalog.default.supplier
Output [4]: [s_suppkey#1, s_name#2, s_address#3, s_phone#4]
Batched: true
Location: InMemoryFileIndex [{warehouse_dir}/supplier]
PushedFilters: [IsNotNull(s_suppkey)]
ReadSchema: struct<s_suppkey:bigint,s_name:string,s_address:string,s_phone:string>

(2) FilterExecTransformer
Input [4]: [s_suppkey#1, s_name#2, s_address#3, s_phone#4]
Arguments: isnotnull(s_suppkey#1)

(3) FileSourceScanExecTransformer parquet spark_catalog.default.lineitem
Output [4]: [l_suppkey#5, l_extendedprice#6, l_discount#7, l_shipdate#8]
Batched: true
Location: InMemoryFileIndex [{warehouse_dir}/lineitem]
PushedFilters: [IsNotNull(l_shipdate), GreaterThanOrEqual(l_shipdate,1996-01-01), LessThan(l_shipdate,1996-04-01), IsNotNull(l_suppkey)]
ReadSchema: struct<l_suppkey:bigint,l_extendedprice:decimal(10,0),l_discount:decimal(10,0),l_shipdate:date>

(4) FilterExecTransformer
Input [4]: [l_suppkey#5, l_extendedprice#6, l_discount#7, l_shipdate#8]
Arguments: (((isnotnull(l_shipdate#8) AND (l_shipdate#8 >= 1996-01-01)) AND (l_shipdate#8 < 1996-04-01)) AND isnotnull(l_suppkey#5))

(5) ProjectExecTransformer
Output [2]: [l_suppkey#5, (l_extendedprice#6 * (1 - l_discount#7)) AS _pre_1#9]
Input [4]: [l_suppkey#5, l_extendedprice#6, l_discount#7, l_shipdate#8]

(6) FlushableHashAggregateExecTransformer
Input [2]: [l_suppkey#5, _pre_1#9]
Keys [1]: [l_suppkey#5]
Functions [1]: [partial_sum(_pre_1#9)]
Aggregate Attributes [2]: [sum#10, isEmpty#11]
Results [3]: [l_suppkey#5, sum#12, isEmpty#13]

(7) ProjectExecTransformer
Output [4]: [hash(l_suppkey#5, 42) AS hash_partition_key#14, l_suppkey#5, sum#12, isEmpty#13]
Input [3]: [l_suppkey#5, sum#12, isEmpty#13]

(8) WholeStageCodegenTransformer (3)
Input [4]: [hash_partition_key#14, l_suppkey#5, sum#12, isEmpty#13]
Arguments: false

(9) VeloxResizeBatches
Input [4]: [hash_partition_key#14, l_suppkey#5, sum#12, isEmpty#13]
Arguments: 1024, 2147483647, 10485760

(10) ColumnarExchange
Input [4]: [hash_partition_key#14, l_suppkey#5, sum#12, isEmpty#13]
Arguments: hashpartitioning(l_suppkey#5, 1), ENSURE_REQUIREMENTS, [l_suppkey#5, sum#12, isEmpty#13], [plan_id=1], [shuffle_writer_type=hash]

(11) InputAdapter
Input [3]: [l_suppkey#5, sum#12, isEmpty#13]

(12) InputIteratorTransformer
Input [3]: [l_suppkey#5, sum#12, isEmpty#13]

(13) RegularHashAggregateExecTransformer
Input [3]: [l_suppkey#5, sum#12, isEmpty#13]
Keys [1]: [l_suppkey#5]
Functions [1]: [sum((l_extendedprice#6 * (1 - l_discount#7)))]
Aggregate Attributes [1]: [sum((l_extendedprice#6 * (1 - l_discount#7)))#15]
Results [2]: [l_suppkey#5 AS supplier_no#16, sum((l_extendedprice#6 * (1 - l_discount#7)))#15 AS total_revenue#17]

(14) FilterExecTransformer
Input [2]: [supplier_no#16, total_revenue#17]
Arguments: (isnotnull(total_revenue#17) AND (total_revenue#17 = Subquery scalar-subquery#18, [id=#2]))

(15) WholeStageCodegenTransformer (4)
Input [2]: [supplier_no#16, total_revenue#17]
Arguments: false

(16) ColumnarBroadcastExchange
Input [2]: [supplier_no#16, total_revenue#17]
Arguments: HashedRelationBroadcastMode(List(input[0, bigint, true]),false), [plan_id=3]

(17) InputAdapter
Input [2]: [supplier_no#16, total_revenue#17]

(18) InputIteratorTransformer
Input [2]: [supplier_no#16, total_revenue#17]

(19) BroadcastHashJoinExecTransformer
Left keys [1]: [s_suppkey#1]
Right keys [1]: [supplier_no#16]
Join type: Inner
Join condition: None

(20) ProjectExecTransformer
Output [5]: [s_suppkey#1, s_name#2, s_address#3, s_phone#4, total_revenue#17]
Input [6]: [s_suppkey#1, s_name#2, s_address#3, s_phone#4, supplier_no#16, total_revenue#17]

(21) WholeStageCodegenTransformer (5)
Input [5]: [s_suppkey#1, s_name#2, s_address#3, s_phone#4, total_revenue#17]
Arguments: false

(22) VeloxResizeBatches
Input [5]: [s_suppkey#1, s_name#2, s_address#3, s_phone#4, total_revenue#17]
Arguments: 1024, 2147483647, 10485760

(23) ColumnarExchange
Input [5]: [s_suppkey#1, s_name#2, s_address#3, s_phone#4, total_revenue#17]
Arguments: rangepartitioning(s_suppkey#1 ASC NULLS FIRST, 1), ENSURE_REQUIREMENTS, [plan_id=4], [shuffle_writer_type=hash]

(24) InputAdapter
Input [5]: [s_suppkey#1, s_name#2, s_address#3, s_phone#4, total_revenue#17]

(25) InputIteratorTransformer
Input [5]: [s_suppkey#1, s_name#2, s_address#3, s_phone#4, total_revenue#17]

(26) SortExecTransformer
Input [5]: [s_suppkey#1, s_name#2, s_address#3, s_phone#4, total_revenue#17]
Arguments: [s_suppkey#1 ASC NULLS FIRST], true, 0

(27) WholeStageCodegenTransformer (6)
Input [5]: [s_suppkey#1, s_name#2, s_address#3, s_phone#4, total_revenue#17]
Arguments: false

(28) VeloxColumnarToRow
Input [5]: [s_suppkey#1, s_name#2, s_address#3, s_phone#4, total_revenue#17]

===== Subqueries =====

Subquery:1 Hosting operator id = 14 Hosting Expression = Subquery scalar-subquery#18, [id=#2]
VeloxColumnarToRow (43)
+- ^ RegularHashAggregateExecTransformer (41)
   +- ^ ProjectExecTransformer (40)
      +- ^ RegularHashAggregateExecTransformer (39)
         +- ^ InputIteratorTransformer (38)
            +- ColumnarExchange (36)
               +- VeloxResizeBatches (35)
                  +- ^ ProjectExecTransformer (33)
                     +- ^ FlushableHashAggregateExecTransformer (32)
                        +- ^ ProjectExecTransformer (31)
                           +- ^ FilterExecTransformer (30)
                              +- ^ FileSourceScanExecTransformer parquet spark_catalog.default.lineitem (29)


(29) FileSourceScanExecTransformer parquet spark_catalog.default.lineitem
Output [4]: [l_suppkey#19, l_extendedprice#20, l_discount#21, l_shipdate#22]
Batched: true
Location: InMemoryFileIndex [{warehouse_dir}/lineitem]
PushedFilters: [IsNotNull(l_shipdate), GreaterThanOrEqual(l_shipdate,1996-01-01), LessThan(l_shipdate,1996-04-01)]
ReadSchema: struct<l_suppkey:bigint,l_extendedprice:decimal(10,0),l_discount:decimal(10,0),l_shipdate:date>

(30) FilterExecTransformer
Input [4]: [l_suppkey#19, l_extendedprice#20, l_discount#21, l_shipdate#22]
Arguments: ((isnotnull(l_shipdate#22) AND (l_shipdate#22 >= 1996-01-01)) AND (l_shipdate#22 < 1996-04-01))

(31) ProjectExecTransformer
Output [2]: [l_suppkey#19, (l_extendedprice#20 * (1 - l_discount#21)) AS _pre_2#23]
Input [4]: [l_suppkey#19, l_extendedprice#20, l_discount#21, l_shipdate#22]

(32) FlushableHashAggregateExecTransformer
Input [2]: [l_suppkey#19, _pre_2#23]
Keys [1]: [l_suppkey#19]
Functions [1]: [partial_sum(_pre_2#23)]
Aggregate Attributes [2]: [sum#24, isEmpty#25]
Results [3]: [l_suppkey#19, sum#26, isEmpty#27]

(33) ProjectExecTransformer
Output [4]: [hash(l_suppkey#19, 42) AS hash_partition_key#28, l_suppkey#19, sum#26, isEmpty#27]
Input [3]: [l_suppkey#19, sum#26, isEmpty#27]

(34) WholeStageCodegenTransformer (1)
Input [4]: [hash_partition_key#28, l_suppkey#19, sum#26, isEmpty#27]
Arguments: false

(35) VeloxResizeBatches
Input [4]: [hash_partition_key#28, l_suppkey#19, sum#26, isEmpty#27]
Arguments: 1024, 2147483647, 10485760

(36) ColumnarExchange
Input [4]: [hash_partition_key#28, l_suppkey#19, sum#26, isEmpty#27]
Arguments: hashpartitioning(l_suppkey#19, 1), ENSURE_REQUIREMENTS, [l_suppkey#19, sum#26, isEmpty#27], [plan_id=5], [shuffle_writer_type=hash]

(37) InputAdapter
Input [3]: [l_suppkey#19, sum#26, isEmpty#27]

(38) InputIteratorTransformer
Input [3]: [l_suppkey#19, sum#26, isEmpty#27]

(39) RegularHashAggregateExecTransformer
Input [3]: [l_suppkey#19, sum#26, isEmpty#27]
Keys [1]: [l_suppkey#19]
Functions [1]: [sum((l_extendedprice#20 * (1 - l_discount#21)))]
Aggregate Attributes [1]: [sum((l_extendedprice#20 * (1 - l_discount#21)))#15]
Results [2]: [l_suppkey#19, sum((l_extendedprice#20 * (1 - l_discount#21)))#15]

(40) ProjectExecTransformer
Output [1]: [sum((l_extendedprice#20 * (1 - l_discount#21)))#15 AS total_revenue#29]
Input [2]: [l_suppkey#19, sum((l_extendedprice#20 * (1 - l_discount#21)))#15]

(41) RegularHashAggregateExecTransformer
Input [1]: [total_revenue#29]
Keys: []
Functions [1]: [max(total_revenue#29)]
Aggregate Attributes [1]: [max(total_revenue#29)#30]
Results [1]: [max(total_revenue#29)#30 AS max(total_revenue)#31]

(42) WholeStageCodegenTransformer (2)
Input [1]: [max(total_revenue)#31]
Arguments: false

(43) VeloxColumnarToRow
Input [1]: [max(total_revenue)#31]


