== Physical Plan ==
AdaptiveSparkPlan (39)
+- == Final Plan ==
   VeloxColumnarToRowExec (25)
   +- ^ ProjectExecTransformer (23)
      +- ^ RegularHashAggregateExecTransformer (22)
         +- ^ RegularHashAggregateExecTransformer (21)
            +- ^ ProjectExecTransformer (20)
               +- ^ ShuffledHashJoinExecTransformer Inner BuildLeft (19)
                  :- ^ InputIteratorTransformer (9)
                  :  +- ShuffleQueryStage (7), Statistics(X)
                  :     +- ColumnarExchange (6)
                  :        +- VeloxAppendBatches (5)
                  :           +- ^ ProjectExecTransformer (3)
                  :              +- ^ NoopFilter (2)
                  :                 +- ^ Scan parquet (1)
                  +- ^ InputIteratorTransformer (18)
                     +- ShuffleQueryStage (16), Statistics(X)
                        +- ColumnarExchange (15)
                           +- VeloxAppendBatches (14)
                              +- ^ ProjectExecTransformer (12)
                                 +- ^ NoopFilter (11)
                                    +- ^ Scan parquet (10)
+- == Initial Plan ==
   HashAggregate (38)
   +- HashAggregate (37)
      +- Project (36)
         +- SortMergeJoin Inner (35)
            :- Sort (30)
            :  +- Exchange (29)
            :     +- Project (28)
            :        +- Filter (27)
            :           +- Scan parquet (26)
            +- Sort (34)
               +- Exchange (33)
                  +- Filter (32)
                     +- Scan parquet (31)


