== Physical Plan ==
AdaptiveSparkPlan (58)
+- == Final Plan ==
   VeloxColumnarToRowExec (40)
   +- ^ SortExecTransformer (38)
      +- ^ InputIteratorTransformer (37)
         +- ShuffleQueryStage (35), Statistics(X)
            +- ColumnarExchange (34)
               +- VeloxAppendBatches (33)
                  +- ^ RegularHashAggregateExecTransformer (31)
                     +- ^ InputIteratorTransformer (30)
                        +- ShuffleQueryStage (28), Statistics(X)
                           +- ColumnarExchange (27)
                              +- VeloxAppendBatches (26)
                                 +- ^ ProjectExecTransformer (24)
                                    +- ^ FlushableHashAggregateExecTransformer (23)
                                       +- ^ ProjectExecTransformer (22)
                                          +- ^ RegularHashAggregateExecTransformer (21)
                                             +- ^ RegularHashAggregateExecTransformer (20)
                                                +- ^ ProjectExecTransformer (19)
                                                   +- ^ ShuffledHashJoinExecTransformer LeftOuter BuildLeft (18)
                                                      :- ^ InputIteratorTransformer (8)
                                                      :  +- ShuffleQueryStage (6), Statistics(X)
                                                      :     +- ColumnarExchange (5)
                                                      :        +- VeloxAppendBatches (4)
                                                      :           +- ^ ProjectExecTransformer (2)
                                                      :              +- ^ Scan parquet (1)
                                                      +- ^ InputIteratorTransformer (17)
                                                         +- ShuffleQueryStage (15), Statistics(X)
                                                            +- ColumnarExchange (14)
                                                               +- VeloxAppendBatches (13)
                                                                  +- ^ ProjectExecTransformer (11)
                                                                     +- ^ FilterExecTransformer (10)
                                                                        +- ^ Scan parquet (9)
+- == Initial Plan ==
   Sort (57)
   +- Exchange (56)
      +- HashAggregate (55)
         +- Exchange (54)
            +- HashAggregate (53)
               +- HashAggregate (52)
                  +- HashAggregate (51)
                     +- Project (50)
                        +- SortMergeJoin LeftOuter (49)
                           :- Sort (43)
                           :  +- Exchange (42)
                           :     +- Scan parquet (41)
                           +- Sort (48)
                              +- Exchange (47)
                                 +- Project (46)
                                    +- Filter (45)
                                       +- Scan parquet (44)


(1) Scan parquet
Output [1]: [c_custkey#X]
Batched: true
Location: InMemoryFileIndex [*]
ReadSchema: struct<c_custkey:bigint>

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

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

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

(5) 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]

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

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

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

