== Physical Plan ==
AdaptiveSparkPlan (62)
+- == Final Plan ==
   VeloxColumnarToRow (39)
   +- ^ ProjectExecTransformer (37)
      +- ^ RegularHashAggregateExecTransformer (36)
         +- ^ ProjectExecTransformer (35)
            +- ^ ShuffledHashJoinExecTransformer Inner BuildRight (34)
               :- ^ ProjectExecTransformer (20)
               :  +- ^ ShuffledHashJoinExecTransformer Inner BuildRight (19)
               :     :- ^ InputIteratorTransformer (9)
               :     :  +- ShuffleQueryStage (7), Statistics(X)
               :     :     +- ColumnarExchange (6)
               :     :        +- VeloxResizeBatches (5)
               :     :           +- ^ ProjectExecTransformer (3)
               :     :              +- ^ FilterExecTransformer (2)
               :     :                 +- ^ ScanTransformer parquet  (1)
               :     +- ^ InputIteratorTransformer (18)
               :        +- ShuffleQueryStage (16), Statistics(X)
               :           +- ColumnarExchange (15)
               :              +- VeloxResizeBatches (14)
               :                 +- ^ ProjectExecTransformer (12)
               :                    +- ^ FilterExecTransformer (11)
               :                       +- ^ ScanTransformer parquet  (10)
               +- ^ FilterExecTransformer (33)
                  +- ^ ProjectExecTransformer (32)
                     +- ^ RegularHashAggregateExecTransformer (31)
                        +- ^ InputIteratorTransformer (30)
                           +- ShuffleQueryStage (28), Statistics(X)
                              +- ColumnarExchange (27)
                                 +- VeloxResizeBatches (26)
                                    +- ^ ProjectExecTransformer (24)
                                       +- ^ FlushableHashAggregateExecTransformer (23)
                                          +- ^ FilterExecTransformer (22)
                                             +- ^ ScanTransformer parquet  (21)
+- == Initial Plan ==
   HashAggregate (61)
   +- HashAggregate (60)
      +- Project (59)
         +- SortMergeJoin Inner (58)
            :- Project (50)
            :  +- SortMergeJoin Inner (49)
            :     :- Sort (43)
            :     :  +- Exchange (42)
            :     :     +- Filter (41)
            :     :        +- Scan parquet (40)
            :     +- Sort (48)
            :        +- Exchange (47)
            :           +- Project (46)
            :              +- Filter (45)
            :                 +- Scan parquet (44)
            +- Sort (57)
               +- Filter (56)
                  +- HashAggregate (55)
                     +- Exchange (54)
                        +- HashAggregate (53)
                           +- Filter (52)
                              +- Scan parquet (51)