(1) Scan parquet
Output [4]: [l_partkey#X, l_extendedprice#X, l_discount#X, l_shipdate#X]
Batched: true
Location: InMemoryFileIndex [*]
PushedFilters: [IsNotNull(l_shipdate), GreaterThanOrEqual(l_shipdate,1995-09-01), LessThan(l_shipdate,1995-10-01), IsNotNull(l_partkey)]
ReadSchema: struct<l_partkey:bigint,l_extendedprice:decimal(12,2),l_discount:decimal(12,2),l_shipdate:date>

(2) NoopFilter
Input [4]: [l_partkey#X, l_extendedprice#X, l_discount#X, l_shipdate#X]
Arguments: [l_partkey#X, l_extendedprice#X, l_discount#X, l_shipdate#X]

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

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

(5) VeloxAppendBatches
Input [4]: [hash_partition_key#X, l_partkey#X, l_extendedprice#X, l_discount#X]
Arguments: X

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

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

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

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

(10) Scan parquet
Output [2]: [p_partkey#X, p_type#X]
Batched: true
Location: InMemoryFileIndex [*]
PushedFilters: [IsNotNull(p_partkey)]
ReadSchema: struct<p_partkey:bigint,p_type:string>

(11) NoopFilter
Input [2]: [p_partkey#X, p_type#X]
Arguments: [p_partkey#X, p_type#X]

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

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

(14) VeloxAppendBatches
Input [3]: [hash_partition_key#X, p_partkey#X, p_type#X]
Arguments: X

(15) ColumnarExchange
Input [3]: [hash_partition_key#X, p_partkey#X, p_type#X]
Arguments: hashpartitioning(p_partkey#X, 1), ENSURE_REQUIREMENTS, [p_partkey#X, p_type#X], [plan_id=X], [id=#X]

(16) ShuffleQueryStage
Output [2]: [p_partkey#X, p_type#X]
Arguments: X

(17) InputAdapter
Input [2]: [p_partkey#X, p_type#X]

(18) InputIteratorTransformer
Input [2]: [p_partkey#X, p_type#X]

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

(20) ProjectExecTransformer
Output [5]: [l_extendedprice#X, l_discount#X, p_type#X, CASE WHEN StartsWith(p_type#X, PROMO) THEN CheckOverflow((promote_precision(cast(l_extendedprice#X as decimal(13,2))) * promote_precision(CheckOverflow((1.00 - promote_precision(cast(l_discount#X as decimal(13,2)))), DecimalType(13,2)))), DecimalType(26,4)) ELSE 0.0000 END AS _pre_X#X, CheckOverflow((promote_precision(cast(l_extendedprice#X as decimal(13,2))) * promote_precision(CheckOverflow((1.00 - promote_precision(cast(l_discount#X as decimal(13,2)))), DecimalType(13,2)))), DecimalType(26,4)) AS _pre_X#X]
Input [5]: [l_partkey#X, l_extendedprice#X, l_discount#X, p_partkey#X, p_type#X]

(21) RegularHashAggregateExecTransformer
Input [5]: [l_extendedprice#X, l_discount#X, p_type#X, _pre_X#X, _pre_X#X]
Keys: []
Functions [2]: [partial_sum(_pre_X#X), partial_sum(_pre_X#X)]
Aggregate Attributes [4]: [sum#X, isEmpty#X, sum#X, isEmpty#X]
Results [4]: [sum#X, isEmpty#X, sum#X, isEmpty#X]

(22) RegularHashAggregateExecTransformer
Input [4]: [sum#X, isEmpty#X, sum#X, isEmpty#X]
Keys: []
Functions [2]: [sum(CASE WHEN StartsWith(p_type#X, PROMO) THEN CheckOverflow((promote_precision(cast(l_extendedprice#X as decimal(13,2))) * promote_precision(CheckOverflow((1.00 - promote_precision(cast(l_discount#X as decimal(13,2)))), DecimalType(13,2)))), DecimalType(26,4)) ELSE 0.0000 END), sum(CheckOverflow((promote_precision(cast(l_extendedprice#X as decimal(13,2))) * promote_precision(CheckOverflow((1.00 - promote_precision(cast(l_discount#X as decimal(13,2)))), DecimalType(13,2)))), DecimalType(26,4)))]
Aggregate Attributes [2]: [sum(CASE WHEN StartsWith(p_type#X, PROMO) THEN CheckOverflow((promote_precision(cast(l_extendedprice#X as decimal(13,2))) * promote_precision(CheckOverflow((1.00 - promote_precision(cast(l_discount#X as decimal(13,2)))), DecimalType(13,2)))), DecimalType(26,4)) ELSE 0.0000 END)#X, sum(CheckOverflow((promote_precision(cast(l_extendedprice#X as decimal(13,2))) * promote_precision(CheckOverflow((1.00 - promote_precision(cast(l_discount#X as decimal(13,2)))), DecimalType(13,2)))), DecimalType(26,4)))#X]
Results [2]: [sum(CASE WHEN StartsWith(p_type#X, PROMO) THEN CheckOverflow((promote_precision(cast(l_extendedprice#X as decimal(13,2))) * promote_precision(CheckOverflow((1.00 - promote_precision(cast(l_discount#X as decimal(13,2)))), DecimalType(13,2)))), DecimalType(26,4)) ELSE 0.0000 END)#X, sum(CheckOverflow((promote_precision(cast(l_extendedprice#X as decimal(13,2))) * promote_precision(CheckOverflow((1.00 - promote_precision(cast(l_discount#X as decimal(13,2)))), DecimalType(13,2)))), DecimalType(26,4)))#X]

(23) ProjectExecTransformer
Output [1]: [CheckOverflow((promote_precision(CheckOverflow((100.0000 * promote_precision(sum(CASE WHEN StartsWith(p_type#X, PROMO) THEN CheckOverflow((promote_precision(cast(l_extendedprice#X as decimal(13,2))) * promote_precision(CheckOverflow((1.00 - promote_precision(cast(l_discount#X as decimal(13,2)))), DecimalType(13,2)))), DecimalType(26,4)) ELSE 0.0000 END)#X)), DecimalType(38,6))) / promote_precision(cast(sum(CheckOverflow((promote_precision(cast(l_extendedprice#X as decimal(13,2))) * promote_precision(CheckOverflow((1.00 - promote_precision(cast(l_discount#X as decimal(13,2)))), DecimalType(13,2)))), DecimalType(26,4)))#X as decimal(38,6)))), DecimalType(38,6)) AS promo_revenue#X]
Input [2]: [sum(CASE WHEN StartsWith(p_type#X, PROMO) THEN CheckOverflow((promote_precision(cast(l_extendedprice#X as decimal(13,2))) * promote_precision(CheckOverflow((1.00 - promote_precision(cast(l_discount#X as decimal(13,2)))), DecimalType(13,2)))), DecimalType(26,4)) ELSE 0.0000 END)#X, sum(CheckOverflow((promote_precision(cast(l_extendedprice#X as decimal(13,2))) * promote_precision(CheckOverflow((1.00 - promote_precision(cast(l_discount#X as decimal(13,2)))), DecimalType(13,2)))), DecimalType(26,4)))#X]

(24) WholeStageCodegenTransformer (X)
Input [1]: [promo_revenue#X]
Arguments: false

(25) VeloxColumnarToRowExec
Input [1]: [promo_revenue#X]

(26) Scan parquet
Output [4]: [l_partkey#X, l_extendedprice#X, l_discount#X, l_shipdate#X]
Batched: true
Location: InMemoryFileIndex [*]
PushedFilters: [IsNotNull(l_shipdate), GreaterThanOrEqual(l_shipdate,1995-09-01), LessThan(l_shipdate,1995-10-01), IsNotNull(l_partkey)]
ReadSchema: struct<l_partkey:bigint,l_extendedprice:decimal(12,2),l_discount:decimal(12,2),l_shipdate:date>

(27) Filter
Input [4]: [l_partkey#X, l_extendedprice#X, l_discount#X, l_shipdate#X]
Condition : (((isnotnull(l_shipdate#X) AND (l_shipdate#X >= 1995-09-01)) AND (l_shipdate#X < 1995-10-01)) AND isnotnull(l_partkey#X))

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

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

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

(31) Scan parquet
Output [2]: [p_partkey#X, p_type#X]
Batched: true
Location: InMemoryFileIndex [*]
PushedFilters: [IsNotNull(p_partkey)]
ReadSchema: struct<p_partkey:bigint,p_type:string>

(32) Filter
Input [2]: [p_partkey#X, p_type#X]
Condition : isnotnull(p_partkey#X)

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

(34) Sort
Input [2]: [p_partkey#X, p_type#X]
Arguments: [p_partkey#X ASC NULLS FIRST], false, 0

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

(36) Project
Output [3]: [l_extendedprice#X, l_discount#X, p_type#X]
Input [5]: [l_partkey#X, l_extendedprice#X, l_discount#X, p_partkey#X, p_type#X]

(37) HashAggregate
Input [3]: [l_extendedprice#X, l_discount#X, p_type#X]
Keys: []
Functions [2]: [partial_sum(CASE WHEN StartsWith(p_type#X, PROMO) THEN CheckOverflow((promote_precision(cast(l_extendedprice#X as decimal(13,2))) * promote_precision(CheckOverflow((1.00 - promote_precision(cast(l_discount#X as decimal(13,2)))), DecimalType(13,2)))), DecimalType(26,4)) ELSE 0.0000 END), partial_sum(CheckOverflow((promote_precision(cast(l_extendedprice#X as decimal(13,2))) * promote_precision(CheckOverflow((1.00 - promote_precision(cast(l_discount#X as decimal(13,2)))), DecimalType(13,2)))), DecimalType(26,4)))]
Aggregate Attributes [4]: [sum#X, isEmpty#X, sum#X, isEmpty#X]
Results [4]: [sum#X, isEmpty#X, sum#X, isEmpty#X]

(38) HashAggregate
Input [4]: [sum#X, isEmpty#X, sum#X, isEmpty#X]
Keys: []
Functions [2]: [sum(CASE WHEN StartsWith(p_type#X, PROMO) THEN CheckOverflow((promote_precision(cast(l_extendedprice#X as decimal(13,2))) * promote_precision(CheckOverflow((1.00 - promote_precision(cast(l_discount#X as decimal(13,2)))), DecimalType(13,2)))), DecimalType(26,4)) ELSE 0.0000 END), sum(CheckOverflow((promote_precision(cast(l_extendedprice#X as decimal(13,2))) * promote_precision(CheckOverflow((1.00 - promote_precision(cast(l_discount#X as decimal(13,2)))), DecimalType(13,2)))), DecimalType(26,4)))]
Aggregate Attributes [2]: [sum(CASE WHEN StartsWith(p_type#X, PROMO) THEN CheckOverflow((promote_precision(cast(l_extendedprice#X as decimal(13,2))) * promote_precision(CheckOverflow((1.00 - promote_precision(cast(l_discount#X as decimal(13,2)))), DecimalType(13,2)))), DecimalType(26,4)) ELSE 0.0000 END)#X, sum(CheckOverflow((promote_precision(cast(l_extendedprice#X as decimal(13,2))) * promote_precision(CheckOverflow((1.00 - promote_precision(cast(l_discount#X as decimal(13,2)))), DecimalType(13,2)))), DecimalType(26,4)))#X]
Results [1]: [CheckOverflow((promote_precision(CheckOverflow((100.0000 * promote_precision(sum(CASE WHEN StartsWith(p_type#X, PROMO) THEN CheckOverflow((promote_precision(cast(l_extendedprice#X as decimal(13,2))) * promote_precision(CheckOverflow((1.00 - promote_precision(cast(l_discount#X as decimal(13,2)))), DecimalType(13,2)))), DecimalType(26,4)) ELSE 0.0000 END)#X)), DecimalType(38,6))) / promote_precision(cast(sum(CheckOverflow((promote_precision(cast(l_extendedprice#X as decimal(13,2))) * promote_precision(CheckOverflow((1.00 - promote_precision(cast(l_discount#X as decimal(13,2)))), DecimalType(13,2)))), DecimalType(26,4)))#X as decimal(38,6)))), DecimalType(38,6)) AS promo_revenue#X]

(39) AdaptiveSparkPlan
Output [1]: [promo_revenue#X]
Arguments: isFinalPlan=true