(9) Scan parquet
Output [3]: [o_orderkey#X, o_custkey#X, o_comment#X]
Batched: true
Location: InMemoryFileIndex [*]
PushedFilters: [IsNotNull(o_comment), IsNotNull(o_custkey)]
ReadSchema: struct<o_orderkey:bigint,o_custkey:bigint,o_comment:string>

(10) FilterExecTransformer
Input [3]: [o_orderkey#X, o_custkey#X, o_comment#X]
Arguments: ((isnotnull(o_comment#X) AND NOT o_comment#X LIKE %special%requests%) AND isnotnull(o_custkey#X))

(11) ProjectExecTransformer
Output [3]: [hash(o_custkey#X, 42) AS hash_partition_key#X, o_orderkey#X, o_custkey#X]
Input [3]: [o_orderkey#X, o_custkey#X, o_comment#X]

(12) WholeStageCodegenTransformer (X)
Input [3]: [hash_partition_key#X, o_orderkey#X, o_custkey#X]
Arguments: false

(13) VeloxAppendBatches
Input [3]: [hash_partition_key#X, o_orderkey#X, o_custkey#X]
Arguments: X

(14) ColumnarExchange
Input [3]: [hash_partition_key#X, o_orderkey#X, o_custkey#X]
Arguments: hashpartitioning(o_custkey#X, 1), ENSURE_REQUIREMENTS, [o_orderkey#X, o_custkey#X], [plan_id=X], [id=#X]

(15) ShuffleQueryStage
Output [2]: [o_orderkey#X, o_custkey#X]
Arguments: X

(16) InputAdapter
Input [2]: [o_orderkey#X, o_custkey#X]

(17) InputIteratorTransformer
Input [2]: [o_orderkey#X, o_custkey#X]

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

(19) ProjectExecTransformer
Output [2]: [c_custkey#X, o_orderkey#X]
Input [3]: [c_custkey#X, o_orderkey#X, o_custkey#X]

(20) RegularHashAggregateExecTransformer
Input [2]: [c_custkey#X, o_orderkey#X]
Keys [1]: [c_custkey#X]
Functions [1]: [partial_count(o_orderkey#X)]
Aggregate Attributes [1]: [count#X]
Results [2]: [c_custkey#X, count#X]

(21) RegularHashAggregateExecTransformer
Input [2]: [c_custkey#X, count#X]
Keys [1]: [c_custkey#X]
Functions [1]: [count(o_orderkey#X)]
Aggregate Attributes [1]: [count(o_orderkey#X)#X]
Results [2]: [c_custkey#X, count(o_orderkey#X)#X]

(22) ProjectExecTransformer
Output [1]: [count(o_orderkey#X)#X AS c_count#X]
Input [2]: [c_custkey#X, count(o_orderkey#X)#X]

(23) FlushableHashAggregateExecTransformer
Input [1]: [c_count#X]
Keys [1]: [c_count#X]
Functions [1]: [partial_count(1)]
Aggregate Attributes [1]: [count#X]
Results [2]: [c_count#X, count#X]

(24) ProjectExecTransformer
Output [3]: [hash(c_count#X, 42) AS hash_partition_key#X, c_count#X, count#X]
Input [2]: [c_count#X, count#X]

(25) WholeStageCodegenTransformer (X)
Input [3]: [hash_partition_key#X, c_count#X, count#X]
Arguments: false

(26) VeloxAppendBatches
Input [3]: [hash_partition_key#X, c_count#X, count#X]
Arguments: X

(27) ColumnarExchange
Input [3]: [hash_partition_key#X, c_count#X, count#X]
Arguments: hashpartitioning(c_count#X, 1), ENSURE_REQUIREMENTS, [c_count#X, count#X], [plan_id=X], [id=#X]

(28) ShuffleQueryStage
Output [2]: [c_count#X, count#X]
Arguments: X

(29) InputAdapter
Input [2]: [c_count#X, count#X]

(30) InputIteratorTransformer
Input [2]: [c_count#X, count#X]

(31) RegularHashAggregateExecTransformer
Input [2]: [c_count#X, count#X]
Keys [1]: [c_count#X]
Functions [1]: [count(1)]
Aggregate Attributes [1]: [count(1)#X]
Results [2]: [c_count#X, count(1)#X AS custdist#X]

(32) WholeStageCodegenTransformer (X)
Input [2]: [c_count#X, custdist#X]
Arguments: false

(33) VeloxAppendBatches
Input [2]: [c_count#X, custdist#X]
Arguments: X

(34) ColumnarExchange
Input [2]: [c_count#X, custdist#X]
Arguments: rangepartitioning(custdist#X DESC NULLS LAST, c_count#X DESC NULLS LAST, 1), ENSURE_REQUIREMENTS, [plan_id=X], [id=#X]

(35) ShuffleQueryStage
Output [2]: [c_count#X, custdist#X]
Arguments: X

(36) InputAdapter
Input [2]: [c_count#X, custdist#X]

(37) InputIteratorTransformer
Input [2]: [c_count#X, custdist#X]

(38) SortExecTransformer
Input [2]: [c_count#X, custdist#X]
Arguments: [custdist#X DESC NULLS LAST, c_count#X DESC NULLS LAST], true, 0

(39) WholeStageCodegenTransformer (X)
Input [2]: [c_count#X, custdist#X]
Arguments: false

(40) VeloxColumnarToRowExec
Input [2]: [c_count#X, custdist#X]

(41) Scan parquet
Output [1]: [c_custkey#X]
Batched: true
Location: InMemoryFileIndex [*]
ReadSchema: struct<c_custkey:bigint>

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

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

(44) Scan parquet
Output [3]: [o_orderkey#X, o_custkey#X, o_comment#X]
Batched: true
Location: InMemoryFileIndex [*]
PushedFilters: [IsNotNull(o_comment), IsNotNull(o_custkey)]
ReadSchema: struct<o_orderkey:bigint,o_custkey:bigint,o_comment:string>

(45) Filter
Input [3]: [o_orderkey#X, o_custkey#X, o_comment#X]
Condition : ((isnotnull(o_comment#X) AND NOT o_comment#X LIKE %special%requests%) AND isnotnull(o_custkey#X))

(46) Project
Output [2]: [o_orderkey#X, o_custkey#X]
Input [3]: [o_orderkey#X, o_custkey#X, o_comment#X]

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

(48) Sort
Input [2]: [o_orderkey#X, o_custkey#X]
Arguments: [o_custkey#X ASC NULLS FIRST], false, 0

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

(50) Project
Output [2]: [c_custkey#X, o_orderkey#X]
Input [3]: [c_custkey#X, o_orderkey#X, o_custkey#X]

(51) HashAggregate
Input [2]: [c_custkey#X, o_orderkey#X]
Keys [1]: [c_custkey#X]
Functions [1]: [partial_count(o_orderkey#X)]
Aggregate Attributes [1]: [count#X]
Results [2]: [c_custkey#X, count#X]

(52) HashAggregate
Input [2]: [c_custkey#X, count#X]
Keys [1]: [c_custkey#X]
Functions [1]: [count(o_orderkey#X)]
Aggregate Attributes [1]: [count(o_orderkey#X)#X]
Results [1]: [count(o_orderkey#X)#X AS c_count#X]

(53) HashAggregate
Input [1]: [c_count#X]
Keys [1]: [c_count#X]
Functions [1]: [partial_count(1)]
Aggregate Attributes [1]: [count#X]
Results [2]: [c_count#X, count#X]

(54) Exchange
Input [2]: [c_count#X, count#X]
Arguments: hashpartitioning(c_count#X, 1), ENSURE_REQUIREMENTS, [plan_id=X]

(55) HashAggregate
Input [2]: [c_count#X, count#X]
Keys [1]: [c_count#X]
Functions [1]: [count(1)]
Aggregate Attributes [1]: [count(1)#X]
Results [2]: [c_count#X, count(1)#X AS custdist#X]

(56) Exchange
Input [2]: [c_count#X, custdist#X]
Arguments: rangepartitioning(custdist#X DESC NULLS LAST, c_count#X DESC NULLS LAST, 1), ENSURE_REQUIREMENTS, [plan_id=X]

(57) Sort
Input [2]: [c_count#X, custdist#X]
Arguments: [custdist#X DESC NULLS LAST, c_count#X DESC NULLS LAST], true, 0

(58) AdaptiveSparkPlan
Output [2]: [c_count#X, custdist#X]
Arguments: isFinalPlan=true