== Physical Plan ==
AdaptiveSparkPlan (43)
+- == Final Plan ==
   VeloxColumnarToRow (28)
   +- AQEShuffleRead (27)
      +- ShuffleQueryStage (26), Statistics(X)
         +- ColumnarExchange (25)
            +- VeloxResizeBatches (24)
               +- ^ ProjectExecTransformer (22)
                  +- ^ BroadcastHashJoinExecTransformer Inner BuildLeft (21)
                     :- ^ InputIteratorTransformer (7)
                     :  +- BroadcastQueryStage (5), Statistics(X)
                     :     +- ColumnarBroadcastExchange (4)
                     :        +- ^ FilterExecTransformer (2)
                     :           +- ^ ScanTransformer parquet  (1)
                     +- ^ FilterExecTransformer (20)
                        +- ^ RegularHashAggregateExecTransformer (19)
                           +- ^ InputIteratorTransformer (18)
                              +- ShuffleQueryStage (16), Statistics(X)
                                 +- ColumnarExchange (15)
                                    +- VeloxResizeBatches (14)
                                       +- ^ ProjectExecTransformer (12)
                                          +- ^ FlushableHashAggregateExecTransformer (11)
                                             +- ^ ProjectExecTransformer (10)
                                                +- ^ FilterExecTransformer (9)
                                                   +- ^ ScanTransformer parquet  (8)
+- == Initial Plan ==
   Sort (42)
   +- Exchange (41)
      +- Project (40)
         +- BroadcastHashJoin Inner BuildLeft (39)
            :- BroadcastExchange (31)
            :  +- Filter (30)
            :     +- Scan parquet (29)
            +- Filter (38)
               +- HashAggregate (37)
                  +- Exchange (36)
                     +- HashAggregate (35)
                        +- Project (34)
                           +- Filter (33)
                              +- Scan parquet (32)


