== Physical Plan ==
AdaptiveSparkPlan (67)
+- == Final Plan ==
   VeloxColumnarToRowExec (43)
   +- TakeOrderedAndProjectExecTransformer (42)
      +- ^ ProjectExecTransformer (40)
         +- ^ RegularHashAggregateExecTransformer (39)
            +- ^ RegularHashAggregateExecTransformer (38)
               +- ^ ProjectExecTransformer (37)
                  +- ^ ShuffledHashJoinExecTransformer Inner BuildLeft (36)
                     :- ^ InputIteratorTransformer (26)
                     :  +- ShuffleQueryStage (24)
                     :     +- ColumnarExchange (23)
                     :        +- VeloxAppendBatches (22)
                     :           +- ^ ProjectExecTransformer (20)
                     :              +- ^ ShuffledHashJoinExecTransformer Inner BuildLeft (19)
                     :                 :- ^ InputIteratorTransformer (9)
                     :                 :  +- ShuffleQueryStage (7)
                     :                 :     +- ColumnarExchange (6)
                     :                 :        +- VeloxAppendBatches (5)
                     :                 :           +- ^ ProjectExecTransformer (3)
                     :                 :              +- ^ FilterExecTransformer (2)
                     :                 :                 +- ^ Scan parquet (1)
                     :                 +- ^ InputIteratorTransformer (18)
                     :                    +- ShuffleQueryStage (16)
                     :                       +- ColumnarExchange (15)
                     :                          +- VeloxAppendBatches (14)
                     :                             +- ^ ProjectExecTransformer (12)
                     :                                +- ^ FilterExecTransformer (11)
                     :                                   +- ^ Scan parquet (10)
                     +- ^ InputIteratorTransformer (35)
                        +- ShuffleQueryStage (33)
                           +- ColumnarExchange (32)
                              +- VeloxAppendBatches (31)
                                 +- ^ ProjectExecTransformer (29)
                                    +- ^ FilterExecTransformer (28)
                                       +- ^ Scan parquet (27)
+- == Initial Plan ==
   TakeOrderedAndProject (66)
   +- HashAggregate (65)
      +- HashAggregate (64)
         +- Project (63)
            +- SortMergeJoin Inner (62)
               :- Sort (56)
               :  +- Exchange (55)
               :     +- Project (54)
               :        +- SortMergeJoin Inner (53)
               :           :- Sort (48)
               :           :  +- Exchange (47)
               :           :     +- Project (46)
               :           :        +- Filter (45)
               :           :           +- Scan parquet (44)
               :           +- Sort (52)
               :              +- Exchange (51)
               :                 +- Filter (50)
               :                    +- Scan parquet (49)
               +- Sort (61)
                  +- Exchange (60)
                     +- Project (59)
                        +- Filter (58)
                           +- Scan parquet (57)


