== Physical Plan ==
VeloxColumnarToRow (28)
+- ^ SortExecTransformer (26)
   +- ^ InputIteratorTransformer (25)
      +- ColumnarExchange (23)
         +- VeloxResizeBatches (22)
            +- ^ RegularHashAggregateExecTransformer (20)
               +- ^ InputIteratorTransformer (19)
                  +- ColumnarExchange (17)
                     +- VeloxResizeBatches (16)
                        +- ^ ProjectExecTransformer (14)
                           +- ^ FlushableHashAggregateExecTransformer (13)
                              +- ^ ProjectExecTransformer (12)
                                 +- ^ BroadcastHashJoinExecTransformer LeftSemi BuildRight (11)
                                    :- ^ ProjectExecTransformer (3)
                                    :  +- ^ FilterExecTransformer (2)
                                    :     +- ^ FileSourceScanExecTransformer parquet spark_catalog.default.orders (1)
                                    +- ^ InputIteratorTransformer (10)
                                       +- ColumnarBroadcastExchange (8)
                                          +- ^ ProjectExecTransformer (6)
                                             +- ^ FilterExecTransformer (5)
                                                +- ^ FileSourceScanExecTransformer parquet spark_catalog.default.lineitem (4)


(1) FileSourceScanExecTransformer parquet spark_catalog.default.orders
Output [3]: [o_orderkey#1, o_orderdate#2, o_orderpriority#3]
Batched: true
Location: InMemoryFileIndex [{warehouse_dir}/orders]
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#1, o_orderdate#2, o_orderpriority#3]
Arguments: ((isnotnull(o_orderdate#2) AND (o_orderdate#2 >= 1993-07-01)) AND (o_orderdate#2 < 1993-10-01))

(3) ProjectExecTransformer
Output [2]: [o_orderkey#1, o_orderpriority#3]
Input [3]: [o_orderkey#1, o_orderdate#2, o_orderpriority#3]

(4) FileSourceScanExecTransformer parquet spark_catalog.default.lineitem
Output [3]: [l_orderkey#4, l_commitdate#5, l_receiptdate#6]
Batched: true
Location: InMemoryFileIndex [{warehouse_dir}/lineitem]
PushedFilters: [IsNotNull(l_commitdate), IsNotNull(l_receiptdate)]
ReadSchema: struct<l_orderkey:bigint,l_commitdate:date,l_receiptdate:date>

(5) FilterExecTransformer
Input [3]: [l_orderkey#4, l_commitdate#5, l_receiptdate#6]
Arguments: ((isnotnull(l_commitdate#5) AND isnotnull(l_receiptdate#6)) AND (l_commitdate#5 < l_receiptdate#6))

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

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

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

(9) InputAdapter
Input [1]: [l_orderkey#4]

(10) InputIteratorTransformer
Input [1]: [l_orderkey#4]

(11) BroadcastHashJoinExecTransformer
Left keys [1]: [o_orderkey#1]
Right keys [1]: [l_orderkey#4]
Join type: LeftSemi
Join condition: None

(12) ProjectExecTransformer
Output [1]: [o_orderpriority#3]
Input [2]: [o_orderkey#1, o_orderpriority#3]

(13) FlushableHashAggregateExecTransformer
Input [1]: [o_orderpriority#3]
Keys [1]: [o_orderpriority#3]
Functions [1]: [partial_count(1)]
Aggregate Attributes [1]: [count#7]
Results [2]: [o_orderpriority#3, count#8]

(14) ProjectExecTransformer
Output [3]: [hash(o_orderpriority#3, 42) AS hash_partition_key#9, o_orderpriority#3, count#8]
Input [2]: [o_orderpriority#3, count#8]

(15) WholeStageCodegenTransformer (2)
Input [3]: [hash_partition_key#9, o_orderpriority#3, count#8]
Arguments: false

(16) VeloxResizeBatches
Input [3]: [hash_partition_key#9, o_orderpriority#3, count#8]
Arguments: 1024, 2147483647, 10485760

(17) ColumnarExchange
Input [3]: [hash_partition_key#9, o_orderpriority#3, count#8]
Arguments: hashpartitioning(o_orderpriority#3, 1), ENSURE_REQUIREMENTS, [o_orderpriority#3, count#8], [plan_id=2], [shuffle_writer_type=hash]

(18) InputAdapter
Input [2]: [o_orderpriority#3, count#8]

(19) InputIteratorTransformer
Input [2]: [o_orderpriority#3, count#8]

(20) RegularHashAggregateExecTransformer
Input [2]: [o_orderpriority#3, count#8]
Keys [1]: [o_orderpriority#3]
Functions [1]: [count(1)]
Aggregate Attributes [1]: [count(1)#10]
Results [2]: [o_orderpriority#3, count(1)#10 AS order_count#11]

(21) WholeStageCodegenTransformer (3)
Input [2]: [o_orderpriority#3, order_count#11]
Arguments: false

(22) VeloxResizeBatches
Input [2]: [o_orderpriority#3, order_count#11]
Arguments: 1024, 2147483647, 10485760

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

(24) InputAdapter
Input [2]: [o_orderpriority#3, order_count#11]

(25) InputIteratorTransformer
Input [2]: [o_orderpriority#3, order_count#11]

(26) SortExecTransformer
Input [2]: [o_orderpriority#3, order_count#11]
Arguments: [o_orderpriority#3 ASC NULLS FIRST], true, 0

(27) WholeStageCodegenTransformer (4)
Input [2]: [o_orderpriority#3, order_count#11]
Arguments: false

(28) VeloxColumnarToRow
Input [2]: [o_orderpriority#3, order_count#11]

