== Physical Plan ==
AdaptiveSparkPlan (46)
+- == Final Plan ==
   VeloxColumnarToRow (31)
   +- ^ SortExecTransformer (29)
      +- ^ InputIteratorTransformer (28)
         +- ShuffleQueryStage (26), Statistics(X)
            +- ColumnarExchange (25)
               +- VeloxResizeBatches (24)
                  +- ^ RegularHashAggregateExecTransformer (22)
                     +- ^ InputIteratorTransformer (21)
                        +- ShuffleQueryStage (19), Statistics(X)
                           +- ColumnarExchange (18)
                              +- VeloxResizeBatches (17)
                                 +- ^ ProjectExecTransformer (15)
                                    +- ^ FlushableHashAggregateExecTransformer (14)
                                       +- ^ ProjectExecTransformer (13)
                                          +- ^ BroadcastHashJoinExecTransformer LeftSemi BuildRight (12)
                                             :- ^ ProjectExecTransformer (3)
                                             :  +- ^ FilterExecTransformer (2)
                                             :     +- ^ ScanTransformer parquet  (1)
                                             +- ^ InputIteratorTransformer (11)
                                                +- BroadcastQueryStage (9), Statistics(X)
                                                   +- ColumnarBroadcastExchange (8)
                                                      +- ^ ProjectExecTransformer (6)
                                                         +- ^ FilterExecTransformer (5)
                                                            +- ^ ScanTransformer parquet  (4)
+- == Initial Plan ==
   Sort (45)
   +- Exchange (44)
      +- HashAggregate (43)
         +- Exchange (42)
            +- HashAggregate (41)
               +- Project (40)
                  +- BroadcastHashJoin LeftSemi BuildRight (39)
                     :- Project (34)
                     :  +- Filter (33)
                     :     +- Scan parquet (32)
                     +- BroadcastExchange (38)
                        +- Project (37)
                           +- Filter (36)
                              +- Scan parquet (35)


(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 [2]: [o_orderkey#X, o_orderpriority#X]
Input [3]: [o_orderkey#X, o_orderdate#X, o_orderpriority#X]

(4) 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>

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

(6) ProjectExecTransformer
Output [1]: [l_orderkey#X]
Input [3]: [l_orderkey#X, l_commitdate#X, l_receiptdate#X]

(7) WholeStageCodegenTransformer (X)
Input [1]: [l_orderkey#X]
Arguments: false

(8) ColumnarBroadcastExchange
Input [1]: [l_orderkey#X]
Arguments: HashedRelationBroadcastMode(List(input[0, bigint, true]),false), [plan_id=X]

(9) BroadcastQueryStage
Output [1]: [l_orderkey#X]
Arguments: X

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

(32) 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>

(33) 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))

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

(35) 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>

(36) 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))

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

(38) BroadcastExchange
Input [1]: [l_orderkey#X]
Arguments: HashedRelationBroadcastMode(List(input[0, bigint, true]),false), [plan_id=X]

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

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

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

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

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

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

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

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