(1) ScanTransformer parquet 
Output [3]: [l_partkey#X, l_quantity#X, l_extendedprice#X]
Batched: true
Location: InMemoryFileIndex [*]
PushedFilters: [IsNotNull(l_partkey), IsNotNull(l_quantity)]
ReadSchema: struct<l_partkey:bigint,l_quantity:decimal(12,2),l_extendedprice:decimal(12,2)>

(2) FilterExecTransformer
Input [3]: [l_partkey#X, l_quantity#X, l_extendedprice#X]
Arguments: (isnotnull(l_partkey#X) AND isnotnull(l_quantity#X))

(3) ProjectExecTransformer
Output [4]: [hash(l_partkey#X, 42) AS hash_partition_key#X, l_partkey#X, l_quantity#X, l_extendedprice#X]
Input [3]: [l_partkey#X, l_quantity#X, l_extendedprice#X]

(4) WholeStageCodegenTransformer (X)
Input [4]: [hash_partition_key#X, l_partkey#X, l_quantity#X, l_extendedprice#X]
Arguments: false

(5) VeloxResizeBatches
Input [4]: [hash_partition_key#X, l_partkey#X, l_quantity#X, l_extendedprice#X]
Arguments: X, X

(6) ColumnarExchange
Input [4]: [hash_partition_key#X, l_partkey#X, l_quantity#X, l_extendedprice#X]
Arguments: hashpartitioning(l_partkey#X, 1), ENSURE_REQUIREMENTS, [l_partkey#X, l_quantity#X, l_extendedprice#X], [plan_id=X], [shuffle_writer_type=hash]

(7) ShuffleQueryStage
Output [3]: [l_partkey#X, l_quantity#X, l_extendedprice#X]
Arguments: X

(8) InputAdapter
Input [3]: [l_partkey#X, l_quantity#X, l_extendedprice#X]

(9) InputIteratorTransformer
Input [3]: [l_partkey#X, l_quantity#X, l_extendedprice#X]

(10) ScanTransformer parquet 
Output [3]: [p_partkey#X, p_brand#X, p_container#X]
Batched: true
Location: InMemoryFileIndex [*]
PushedFilters: [IsNotNull(p_brand), IsNotNull(p_container), EqualTo(p_brand,Brand#X), EqualTo(p_container,MED BOX), IsNotNull(p_partkey)]
ReadSchema: struct<p_partkey:bigint,p_brand:string,p_container:string>

(11) FilterExecTransformer
Input [3]: [p_partkey#X, p_brand#X, p_container#X]
Arguments: ((((isnotnull(p_brand#X) AND isnotnull(p_container#X)) AND (p_brand#X = Brand#X)) AND (p_container#X = MED BOX)) AND isnotnull(p_partkey#X))

(12) ProjectExecTransformer
Output [2]: [hash(p_partkey#X, 42) AS hash_partition_key#X, p_partkey#X]
Input [3]: [p_partkey#X, p_brand#X, p_container#X]

(13) WholeStageCodegenTransformer (X)
Input [2]: [hash_partition_key#X, p_partkey#X]
Arguments: false

(14) VeloxResizeBatches
Input [2]: [hash_partition_key#X, p_partkey#X]
Arguments: X, X

(15) ColumnarExchange
Input [2]: [hash_partition_key#X, p_partkey#X]
Arguments: hashpartitioning(p_partkey#X, 1), ENSURE_REQUIREMENTS, [p_partkey#X], [plan_id=X], [shuffle_writer_type=hash]

(16) ShuffleQueryStage
Output [1]: [p_partkey#X]
Arguments: X

(17) InputAdapter
Input [1]: [p_partkey#X]

(18) InputIteratorTransformer
Input [1]: [p_partkey#X]

(19) ShuffledHashJoinExecTransformer
Left keys [1]: [l_partkey#X]
Right keys [1]: [p_partkey#X]
Join type: Inner
Join condition: None

(20) ProjectExecTransformer
Output [3]: [l_quantity#X, l_extendedprice#X, p_partkey#X]
Input [4]: [l_partkey#X, l_quantity#X, l_extendedprice#X, p_partkey#X]

(21) ScanTransformer parquet 
Output [2]: [l_partkey#X, l_quantity#X]
Batched: true
Location: InMemoryFileIndex [*]
PushedFilters: [IsNotNull(l_partkey)]
ReadSchema: struct<l_partkey:bigint,l_quantity:decimal(12,2)>

(22) FilterExecTransformer
Input [2]: [l_partkey#X, l_quantity#X]
Arguments: isnotnull(l_partkey#X)

(23) FlushableHashAggregateExecTransformer
Input [2]: [l_partkey#X, l_quantity#X]
Keys [1]: [l_partkey#X]
Functions [1]: [partial_avg(l_quantity#X)]
Aggregate Attributes [2]: [sum#X, count#X]
Results [3]: [l_partkey#X, sum#X, count#X]

(24) ProjectExecTransformer
Output [4]: [hash(l_partkey#X, 42) AS hash_partition_key#X, l_partkey#X, sum#X, count#X]
Input [3]: [l_partkey#X, sum#X, count#X]

(25) WholeStageCodegenTransformer (X)
Input [4]: [hash_partition_key#X, l_partkey#X, sum#X, count#X]
Arguments: false

(26) VeloxResizeBatches
Input [4]: [hash_partition_key#X, l_partkey#X, sum#X, count#X]
Arguments: X, X

(27) ColumnarExchange
Input [4]: [hash_partition_key#X, l_partkey#X, sum#X, count#X]
Arguments: hashpartitioning(l_partkey#X, 1), ENSURE_REQUIREMENTS, [l_partkey#X, sum#X, count#X], [plan_id=X], [shuffle_writer_type=hash]

(28) ShuffleQueryStage
Output [3]: [l_partkey#X, sum#X, count#X]
Arguments: X

(29) InputAdapter
Input [3]: [l_partkey#X, sum#X, count#X]

(30) InputIteratorTransformer
Input [3]: [l_partkey#X, sum#X, count#X]

(31) RegularHashAggregateExecTransformer
Input [3]: [l_partkey#X, sum#X, count#X]
Keys [1]: [l_partkey#X]
Functions [1]: [avg(l_quantity#X)]
Aggregate Attributes [1]: [avg(l_quantity#X)#X]
Results [2]: [l_partkey#X, avg(l_quantity#X)#X]

(32) ProjectExecTransformer
Output [2]: [(0.2 * avg(l_quantity#X)#X) AS (0.2 * avg(l_quantity))#X, l_partkey#X]
Input [2]: [l_partkey#X, avg(l_quantity#X)#X]

(33) FilterExecTransformer
Input [2]: [(0.2 * avg(l_quantity))#X, l_partkey#X]
Arguments: isnotnull((0.2 * avg(l_quantity))#X)

(34) ShuffledHashJoinExecTransformer
Left keys [1]: [p_partkey#X]
Right keys [1]: [l_partkey#X]
Join type: Inner
Join condition: (cast(l_quantity#X as decimal(18,7)) < (0.2 * avg(l_quantity))#X)

(35) ProjectExecTransformer
Output [1]: [l_extendedprice#X]
Input [5]: [l_quantity#X, l_extendedprice#X, p_partkey#X, (0.2 * avg(l_quantity))#X, l_partkey#X]

(36) RegularHashAggregateExecTransformer
Input [1]: [l_extendedprice#X]
Keys: []
Functions [1]: [sum(l_extendedprice#X)]
Aggregate Attributes [1]: [sum(l_extendedprice#X)#X]
Results [1]: [sum(l_extendedprice#X)#X]

(37) ProjectExecTransformer
Output [1]: [(sum(l_extendedprice#X)#X / 7.0) AS avg_yearly#X]
Input [1]: [sum(l_extendedprice#X)#X]

(38) WholeStageCodegenTransformer (X)
Input [1]: [avg_yearly#X]
Arguments: false

(39) VeloxColumnarToRow
Input [1]: [avg_yearly#X]

(40) Scan parquet
Output [3]: [l_partkey#X, l_quantity#X, l_extendedprice#X]
Batched: true
Location: InMemoryFileIndex [*]
PushedFilters: [IsNotNull(l_partkey), IsNotNull(l_quantity)]
ReadSchema: struct<l_partkey:bigint,l_quantity:decimal(12,2),l_extendedprice:decimal(12,2)>

(41) Filter
Input [3]: [l_partkey#X, l_quantity#X, l_extendedprice#X]
Condition : (isnotnull(l_partkey#X) AND isnotnull(l_quantity#X))

(42) Exchange
Input [3]: [l_partkey#X, l_quantity#X, l_extendedprice#X]
Arguments: hashpartitioning(l_partkey#X, 1), ENSURE_REQUIREMENTS, [plan_id=X]

(43) Sort
Input [3]: [l_partkey#X, l_quantity#X, l_extendedprice#X]
Arguments: [l_partkey#X ASC NULLS FIRST], false, 0

(44) Scan parquet
Output [3]: [p_partkey#X, p_brand#X, p_container#X]
Batched: true
Location: InMemoryFileIndex [*]
PushedFilters: [IsNotNull(p_brand), IsNotNull(p_container), EqualTo(p_brand,Brand#X), EqualTo(p_container,MED BOX), IsNotNull(p_partkey)]
ReadSchema: struct<p_partkey:bigint,p_brand:string,p_container:string>

(45) Filter
Input [3]: [p_partkey#X, p_brand#X, p_container#X]
Condition : ((((isnotnull(p_brand#X) AND isnotnull(p_container#X)) AND (p_brand#X = Brand#X)) AND (p_container#X = MED BOX)) AND isnotnull(p_partkey#X))

(46) Project
Output [1]: [p_partkey#X]
Input [3]: [p_partkey#X, p_brand#X, p_container#X]

(47) Exchange
Input [1]: [p_partkey#X]
Arguments: hashpartitioning(p_partkey#X, 1), ENSURE_REQUIREMENTS, [plan_id=X]

(48) Sort
Input [1]: [p_partkey#X]
Arguments: [p_partkey#X ASC NULLS FIRST], false, 0

(49) SortMergeJoin
Left keys [1]: [l_partkey#X]
Right keys [1]: [p_partkey#X]
Join type: Inner
Join condition: None

(50) Project
Output [3]: [l_quantity#X, l_extendedprice#X, p_partkey#X]
Input [4]: [l_partkey#X, l_quantity#X, l_extendedprice#X, p_partkey#X]

(51) Scan parquet
Output [2]: [l_partkey#X, l_quantity#X]
Batched: true
Location: InMemoryFileIndex [*]
PushedFilters: [IsNotNull(l_partkey)]
ReadSchema: struct<l_partkey:bigint,l_quantity:decimal(12,2)>

(52) Filter
Input [2]: [l_partkey#X, l_quantity#X]
Condition : isnotnull(l_partkey#X)

(53) HashAggregate
Input [2]: [l_partkey#X, l_quantity#X]
Keys [1]: [l_partkey#X]
Functions [1]: [partial_avg(l_quantity#X)]
Aggregate Attributes [2]: [sum#X, count#X]
Results [3]: [l_partkey#X, sum#X, count#X]

(54) Exchange
Input [3]: [l_partkey#X, sum#X, count#X]
Arguments: hashpartitioning(l_partkey#X, 1), ENSURE_REQUIREMENTS, [plan_id=X]

(55) HashAggregate
Input [3]: [l_partkey#X, sum#X, count#X]
Keys [1]: [l_partkey#X]
Functions [1]: [avg(l_quantity#X)]
Aggregate Attributes [1]: [avg(l_quantity#X)#X]
Results [2]: [(0.2 * avg(l_quantity#X)#X) AS (0.2 * avg(l_quantity))#X, l_partkey#X]

(56) Filter
Input [2]: [(0.2 * avg(l_quantity))#X, l_partkey#X]
Condition : isnotnull((0.2 * avg(l_quantity))#X)

(57) Sort
Input [2]: [(0.2 * avg(l_quantity))#X, l_partkey#X]
Arguments: [l_partkey#X ASC NULLS FIRST], false, 0

(58) SortMergeJoin
Left keys [1]: [p_partkey#X]
Right keys [1]: [l_partkey#X]
Join type: Inner
Join condition: (cast(l_quantity#X as decimal(18,7)) < (0.2 * avg(l_quantity))#X)

(59) Project
Output [1]: [l_extendedprice#X]
Input [5]: [l_quantity#X, l_extendedprice#X, p_partkey#X, (0.2 * avg(l_quantity))#X, l_partkey#X]

(60) HashAggregate
Input [1]: [l_extendedprice#X]
Keys: []
Functions [1]: [partial_sum(l_extendedprice#X)]
Aggregate Attributes [2]: [sum#X, isEmpty#X]
Results [2]: [sum#X, isEmpty#X]

(61) HashAggregate
Input [2]: [sum#X, isEmpty#X]
Keys: []
Functions [1]: [sum(l_extendedprice#X)]
Aggregate Attributes [1]: [sum(l_extendedprice#X)#X]
Results [1]: [(sum(l_extendedprice#X)#X / 7.0) AS avg_yearly#X]

(62) AdaptiveSparkPlan
Output [1]: [avg_yearly#X]
Arguments: isFinalPlan=true