== Physical Plan ==
VeloxColumnarToRow (60)
+- ^ SortExecTransformer (58)
   +- ^ InputIteratorTransformer (57)
      +- ColumnarExchange (55)
         +- VeloxResizeBatches (54)
            +- ^ RegularHashAggregateExecTransformer (52)
               +- ^ InputIteratorTransformer (51)
                  +- ColumnarExchange (49)
                     +- VeloxResizeBatches (48)
                        +- ^ ProjectExecTransformer (46)
                           +- ^ FlushableHashAggregateExecTransformer (45)
                              +- ^ ProjectExecTransformer (44)
                                 +- ^ BroadcastHashJoinExecTransformer Inner BuildRight (43)
                                    :- ^ ProjectExecTransformer (35)
                                    :  +- ^ BroadcastHashJoinExecTransformer Inner BuildRight (34)
                                    :     :- ^ ProjectExecTransformer (27)
                                    :     :  +- ^ BroadcastHashJoinExecTransformer Inner BuildRight (26)
                                    :     :     :- ^ ProjectExecTransformer (19)
                                    :     :     :  +- ^ BroadcastHashJoinExecTransformer Inner BuildRight (18)
                                    :     :     :     :- ^ ProjectExecTransformer (11)
                                    :     :     :     :  +- ^ BroadcastHashJoinExecTransformer Inner BuildRight (10)
                                    :     :     :     :     :- ^ FilterExecTransformer (2)
                                    :     :     :     :     :  +- ^ FileSourceScanExecTransformer parquet spark_catalog.default.customer (1)
                                    :     :     :     :     +- ^ InputIteratorTransformer (9)
                                    :     :     :     :        +- ColumnarBroadcastExchange (7)
                                    :     :     :     :           +- ^ ProjectExecTransformer (5)
                                    :     :     :     :              +- ^ FilterExecTransformer (4)
                                    :     :     :     :                 +- ^ FileSourceScanExecTransformer parquet spark_catalog.default.orders (3)
                                    :     :     :     +- ^ InputIteratorTransformer (17)
                                    :     :     :        +- ColumnarBroadcastExchange (15)
                                    :     :     :           +- ^ FilterExecTransformer (13)
                                    :     :     :              +- ^ FileSourceScanExecTransformer parquet spark_catalog.default.lineitem (12)
                                    :     :     +- ^ InputIteratorTransformer (25)
                                    :     :        +- ColumnarBroadcastExchange (23)
                                    :     :           +- ^ FilterExecTransformer (21)
                                    :     :              +- ^ FileSourceScanExecTransformer parquet spark_catalog.default.supplier (20)
                                    :     +- ^ InputIteratorTransformer (33)
                                    :        +- ColumnarBroadcastExchange (31)
                                    :           +- ^ FilterExecTransformer (29)
                                    :              +- ^ FileSourceScanExecTransformer parquet spark_catalog.default.nation (28)
                                    +- ^ InputIteratorTransformer (42)
                                       +- ColumnarBroadcastExchange (40)
                                          +- ^ ProjectExecTransformer (38)
                                             +- ^ FilterExecTransformer (37)
                                                +- ^ FileSourceScanExecTransformer parquet spark_catalog.default.region (36)