(1) Scan parquet
Output [2]: [c_custkey#X, c_mktsegment#X]
Batched: true
Location: InMemoryFileIndex [*]
PushedFilters: [IsNotNull(c_mktsegment), EqualTo(c_mktsegment,BUILDING), IsNotNull(c_custkey)]
ReadSchema: struct<c_custkey:bigint,c_mktsegment:string>

(2) FilterExecTransformer
Input [2]: [c_custkey#X, c_mktsegment#X]
Arguments: ((isnotnull(c_mktsegment#X) AND (c_mktsegment#X = BUILDING)) AND isnotnull(c_custkey#X))

(3) ProjectExecTransformer
Output [2]: [hash(c_custkey#X, 42) AS hash_partition_key#X, c_custkey#X]
Input [2]: [c_custkey#X, c_mktsegment#X]

(4) WholeStageCodegenTransformer (X)
Input [2]: [hash_partition_key#X, c_custkey#X]
Arguments: false

(5) VeloxAppendBatches
Input [2]: [hash_partition_key#X, c_custkey#X]
Arguments: X

(6) ColumnarExchange
Input [2]: [hash_partition_key#X, c_custkey#X]
Arguments: hashpartitioning(c_custkey#X, 1), ENSURE_REQUIREMENTS, [c_custkey#X], [plan_id=X], [id=#X]

(7) ShuffleQueryStage
Output [1]: [c_custkey#X]
Arguments: X

(8) InputAdapter
Input [1]: [c_custkey#X]

(9) InputIteratorTransformer
Input [1]: [c_custkey#X]

(10) Scan parquet
Output [4]: [o_orderkey#X, o_custkey#X, o_orderdate#X, o_shippriority#X]
Batched: true
Location: InMemoryFileIndex [*]
PushedFilters: [IsNotNull(o_orderdate), LessThan(o_orderdate,1995-03-15), IsNotNull(o_custkey), IsNotNull(o_orderkey)]
ReadSchema: struct<o_orderkey:bigint,o_custkey:bigint,o_orderdate:date,o_shippriority:int>

(11) FilterExecTransformer
Input [4]: [o_orderkey#X, o_custkey#X, o_orderdate#X, o_shippriority#X]
Arguments: (((isnotnull(o_orderdate#X) AND (o_orderdate#X < 1995-03-15)) AND isnotnull(o_custkey#X)) AND isnotnull(o_orderkey#X))

(12) ProjectExecTransformer
Output [5]: [hash(o_custkey#X, 42) AS hash_partition_key#X, o_orderkey#X, o_custkey#X, o_orderdate#X, o_shippriority#X]
Input [4]: [o_orderkey#X, o_custkey#X, o_orderdate#X, o_shippriority#X]

(13) WholeStageCodegenTransformer (X)
Input [5]: [hash_partition_key#X, o_orderkey#X, o_custkey#X, o_orderdate#X, o_shippriority#X]
Arguments: false

(14) VeloxAppendBatches
Input [5]: [hash_partition_key#X, o_orderkey#X, o_custkey#X, o_orderdate#X, o_shippriority#X]
Arguments: X

(15) ColumnarExchange
Input [5]: [hash_partition_key#X, o_orderkey#X, o_custkey#X, o_orderdate#X, o_shippriority#X]
Arguments: hashpartitioning(o_custkey#X, 1), ENSURE_REQUIREMENTS, [o_orderkey#X, o_custkey#X, o_orderdate#X, o_shippriority#X], [plan_id=X], [id=#X]

(16) ShuffleQueryStage
Output [4]: [o_orderkey#X, o_custkey#X, o_orderdate#X, o_shippriority#X]
Arguments: X

(17) InputAdapter
Input [4]: [o_orderkey#X, o_custkey#X, o_orderdate#X, o_shippriority#X]

(18) InputIteratorTransformer
Input [4]: [o_orderkey#X, o_custkey#X, o_orderdate#X, o_shippriority#X]

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

(20) ProjectExecTransformer
Output [4]: [hash(o_orderkey#X, 42) AS hash_partition_key#X, o_orderkey#X, o_orderdate#X, o_shippriority#X]
Input [5]: [c_custkey#X, o_orderkey#X, o_custkey#X, o_orderdate#X, o_shippriority#X]

(21) WholeStageCodegenTransformer (X)
Input [4]: [hash_partition_key#X, o_orderkey#X, o_orderdate#X, o_shippriority#X]
Arguments: false

(22) VeloxAppendBatches
Input [4]: [hash_partition_key#X, o_orderkey#X, o_orderdate#X, o_shippriority#X]
Arguments: X

(23) ColumnarExchange
Input [4]: [hash_partition_key#X, o_orderkey#X, o_orderdate#X, o_shippriority#X]
Arguments: hashpartitioning(o_orderkey#X, 1), ENSURE_REQUIREMENTS, [o_orderkey#X, o_orderdate#X, o_shippriority#X], [plan_id=X], [id=#X]

(24) ShuffleQueryStage
Output [3]: [o_orderkey#X, o_orderdate#X, o_shippriority#X]
Arguments: X

(25) InputAdapter
Input [3]: [o_orderkey#X, o_orderdate#X, o_shippriority#X]

(26) InputIteratorTransformer
Input [3]: [o_orderkey#X, o_orderdate#X, o_shippriority#X]

(27) Scan parquet
Output [4]: [l_orderkey#X, l_extendedprice#X, l_discount#X, l_shipdate#X]
Batched: true
Location: InMemoryFileIndex [*]
PushedFilters: [IsNotNull(l_shipdate), GreaterThan(l_shipdate,1995-03-15), IsNotNull(l_orderkey)]
ReadSchema: struct<l_orderkey:bigint,l_extendedprice:decimal(12,2),l_discount:decimal(12,2),l_shipdate:date>

(28) FilterExecTransformer
Input [4]: [l_orderkey#X, l_extendedprice#X, l_discount#X, l_shipdate#X]
Arguments: ((isnotnull(l_shipdate#X) AND (l_shipdate#X > 1995-03-15)) AND isnotnull(l_orderkey#X))

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

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

(31) VeloxAppendBatches
Input [4]: [hash_partition_key#X, l_orderkey#X, l_extendedprice#X, l_discount#X]
Arguments: X

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

(33) ShuffleQueryStage
Output [3]: [l_orderkey#X, l_extendedprice#X, l_discount#X]
Arguments: X

(34) InputAdapter
Input [3]: [l_orderkey#X, l_extendedprice#X, l_discount#X]

(35) InputIteratorTransformer
Input [3]: [l_orderkey#X, l_extendedprice#X, l_discount#X]

(36) ShuffledHashJoinExecTransformer
Left keys [1]: [o_orderkey#X]
Right keys [1]: [l_orderkey#X]
Join condition: None

(37) ProjectExecTransformer
Output [6]: [o_orderdate#X, o_shippriority#X, l_orderkey#X, l_extendedprice#X, l_discount#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), true))), DecimalType(26,4), true) AS _pre_X#X]
Input [6]: [o_orderkey#X, o_orderdate#X, o_shippriority#X, l_orderkey#X, l_extendedprice#X, l_discount#X]

(38) RegularHashAggregateExecTransformer
Input [6]: [o_orderdate#X, o_shippriority#X, l_orderkey#X, l_extendedprice#X, l_discount#X, _pre_X#X]
Keys [3]: [l_orderkey#X, o_orderdate#X, o_shippriority#X]
Functions [1]: [partial_sum(_pre_X#X)]
Aggregate Attributes [2]: [sum#X, isEmpty#X]
Results [5]: [l_orderkey#X, o_orderdate#X, o_shippriority#X, sum#X, isEmpty#X]

(39) RegularHashAggregateExecTransformer
Input [5]: [l_orderkey#X, o_orderdate#X, o_shippriority#X, sum#X, isEmpty#X]
Keys [3]: [l_orderkey#X, o_orderdate#X, o_shippriority#X]
Functions [1]: [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), true))), DecimalType(26,4), true))]
Aggregate Attributes [1]: [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), true))), DecimalType(26,4), true))#X]
Results [4]: [l_orderkey#X, o_orderdate#X, o_shippriority#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), true))), DecimalType(26,4), true))#X]

(40) ProjectExecTransformer
Output [4]: [l_orderkey#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), true))), DecimalType(26,4), true))#X AS revenue#X, o_orderdate#X, o_shippriority#X]
Input [4]: [l_orderkey#X, o_orderdate#X, o_shippriority#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), true))), DecimalType(26,4), true))#X]

(41) WholeStageCodegenTransformer (X)
Input [4]: [l_orderkey#X, revenue#X, o_orderdate#X, o_shippriority#X]
Arguments: false

(42) TakeOrderedAndProjectExecTransformer
Input [4]: [l_orderkey#X, revenue#X, o_orderdate#X, o_shippriority#X]
Arguments: X, [revenue#X DESC NULLS LAST, o_orderdate#X ASC NULLS FIRST], [l_orderkey#X, revenue#X, o_orderdate#X, o_shippriority#X], 0

(43) VeloxColumnarToRowExec
Input [4]: [l_orderkey#X, revenue#X, o_orderdate#X, o_shippriority#X]

(44) Scan parquet
Output [2]: [c_custkey#X, c_mktsegment#X]
Batched: true
Location: InMemoryFileIndex [*]
PushedFilters: [IsNotNull(c_mktsegment), EqualTo(c_mktsegment,BUILDING), IsNotNull(c_custkey)]
ReadSchema: struct<c_custkey:bigint,c_mktsegment:string>

(45) Filter
Input [2]: [c_custkey#X, c_mktsegment#X]
Condition : ((isnotnull(c_mktsegment#X) AND (c_mktsegment#X = BUILDING)) AND isnotnull(c_custkey#X))

(46) Project
Output [1]: [c_custkey#X]
Input [2]: [c_custkey#X, c_mktsegment#X]

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

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

(49) Scan parquet
Output [4]: [o_orderkey#X, o_custkey#X, o_orderdate#X, o_shippriority#X]
Batched: true
Location: InMemoryFileIndex [*]
PushedFilters: [IsNotNull(o_orderdate), LessThan(o_orderdate,1995-03-15), IsNotNull(o_custkey), IsNotNull(o_orderkey)]
ReadSchema: struct<o_orderkey:bigint,o_custkey:bigint,o_orderdate:date,o_shippriority:int>

(50) Filter
Input [4]: [o_orderkey#X, o_custkey#X, o_orderdate#X, o_shippriority#X]
Condition : (((isnotnull(o_orderdate#X) AND (o_orderdate#X < 1995-03-15)) AND isnotnull(o_custkey#X)) AND isnotnull(o_orderkey#X))

(51) Exchange
Input [4]: [o_orderkey#X, o_custkey#X, o_orderdate#X, o_shippriority#X]
Arguments: hashpartitioning(o_custkey#X, 1), ENSURE_REQUIREMENTS, [plan_id=X]

(52) Sort
Input [4]: [o_orderkey#X, o_custkey#X, o_orderdate#X, o_shippriority#X]
Arguments: [o_custkey#X ASC NULLS FIRST], false, 0

(53) SortMergeJoin
Left keys [1]: [c_custkey#X]
Right keys [1]: [o_custkey#X]
Join condition: None

(54) Project
Output [3]: [o_orderkey#X, o_orderdate#X, o_shippriority#X]
Input [5]: [c_custkey#X, o_orderkey#X, o_custkey#X, o_orderdate#X, o_shippriority#X]

(55) Exchange
Input [3]: [o_orderkey#X, o_orderdate#X, o_shippriority#X]
Arguments: hashpartitioning(o_orderkey#X, 1), ENSURE_REQUIREMENTS, [plan_id=X]

(56) Sort
Input [3]: [o_orderkey#X, o_orderdate#X, o_shippriority#X]
Arguments: [o_orderkey#X ASC NULLS FIRST], false, 0

(57) Scan parquet
Output [4]: [l_orderkey#X, l_extendedprice#X, l_discount#X, l_shipdate#X]
Batched: true
Location: InMemoryFileIndex [*]
PushedFilters: [IsNotNull(l_shipdate), GreaterThan(l_shipdate,1995-03-15), IsNotNull(l_orderkey)]
ReadSchema: struct<l_orderkey:bigint,l_extendedprice:decimal(12,2),l_discount:decimal(12,2),l_shipdate:date>

(58) Filter
Input [4]: [l_orderkey#X, l_extendedprice#X, l_discount#X, l_shipdate#X]
Condition : ((isnotnull(l_shipdate#X) AND (l_shipdate#X > 1995-03-15)) AND isnotnull(l_orderkey#X))

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

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

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

(62) SortMergeJoin
Left keys [1]: [o_orderkey#X]
Right keys [1]: [l_orderkey#X]
Join condition: None

(63) Project
Output [5]: [o_orderdate#X, o_shippriority#X, l_orderkey#X, l_extendedprice#X, l_discount#X]
Input [6]: [o_orderkey#X, o_orderdate#X, o_shippriority#X, l_orderkey#X, l_extendedprice#X, l_discount#X]

(64) HashAggregate
Input [5]: [o_orderdate#X, o_shippriority#X, l_orderkey#X, l_extendedprice#X, l_discount#X]
Keys [3]: [l_orderkey#X, o_orderdate#X, o_shippriority#X]
Functions [1]: [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), true))), DecimalType(26,4), true))]
Aggregate Attributes [2]: [sum#X, isEmpty#X]
Results [5]: [l_orderkey#X, o_orderdate#X, o_shippriority#X, sum#X, isEmpty#X]

(65) HashAggregate
Input [5]: [l_orderkey#X, o_orderdate#X, o_shippriority#X, sum#X, isEmpty#X]
Keys [3]: [l_orderkey#X, o_orderdate#X, o_shippriority#X]
Functions [1]: [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), true))), DecimalType(26,4), true))]
Aggregate Attributes [1]: [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), true))), DecimalType(26,4), true))#X]
Results [4]: [l_orderkey#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), true))), DecimalType(26,4), true))#X AS revenue#X, o_orderdate#X, o_shippriority#X]

(66) TakeOrderedAndProject
Input [4]: [l_orderkey#X, revenue#X, o_orderdate#X, o_shippriority#X]
Arguments: X, [revenue#X DESC NULLS LAST, o_orderdate#X ASC NULLS FIRST], [l_orderkey#X, revenue#X, o_orderdate#X, o_shippriority#X]

(67) AdaptiveSparkPlan
Output [4]: [l_orderkey#X, revenue#X, o_orderdate#X, o_shippriority#X]
Arguments: isFinalPlan=true