== Physical Plan ==
AdaptiveSparkPlan (56)
+- == Final Plan ==
   VeloxColumnarToRow (38)
   +- ^ SortExecTransformer (36)
      +- ^ InputIteratorTransformer (35)
         +- ShuffleQueryStage (33), Statistics(X)
            +- ColumnarExchange (32)
               +- VeloxResizeBatches (31)
                  +- ^ RegularHashAggregateExecTransformer (29)
                     +- ^ InputIteratorTransformer (28)
                        +- ShuffleQueryStage (26), Statistics(X)
                           +- ColumnarExchange (25)
                              +- VeloxResizeBatches (24)
                                 +- ^ ProjectExecTransformer (22)
                                    +- ^ FlushableHashAggregateExecTransformer (21)
                                       +- ^ ProjectExecTransformer (20)
                                          +- ^ ShuffledHashJoinExecTransformer LeftSemi 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)
+- == Initial Plan ==
   Sort (55)
   +- Exchange (54)
      +- HashAggregate (53)
         +- Exchange (52)
            +- HashAggregate (51)
               +- Project (50)
                  +- SortMergeJoin LeftSemi (49)
                     :- Sort (43)
                     :  +- Exchange (42)
                     :     +- Project (41)
                     :        +- Filter (40)
                     :           +- Scan parquet (39)
                     +- Sort (48)
                        +- Exchange (47)
                           +- Project (46)
                              +- Filter (45)
                                 +- Scan parquet (44)