(1) FileSourceScanExecTransformer parquet spark_catalog.default.customer
Output [2]: [c_custkey#1, c_nationkey#2]
Batched: true
Location: InMemoryFileIndex [{warehouse_dir}/customer]
PushedFilters: [IsNotNull(c_custkey), IsNotNull(c_nationkey)]
ReadSchema: struct<c_custkey:bigint,c_nationkey:bigint>

(2) FilterExecTransformer
Input [2]: [c_custkey#1, c_nationkey#2]
Arguments: (isnotnull(c_custkey#1) AND isnotnull(c_nationkey#2))

(3) FileSourceScanExecTransformer parquet spark_catalog.default.orders
Output [3]: [o_orderkey#3, o_custkey#4, o_orderdate#5]
Batched: true
Location: InMemoryFileIndex [{warehouse_dir}/orders]
PushedFilters: [IsNotNull(o_orderdate), GreaterThanOrEqual(o_orderdate,1994-01-01), LessThan(o_orderdate,1995-01-01), IsNotNull(o_custkey), IsNotNull(o_orderkey)]
ReadSchema: struct<o_orderkey:bigint,o_custkey:bigint,o_orderdate:date>

(4) FilterExecTransformer
Input [3]: [o_orderkey#3, o_custkey#4, o_orderdate#5]
Arguments: ((((isnotnull(o_orderdate#5) AND (o_orderdate#5 >= 1994-01-01)) AND (o_orderdate#5 < 1995-01-01)) AND isnotnull(o_custkey#4)) AND isnotnull(o_orderkey#3))

(5) ProjectExecTransformer
Output [2]: [o_orderkey#3, o_custkey#4]
Input [3]: [o_orderkey#3, o_custkey#4, o_orderdate#5]

(6) WholeStageCodegenTransformer (1)
Input [2]: [o_orderkey#3, o_custkey#4]
Arguments: false

(7) ColumnarBroadcastExchange
Input [2]: [o_orderkey#3, o_custkey#4]
Arguments: HashedRelationBroadcastMode(List(input[1, bigint, true]),false), [plan_id=1]

(8) InputAdapter
Input [2]: [o_orderkey#3, o_custkey#4]

(9) InputIteratorTransformer
Input [2]: [o_orderkey#3, o_custkey#4]

(10) BroadcastHashJoinExecTransformer
Left keys [1]: [c_custkey#1]
Right keys [1]: [o_custkey#4]
Join type: Inner
Join condition: None

(11) ProjectExecTransformer
Output [2]: [c_nationkey#2, o_orderkey#3]
Input [4]: [c_custkey#1, c_nationkey#2, o_orderkey#3, o_custkey#4]

(12) FileSourceScanExecTransformer parquet spark_catalog.default.lineitem
Output [4]: [l_orderkey#6, l_suppkey#7, l_extendedprice#8, l_discount#9]
Batched: true
Location: InMemoryFileIndex [{warehouse_dir}/lineitem]
PushedFilters: [IsNotNull(l_orderkey), IsNotNull(l_suppkey)]
ReadSchema: struct<l_orderkey:bigint,l_suppkey:bigint,l_extendedprice:decimal(10,0),l_discount:decimal(10,0)>

(13) FilterExecTransformer
Input [4]: [l_orderkey#6, l_suppkey#7, l_extendedprice#8, l_discount#9]
Arguments: (isnotnull(l_orderkey#6) AND isnotnull(l_suppkey#7))

(14) WholeStageCodegenTransformer (2)
Input [4]: [l_orderkey#6, l_suppkey#7, l_extendedprice#8, l_discount#9]
Arguments: false

(15) ColumnarBroadcastExchange
Input [4]: [l_orderkey#6, l_suppkey#7, l_extendedprice#8, l_discount#9]
Arguments: HashedRelationBroadcastMode(List(input[0, bigint, false]),false), [plan_id=2]

(16) InputAdapter
Input [4]: [l_orderkey#6, l_suppkey#7, l_extendedprice#8, l_discount#9]

(17) InputIteratorTransformer
Input [4]: [l_orderkey#6, l_suppkey#7, l_extendedprice#8, l_discount#9]

(18) BroadcastHashJoinExecTransformer
Left keys [1]: [o_orderkey#3]
Right keys [1]: [l_orderkey#6]
Join type: Inner
Join condition: None

(19) ProjectExecTransformer
Output [4]: [c_nationkey#2, l_suppkey#7, l_extendedprice#8, l_discount#9]
Input [6]: [c_nationkey#2, o_orderkey#3, l_orderkey#6, l_suppkey#7, l_extendedprice#8, l_discount#9]

(20) FileSourceScanExecTransformer parquet spark_catalog.default.supplier
Output [2]: [s_suppkey#10, s_nationkey#11]
Batched: true
Location: InMemoryFileIndex [{warehouse_dir}/supplier]
PushedFilters: [IsNotNull(s_suppkey), IsNotNull(s_nationkey)]
ReadSchema: struct<s_suppkey:bigint,s_nationkey:bigint>

(21) FilterExecTransformer
Input [2]: [s_suppkey#10, s_nationkey#11]
Arguments: (isnotnull(s_suppkey#10) AND isnotnull(s_nationkey#11))

(22) WholeStageCodegenTransformer (3)
Input [2]: [s_suppkey#10, s_nationkey#11]
Arguments: false

(23) ColumnarBroadcastExchange
Input [2]: [s_suppkey#10, s_nationkey#11]
Arguments: HashedRelationBroadcastMode(List(input[0, bigint, false], input[1, bigint, false]),false), [plan_id=3]

(24) InputAdapter
Input [2]: [s_suppkey#10, s_nationkey#11]

(25) InputIteratorTransformer
Input [2]: [s_suppkey#10, s_nationkey#11]

(26) BroadcastHashJoinExecTransformer
Left keys [2]: [l_suppkey#7, c_nationkey#2]
Right keys [2]: [s_suppkey#10, s_nationkey#11]
Join type: Inner
Join condition: None

(27) ProjectExecTransformer
Output [3]: [l_extendedprice#8, l_discount#9, s_nationkey#11]
Input [6]: [c_nationkey#2, l_suppkey#7, l_extendedprice#8, l_discount#9, s_suppkey#10, s_nationkey#11]

(28) FileSourceScanExecTransformer parquet spark_catalog.default.nation
Output [3]: [n_nationkey#12, n_name#13, n_regionkey#14]
Batched: true
Location: InMemoryFileIndex [{warehouse_dir}/nation]
PushedFilters: [IsNotNull(n_nationkey), IsNotNull(n_regionkey)]
ReadSchema: struct<n_nationkey:bigint,n_name:string,n_regionkey:bigint>

(29) FilterExecTransformer
Input [3]: [n_nationkey#12, n_name#13, n_regionkey#14]
Arguments: (isnotnull(n_nationkey#12) AND isnotnull(n_regionkey#14))

(30) WholeStageCodegenTransformer (4)
Input [3]: [n_nationkey#12, n_name#13, n_regionkey#14]
Arguments: false

(31) ColumnarBroadcastExchange
Input [3]: [n_nationkey#12, n_name#13, n_regionkey#14]
Arguments: HashedRelationBroadcastMode(List(input[0, bigint, false]),false), [plan_id=4]

(32) InputAdapter
Input [3]: [n_nationkey#12, n_name#13, n_regionkey#14]

(33) InputIteratorTransformer
Input [3]: [n_nationkey#12, n_name#13, n_regionkey#14]

(34) BroadcastHashJoinExecTransformer
Left keys [1]: [s_nationkey#11]
Right keys [1]: [n_nationkey#12]
Join type: Inner
Join condition: None

(35) ProjectExecTransformer
Output [4]: [l_extendedprice#8, l_discount#9, n_name#13, n_regionkey#14]
Input [6]: [l_extendedprice#8, l_discount#9, s_nationkey#11, n_nationkey#12, n_name#13, n_regionkey#14]

(36) FileSourceScanExecTransformer parquet spark_catalog.default.region
Output [2]: [r_regionkey#15, r_name#16]
Batched: true
Location: InMemoryFileIndex [{warehouse_dir}/region]
PushedFilters: [IsNotNull(r_name), EqualTo(r_name,ASIA), IsNotNull(r_regionkey)]
ReadSchema: struct<r_regionkey:bigint,r_name:string>

(37) FilterExecTransformer
Input [2]: [r_regionkey#15, r_name#16]
Arguments: ((isnotnull(r_name#16) AND (r_name#16 = ASIA)) AND isnotnull(r_regionkey#15))

(38) ProjectExecTransformer
Output [1]: [r_regionkey#15]
Input [2]: [r_regionkey#15, r_name#16]

(39) WholeStageCodegenTransformer (5)
Input [1]: [r_regionkey#15]
Arguments: false

(40) ColumnarBroadcastExchange
Input [1]: [r_regionkey#15]
Arguments: HashedRelationBroadcastMode(List(input[0, bigint, true]),false), [plan_id=5]

(41) InputAdapter
Input [1]: [r_regionkey#15]

(42) InputIteratorTransformer
Input [1]: [r_regionkey#15]

(43) BroadcastHashJoinExecTransformer
Left keys [1]: [n_regionkey#14]
Right keys [1]: [r_regionkey#15]
Join type: Inner
Join condition: None

(44) ProjectExecTransformer
Output [2]: [n_name#13, (l_extendedprice#8 * (1 - l_discount#9)) AS _pre_1#17]
Input [5]: [l_extendedprice#8, l_discount#9, n_name#13, n_regionkey#14, r_regionkey#15]

(45) FlushableHashAggregateExecTransformer
Input [2]: [n_name#13, _pre_1#17]
Keys [1]: [n_name#13]
Functions [1]: [partial_sum(_pre_1#17)]
Aggregate Attributes [2]: [sum#18, isEmpty#19]
Results [3]: [n_name#13, sum#20, isEmpty#21]

(46) ProjectExecTransformer
Output [4]: [hash(n_name#13, 42) AS hash_partition_key#22, n_name#13, sum#20, isEmpty#21]
Input [3]: [n_name#13, sum#20, isEmpty#21]

(47) WholeStageCodegenTransformer (6)
Input [4]: [hash_partition_key#22, n_name#13, sum#20, isEmpty#21]
Arguments: false

(48) VeloxResizeBatches
Input [4]: [hash_partition_key#22, n_name#13, sum#20, isEmpty#21]
Arguments: 1024, 2147483647, 10485760

(49) ColumnarExchange
Input [4]: [hash_partition_key#22, n_name#13, sum#20, isEmpty#21]
Arguments: hashpartitioning(n_name#13, 1), ENSURE_REQUIREMENTS, [n_name#13, sum#20, isEmpty#21], [plan_id=6], [shuffle_writer_type=hash]

(50) InputAdapter
Input [3]: [n_name#13, sum#20, isEmpty#21]

(51) InputIteratorTransformer
Input [3]: [n_name#13, sum#20, isEmpty#21]

(52) RegularHashAggregateExecTransformer
Input [3]: [n_name#13, sum#20, isEmpty#21]
Keys [1]: [n_name#13]
Functions [1]: [sum((l_extendedprice#8 * (1 - l_discount#9)))]
Aggregate Attributes [1]: [sum((l_extendedprice#8 * (1 - l_discount#9)))#23]
Results [2]: [n_name#13, sum((l_extendedprice#8 * (1 - l_discount#9)))#23 AS revenue#24]

(53) WholeStageCodegenTransformer (7)
Input [2]: [n_name#13, revenue#24]
Arguments: false

(54) VeloxResizeBatches
Input [2]: [n_name#13, revenue#24]
Arguments: 1024, 2147483647, 10485760

(55) ColumnarExchange
Input [2]: [n_name#13, revenue#24]
Arguments: rangepartitioning(revenue#24 DESC NULLS LAST, 1), ENSURE_REQUIREMENTS, [plan_id=7], [shuffle_writer_type=hash]

(56) InputAdapter
Input [2]: [n_name#13, revenue#24]

(57) InputIteratorTransformer
Input [2]: [n_name#13, revenue#24]

(58) SortExecTransformer
Input [2]: [n_name#13, revenue#24]
Arguments: [revenue#24 DESC NULLS LAST], true, 0

(59) WholeStageCodegenTransformer (8)
Input [2]: [n_name#13, revenue#24]
Arguments: false

(60) VeloxColumnarToRow
Input [2]: [n_name#13, revenue#24]