(1) ScanTransformer parquet 
Output [4]: [s_suppkey#X, s_name#X, s_address#X, s_phone#X]
Batched: true
Location: InMemoryFileIndex [*]
PushedFilters: [IsNotNull(s_suppkey)]
ReadSchema: struct<s_suppkey:bigint,s_name:string,s_address:string,s_phone:string>

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

(3) WholeStageCodegenTransformer (X)
Input [4]: [s_suppkey#X, s_name#X, s_address#X, s_phone#X]
Arguments: false

(4) ColumnarBroadcastExchange
Input [4]: [s_suppkey#X, s_name#X, s_address#X, s_phone#X]
Arguments: HashedRelationBroadcastMode(List(input[0, bigint, false]),false), [plan_id=X]

(5) BroadcastQueryStage
Output [4]: [s_suppkey#X, s_name#X, s_address#X, s_phone#X]
Arguments: X

(6) InputAdapter
Input [4]: [s_suppkey#X, s_name#X, s_address#X, s_phone#X]

(7) InputIteratorTransformer
Input [4]: [s_suppkey#X, s_name#X, s_address#X, s_phone#X]

(8) ScanTransformer parquet 
Output [4]: [l_suppkey#X, l_extendedprice#X, l_discount#X, l_shipdate#X]
Batched: true
Location: InMemoryFileIndex [*]
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(12,2),l_discount:decimal(12,2),l_shipdate:date>

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

(10) ProjectExecTransformer
Output [2]: [l_suppkey#X, (l_extendedprice#X * (1 - l_discount#X)) AS _pre_X#X]
Input [4]: [l_suppkey#X, l_extendedprice#X, l_discount#X, l_shipdate#X]

(11) FlushableHashAggregateExecTransformer
Input [2]: [l_suppkey#X, _pre_X#X]
Keys [1]: [l_suppkey#X]
Functions [1]: [partial_sum(_pre_X#X)]
Aggregate Attributes [2]: [sum#X, isEmpty#X]
Results [3]: [l_suppkey#X, sum#X, isEmpty#X]

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

(13) WholeStageCodegenTransformer (X)
Input [4]: [hash_partition_key#X, l_suppkey#X, sum#X, isEmpty#X]
Arguments: false

(14) VeloxResizeBatches
Input [4]: [hash_partition_key#X, l_suppkey#X, sum#X, isEmpty#X]
Arguments: X, X

(15) ColumnarExchange
Input [4]: [hash_partition_key#X, l_suppkey#X, sum#X, isEmpty#X]
Arguments: hashpartitioning(l_suppkey#X, 1), ENSURE_REQUIREMENTS, [l_suppkey#X, sum#X, isEmpty#X], [plan_id=X], [shuffle_writer_type=hash]

(16) ShuffleQueryStage
Output [3]: [l_suppkey#X, sum#X, isEmpty#X]
Arguments: X

(17) InputAdapter
Input [3]: [l_suppkey#X, sum#X, isEmpty#X]

(18) InputIteratorTransformer
Input [3]: [l_suppkey#X, sum#X, isEmpty#X]

(19) RegularHashAggregateExecTransformer
Input [3]: [l_suppkey#X, sum#X, isEmpty#X]
Keys [1]: [l_suppkey#X]
Functions [1]: [sum((l_extendedprice#X * (1 - l_discount#X)))]
Aggregate Attributes [1]: [sum((l_extendedprice#X * (1 - l_discount#X)))#X]
Results [2]: [l_suppkey#X AS supplier_no#X, sum((l_extendedprice#X * (1 - l_discount#X)))#X AS total_revenue#X]

(20) FilterExecTransformer
Input [2]: [supplier_no#X, total_revenue#X]
Arguments: (isnotnull(total_revenue#X) AND (total_revenue#X = Subquery subquery#X, [id=#X]))

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

(22) ProjectExecTransformer
Output [5]: [s_suppkey#X, s_name#X, s_address#X, s_phone#X, total_revenue#X]
Input [6]: [s_suppkey#X, s_name#X, s_address#X, s_phone#X, supplier_no#X, total_revenue#X]

(23) WholeStageCodegenTransformer (X)
Input [5]: [s_suppkey#X, s_name#X, s_address#X, s_phone#X, total_revenue#X]
Arguments: false

(24) VeloxResizeBatches
Input [5]: [s_suppkey#X, s_name#X, s_address#X, s_phone#X, total_revenue#X]
Arguments: X, X

(25) ColumnarExchange
Input [5]: [s_suppkey#X, s_name#X, s_address#X, s_phone#X, total_revenue#X]
Arguments: rangepartitioning(s_suppkey#X ASC NULLS FIRST, 1), ENSURE_REQUIREMENTS, [plan_id=X], [shuffle_writer_type=hash]

(26) ShuffleQueryStage
Output [5]: [s_suppkey#X, s_name#X, s_address#X, s_phone#X, total_revenue#X]
Arguments: X

(27) AQEShuffleRead
Input [5]: [s_suppkey#X, s_name#X, s_address#X, s_phone#X, total_revenue#X]
Arguments: local

(28) VeloxColumnarToRow
Input [5]: [s_suppkey#X, s_name#X, s_address#X, s_phone#X, total_revenue#X]

(29) Scan parquet
Output [4]: [s_suppkey#X, s_name#X, s_address#X, s_phone#X]
Batched: true
Location: InMemoryFileIndex [*]
PushedFilters: [IsNotNull(s_suppkey)]
ReadSchema: struct<s_suppkey:bigint,s_name:string,s_address:string,s_phone:string>

(30) Filter
Input [4]: [s_suppkey#X, s_name#X, s_address#X, s_phone#X]
Condition : isnotnull(s_suppkey#X)

(31) BroadcastExchange
Input [4]: [s_suppkey#X, s_name#X, s_address#X, s_phone#X]
Arguments: HashedRelationBroadcastMode(List(input[0, bigint, false]),false), [plan_id=X]

(32) Scan parquet
Output [4]: [l_suppkey#X, l_extendedprice#X, l_discount#X, l_shipdate#X]
Batched: true
Location: InMemoryFileIndex [*]
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(12,2),l_discount:decimal(12,2),l_shipdate:date>

(33) Filter
Input [4]: [l_suppkey#X, l_extendedprice#X, l_discount#X, l_shipdate#X]
Condition : (((isnotnull(l_shipdate#X) AND (l_shipdate#X >= 1996-01-01)) AND (l_shipdate#X < 1996-04-01)) AND isnotnull(l_suppkey#X))

(34) Project
Output [3]: [l_suppkey#X, l_extendedprice#X, l_discount#X]
Input [4]: [l_suppkey#X, l_extendedprice#X, l_discount#X, l_shipdate#X]

(35) HashAggregate
Input [3]: [l_suppkey#X, l_extendedprice#X, l_discount#X]
Keys [1]: [l_suppkey#X]
Functions [1]: [partial_sum((l_extendedprice#X * (1 - l_discount#X)))]
Aggregate Attributes [2]: [sum#X, isEmpty#X]
Results [3]: [l_suppkey#X, sum#X, isEmpty#X]

(36) Exchange
Input [3]: [l_suppkey#X, sum#X, isEmpty#X]
Arguments: hashpartitioning(l_suppkey#X, 1), ENSURE_REQUIREMENTS, [plan_id=X]

(37) HashAggregate
Input [3]: [l_suppkey#X, sum#X, isEmpty#X]
Keys [1]: [l_suppkey#X]
Functions [1]: [sum((l_extendedprice#X * (1 - l_discount#X)))]
Aggregate Attributes [1]: [sum((l_extendedprice#X * (1 - l_discount#X)))#X]
Results [2]: [l_suppkey#X AS supplier_no#X, sum((l_extendedprice#X * (1 - l_discount#X)))#X AS total_revenue#X]

(38) Filter
Input [2]: [supplier_no#X, total_revenue#X]
Condition : (isnotnull(total_revenue#X) AND (total_revenue#X = Subquery subquery#X, [id=#X]))

(39) BroadcastHashJoin
Left keys [1]: [s_suppkey#X]
Right keys [1]: [supplier_no#X]
Join type: Inner
Join condition: None

(40) Project
Output [5]: [s_suppkey#X, s_name#X, s_address#X, s_phone#X, total_revenue#X]
Input [6]: [s_suppkey#X, s_name#X, s_address#X, s_phone#X, supplier_no#X, total_revenue#X]

(41) Exchange
Input [5]: [s_suppkey#X, s_name#X, s_address#X, s_phone#X, total_revenue#X]
Arguments: rangepartitioning(s_suppkey#X ASC NULLS FIRST, 1), ENSURE_REQUIREMENTS, [plan_id=X]

(42) Sort
Input [5]: [s_suppkey#X, s_name#X, s_address#X, s_phone#X, total_revenue#X]
Arguments: [s_suppkey#X ASC NULLS FIRST], true, 0

(43) AdaptiveSparkPlan
Output [5]: [s_suppkey#X, s_name#X, s_address#X, s_phone#X, total_revenue#X]
Arguments: isFinalPlan=true

===== Subqueries =====

Subquery:1 Hosting operator id = 20 Hosting Expression = Subquery subquery#X, [id=#X]
AdaptiveSparkPlan (68)
+- == Final Plan ==
   VeloxColumnarToRow (59)
   +- ^ RegularHashAggregateExecTransformer (57)
      +- ^ ProjectExecTransformer (56)
         +- ^ RegularHashAggregateExecTransformer (55)
            +- ^ InputIteratorTransformer (54)
               +- ShuffleQueryStage (52), Statistics(X)
                  +- ColumnarExchange (51)
                     +- VeloxResizeBatches (50)
                        +- ^ ProjectExecTransformer (48)
                           +- ^ FlushableHashAggregateExecTransformer (47)
                              +- ^ ProjectExecTransformer (46)
                                 +- ^ FilterExecTransformer (45)
                                    +- ^ ScanTransformer parquet  (44)
+- == Initial Plan ==
   HashAggregate (67)
   +- HashAggregate (66)
      +- HashAggregate (65)
         +- Exchange (64)
            +- HashAggregate (63)
               +- Project (62)
                  +- Filter (61)
                     +- Scan parquet (60)


(44) ScanTransformer parquet 
Output [4]: [l_suppkey#X, l_extendedprice#X, l_discount#X, l_shipdate#X]
Batched: true
Location: InMemoryFileIndex [*]
PushedFilters: [IsNotNull(l_shipdate), GreaterThanOrEqual(l_shipdate,1996-01-01), LessThan(l_shipdate,1996-04-01)]
ReadSchema: struct<l_suppkey:bigint,l_extendedprice:decimal(12,2),l_discount:decimal(12,2),l_shipdate:date>

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

(46) ProjectExecTransformer
Output [2]: [l_suppkey#X, (l_extendedprice#X * (1 - l_discount#X)) AS _pre_X#X]
Input [4]: [l_suppkey#X, l_extendedprice#X, l_discount#X, l_shipdate#X]

(47) FlushableHashAggregateExecTransformer
Input [2]: [l_suppkey#X, _pre_X#X]
Keys [1]: [l_suppkey#X]
Functions [1]: [partial_sum(_pre_X#X)]
Aggregate Attributes [2]: [sum#X, isEmpty#X]
Results [3]: [l_suppkey#X, sum#X, isEmpty#X]

(48) ProjectExecTransformer
Output [4]: [hash(l_suppkey#X, 42) AS hash_partition_key#X, l_suppkey#X, sum#X, isEmpty#X]
Input [3]: [l_suppkey#X, sum#X, isEmpty#X]

(49) WholeStageCodegenTransformer (X)
Input [4]: [hash_partition_key#X, l_suppkey#X, sum#X, isEmpty#X]
Arguments: false

(50) VeloxResizeBatches
Input [4]: [hash_partition_key#X, l_suppkey#X, sum#X, isEmpty#X]
Arguments: X, X

(51) ColumnarExchange
Input [4]: [hash_partition_key#X, l_suppkey#X, sum#X, isEmpty#X]
Arguments: hashpartitioning(l_suppkey#X, 1), ENSURE_REQUIREMENTS, [l_suppkey#X, sum#X, isEmpty#X], [plan_id=X], [shuffle_writer_type=hash]

(52) ShuffleQueryStage
Output [3]: [l_suppkey#X, sum#X, isEmpty#X]
Arguments: X

(53) InputAdapter
Input [3]: [l_suppkey#X, sum#X, isEmpty#X]

(54) InputIteratorTransformer
Input [3]: [l_suppkey#X, sum#X, isEmpty#X]

(55) RegularHashAggregateExecTransformer
Input [3]: [l_suppkey#X, sum#X, isEmpty#X]
Keys [1]: [l_suppkey#X]
Functions [1]: [sum((l_extendedprice#X * (1 - l_discount#X)))]
Aggregate Attributes [1]: [sum((l_extendedprice#X * (1 - l_discount#X)))#X]
Results [2]: [l_suppkey#X, sum((l_extendedprice#X * (1 - l_discount#X)))#X]

(56) ProjectExecTransformer
Output [1]: [sum((l_extendedprice#X * (1 - l_discount#X)))#X AS total_revenue#X]
Input [2]: [l_suppkey#X, sum((l_extendedprice#X * (1 - l_discount#X)))#X]

(57) RegularHashAggregateExecTransformer
Input [1]: [total_revenue#X]
Keys: []
Functions [1]: [max(total_revenue#X)]
Aggregate Attributes [1]: [max(total_revenue#X)#X]
Results [1]: [max(total_revenue#X)#X AS max(total_revenue)#X]

(58) WholeStageCodegenTransformer (X)
Input [1]: [max(total_revenue)#X]
Arguments: false

(59) VeloxColumnarToRow
Input [1]: [max(total_revenue)#X]

(60) Scan parquet
Output [4]: [l_suppkey#X, l_extendedprice#X, l_discount#X, l_shipdate#X]
Batched: true
Location: InMemoryFileIndex [*]
PushedFilters: [IsNotNull(l_shipdate), GreaterThanOrEqual(l_shipdate,1996-01-01), LessThan(l_shipdate,1996-04-01)]
ReadSchema: struct<l_suppkey:bigint,l_extendedprice:decimal(12,2),l_discount:decimal(12,2),l_shipdate:date>

(61) Filter
Input [4]: [l_suppkey#X, l_extendedprice#X, l_discount#X, l_shipdate#X]
Condition : ((isnotnull(l_shipdate#X) AND (l_shipdate#X >= 1996-01-01)) AND (l_shipdate#X < 1996-04-01))

(62) Project
Output [3]: [l_suppkey#X, l_extendedprice#X, l_discount#X]
Input [4]: [l_suppkey#X, l_extendedprice#X, l_discount#X, l_shipdate#X]

(63) HashAggregate
Input [3]: [l_suppkey#X, l_extendedprice#X, l_discount#X]
Keys [1]: [l_suppkey#X]
Functions [1]: [partial_sum((l_extendedprice#X * (1 - l_discount#X)))]
Aggregate Attributes [2]: [sum#X, isEmpty#X]
Results [3]: [l_suppkey#X, sum#X, isEmpty#X]

(64) Exchange
Input [3]: [l_suppkey#X, sum#X, isEmpty#X]
Arguments: hashpartitioning(l_suppkey#X, 1), ENSURE_REQUIREMENTS, [plan_id=X]

(65) HashAggregate
Input [3]: [l_suppkey#X, sum#X, isEmpty#X]
Keys [1]: [l_suppkey#X]
Functions [1]: [sum((l_extendedprice#X * (1 - l_discount#X)))]
Aggregate Attributes [1]: [sum((l_extendedprice#X * (1 - l_discount#X)))#X]
Results [1]: [sum((l_extendedprice#X * (1 - l_discount#X)))#X AS total_revenue#X]

(66) HashAggregate
Input [1]: [total_revenue#X]
Keys: []
Functions [1]: [partial_max(total_revenue#X)]
Aggregate Attributes [1]: [max#X]
Results [1]: [max#X]

(67) HashAggregate
Input [1]: [max#X]
Keys: []
Functions [1]: [max(total_revenue#X)]
Aggregate Attributes [1]: [max(total_revenue#X)#X]
Results [1]: [max(total_revenue#X)#X AS max(total_revenue)#X]

(68) AdaptiveSparkPlan
Output [1]: [max(total_revenue)#X]
Arguments: isFinalPlan=true