(1) ScanTransformer parquet 
Output [3]: [o_orderkey#X, o_orderdate#X, o_orderpriority#X]
Batched: true
Location: InMemoryFileIndex [*]
PushedFilters: [IsNotNull(o_orderdate), GreaterThanOrEqual(o_orderdate,1993-07-01), LessThan(o_orderdate,1993-10-01)]
ReadSchema: struct<o_orderkey:bigint,o_orderdate:date,o_orderpriority:string>

(2) FilterExecTransformer
Input [3]: [o_orderkey#X, o_orderdate#X, o_orderpriority#X]
Arguments: ((isnotnull(o_orderdate#X) AND (o_orderdate#X >= 1993-07-01)) AND (o_orderdate#X < 1993-10-01))

(3) ProjectExecTransformer
Output [3]: [hash(o_orderkey#X, 42) AS hash_partition_key#X, o_orderkey#X, o_orderpriority#X]
Input [3]: [o_orderkey#X, o_orderdate#X, o_orderpriority#X]

(4) WholeStageCodegenTransformer (X)
Input [3]: [hash_partition_key#X, o_orderkey#X, o_orderpriority#X]
Arguments: false

(5) VeloxResizeBatches
Input [3]: [hash_partition_key#X, o_orderkey#X, o_orderpriority#X]
Arguments: X, X

(6) ColumnarExchange
Input [3]: [hash_partition_key#X, o_orderkey#X, o_orderpriority#X]
Arguments: hashpartitioning(o_orderkey#X, 1), ENSURE_REQUIREMENTS, [o_orderkey#X, o_orderpriority#X], [plan_id=X], [shuffle_writer_type=hash]

(7) ShuffleQueryStage
Output [2]: [o_orderkey#X, o_orderpriority#X]
Arguments: X

(8) InputAdapter
Input [2]: [o_orderkey#X, o_orderpriority#X]

(9) InputIteratorTransformer
Input [2]: [o_orderkey#X, o_orderpriority#X]

(10) ScanTransformer parquet 
Output [3]: [l_orderkey#X, l_commitdate#X, l_receiptdate#X]
Batched: true
Location: InMemoryFileIndex [*]
PushedFilters: [IsNotNull(l_commitdate), IsNotNull(l_receiptdate)]
ReadSchema: struct<l_orderkey:bigint,l_commitdate:date,l_receiptdate:date>

(11) FilterExecTransformer
Input [3]: [l_orderkey#X, l_commitdate#X, l_receiptdate#X]
Arguments: ((isnotnull(l_commitdate#X) AND isnotnull(l_receiptdate#X)) AND (l_commitdate#X < l_receiptdate#X))

(12) ProjectExecTransformer
Output [2]: [hash(l_orderkey#X, 42) AS hash_partition_key#X, l_orderkey#X]
Input [3]: [l_orderkey#X, l_commitdate#X, l_receiptdate#X]

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

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

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

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

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

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

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

(20) ProjectExecTransformer
Output [1]: [o_orderpriority#X]
Input [2]: [o_orderkey#X, o_orderpriority#X]

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

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

(23) WholeStageCodegenTransformer (X)
Input [3]: [hash_partition_key#X, o_orderpriority#X, count#X]
Arguments: false

(24) VeloxResizeBatches
Input [3]: [hash_partition_key#X, o_orderpriority#X, count#X]
Arguments: X, X

(25) ColumnarExchange
Input [3]: [hash_partition_key#X, o_orderpriority#X, count#X]
Arguments: hashpartitioning(o_orderpriority#X, 1), ENSURE_REQUIREMENTS, [o_orderpriority#X, count#X], [plan_id=X], [shuffle_writer_type=hash]

(26) ShuffleQueryStage
Output [2]: [o_orderpriority#X, count#X]
Arguments: X

(27) InputAdapter
Input [2]: [o_orderpriority#X, count#X]

(28) InputIteratorTransformer
Input [2]: [o_orderpriority#X, count#X]

(29) RegularHashAggregateExecTransformer
Input [2]: [o_orderpriority#X, count#X]
Keys [1]: [o_orderpriority#X]
Functions [1]: [count(1)]
Aggregate Attributes [1]: [count(1)#X]
Results [2]: [o_orderpriority#X, count(1)#X AS order_count#X]

(30) WholeStageCodegenTransformer (X)
Input [2]: [o_orderpriority#X, order_count#X]
Arguments: false

(31) VeloxResizeBatches
Input [2]: [o_orderpriority#X, order_count#X]
Arguments: X, X

(32) ColumnarExchange
Input [2]: [o_orderpriority#X, order_count#X]
Arguments: rangepartitioning(o_orderpriority#X ASC NULLS FIRST, 1), ENSURE_REQUIREMENTS, [plan_id=X], [shuffle_writer_type=hash]

(33) ShuffleQueryStage
Output [2]: [o_orderpriority#X, order_count#X]
Arguments: X

(34) InputAdapter
Input [2]: [o_orderpriority#X, order_count#X]

(35) InputIteratorTransformer
Input [2]: [o_orderpriority#X, order_count#X]

(36) SortExecTransformer
Input [2]: [o_orderpriority#X, order_count#X]
Arguments: [o_orderpriority#X ASC NULLS FIRST], true, 0

(37) WholeStageCodegenTransformer (X)
Input [2]: [o_orderpriority#X, order_count#X]
Arguments: false

(38) VeloxColumnarToRow
Input [2]: [o_orderpriority#X, order_count#X]

(39) Scan parquet
Output [3]: [o_orderkey#X, o_orderdate#X, o_orderpriority#X]
Batched: true
Location: InMemoryFileIndex [*]
PushedFilters: [IsNotNull(o_orderdate), GreaterThanOrEqual(o_orderdate,1993-07-01), LessThan(o_orderdate,1993-10-01)]
ReadSchema: struct<o_orderkey:bigint,o_orderdate:date,o_orderpriority:string>

(40) Filter
Input [3]: [o_orderkey#X, o_orderdate#X, o_orderpriority#X]
Condition : ((isnotnull(o_orderdate#X) AND (o_orderdate#X >= 1993-07-01)) AND (o_orderdate#X < 1993-10-01))

(41) Project
Output [2]: [o_orderkey#X, o_orderpriority#X]
Input [3]: [o_orderkey#X, o_orderdate#X, o_orderpriority#X]

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

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

(44) Scan parquet
Output [3]: [l_orderkey#X, l_commitdate#X, l_receiptdate#X]
Batched: true
Location: InMemoryFileIndex [*]
PushedFilters: [IsNotNull(l_commitdate), IsNotNull(l_receiptdate)]
ReadSchema: struct<l_orderkey:bigint,l_commitdate:date,l_receiptdate:date>

(45) Filter
Input [3]: [l_orderkey#X, l_commitdate#X, l_receiptdate#X]
Condition : ((isnotnull(l_commitdate#X) AND isnotnull(l_receiptdate#X)) AND (l_commitdate#X < l_receiptdate#X))

(46) Project
Output [1]: [l_orderkey#X]
Input [3]: [l_orderkey#X, l_commitdate#X, l_receiptdate#X]

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

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

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

(50) Project
Output [1]: [o_orderpriority#X]
Input [2]: [o_orderkey#X, o_orderpriority#X]

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

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

(53) HashAggregate
Input [2]: [o_orderpriority#X, count#X]
Keys [1]: [o_orderpriority#X]
Functions [1]: [count(1)]
Aggregate Attributes [1]: [count(1)#X]
Results [2]: [o_orderpriority#X, count(1)#X AS order_count#X]

(54) Exchange
Input [2]: [o_orderpriority#X, order_count#X]
Arguments: rangepartitioning(o_orderpriority#X ASC NULLS FIRST, 1), ENSURE_REQUIREMENTS, [plan_id=X]

(55) Sort
Input [2]: [o_orderpriority#X, order_count#X]
Arguments: [o_orderpriority#X ASC NULLS FIRST], true, 0

(56) AdaptiveSparkPlan
Output [2]: [o_orderpriority#X, order_count#X]
Arguments: isFinalPlan=true