== Physical Plan ==
AdaptiveSparkPlan (102)
+- == Final Plan ==
   VeloxColumnarToRowExec (67)
   +- ^ SortExecTransformer (65)
      +- ^ InputIteratorTransformer (64)
         +- ShuffleQueryStage (62), Statistics(X)
            +- ColumnarExchange (61)
               +- VeloxAppendBatches (60)
                  +- ^ RegularHashAggregateExecTransformer (58)
                     +- ^ InputIteratorTransformer (57)
                        +- ShuffleQueryStage (55), Statistics(X)
                           +- ColumnarExchange (54)
                              +- VeloxAppendBatches (53)
                                 +- ^ ProjectExecTransformer (51)
                                    +- ^ FlushableHashAggregateExecTransformer (50)
                                       +- ^ ProjectExecTransformer (49)
                                          +- ^ BroadcastHashJoinExecTransformer Inner BuildRight (48)
                                             :- ^ ProjectExecTransformer (39)
                                             :  +- ^ BroadcastHashJoinExecTransformer Inner BuildRight (38)
                                             :     :- ^ ProjectExecTransformer (30)
                                             :     :  +- ^ BroadcastHashJoinExecTransformer Inner BuildRight (29)
                                             :     :     :- ^ ProjectExecTransformer (21)
                                             :     :     :  +- ^ BroadcastHashJoinExecTransformer Inner BuildRight (20)
                                             :     :     :     :- ^ ProjectExecTransformer (12)
                                             :     :     :     :  +- ^ BroadcastHashJoinExecTransformer Inner BuildLeft (11)
                                             :     :     :     :     :- ^ InputIteratorTransformer (7)
                                             :     :     :     :     :  +- BroadcastQueryStage (5), Statistics(X)
                                             :     :     :     :     :     +- ColumnarBroadcastExchange (4)
                                             :     :     :     :     :        +- ^ NoopFilter (2)
                                             :     :     :     :     :           +- ^ Scan parquet (1)
                                             :     :     :     :     +- ^ ProjectExecTransformer (10)
                                             :     :     :     :        +- ^ NoopFilter (9)
                                             :     :     :     :           +- ^ Scan parquet (8)
                                             :     :     :     +- ^ InputIteratorTransformer (19)
                                             :     :     :        +- BroadcastQueryStage (17), Statistics(X)
                                             :     :     :           +- ColumnarBroadcastExchange (16)
                                             :     :     :              +- ^ NoopFilter (14)
                                             :     :     :                 +- ^ Scan parquet (13)
                                             :     :     +- ^ InputIteratorTransformer (28)
                                             :     :        +- BroadcastQueryStage (26), Statistics(X)
                                             :     :           +- ColumnarBroadcastExchange (25)
                                             :     :              +- ^ NoopFilter (23)
                                             :     :                 +- ^ Scan parquet (22)
                                             :     +- ^ InputIteratorTransformer (37)
                                             :        +- BroadcastQueryStage (35), Statistics(X)
                                             :           +- ColumnarBroadcastExchange (34)
                                             :              +- ^ NoopFilter (32)
                                             :                 +- ^ Scan parquet (31)
                                             +- ^ InputIteratorTransformer (47)
                                                +- BroadcastQueryStage (45), Statistics(X)
                                                   +- ColumnarBroadcastExchange (44)
                                                      +- ^ ProjectExecTransformer (42)
                                                         +- ^ NoopFilter (41)
                                                            +- ^ Scan parquet (40)
+- == Initial Plan ==
   Sort (101)
   +- Exchange (100)
      +- HashAggregate (99)
         +- Exchange (98)
            +- HashAggregate (97)
               +- Project (96)
                  +- BroadcastHashJoin Inner BuildRight (95)
                     :- Project (90)
                     :  +- BroadcastHashJoin Inner BuildRight (89)
                     :     :- Project (85)
                     :     :  +- BroadcastHashJoin Inner BuildRight (84)
                     :     :     :- Project (80)
                     :     :     :  +- BroadcastHashJoin Inner BuildRight (79)
                     :     :     :     :- Project (75)
                     :     :     :     :  +- BroadcastHashJoin Inner BuildLeft (74)
                     :     :     :     :     :- BroadcastExchange (70)
                     :     :     :     :     :  +- Filter (69)
                     :     :     :     :     :     +- Scan parquet (68)
                     :     :     :     :     +- Project (73)
                     :     :     :     :        +- Filter (72)
                     :     :     :     :           +- Scan parquet (71)
                     :     :     :     +- BroadcastExchange (78)
                     :     :     :        +- Filter (77)
                     :     :     :           +- Scan parquet (76)
                     :     :     +- BroadcastExchange (83)
                     :     :        +- Filter (82)
                     :     :           +- Scan parquet (81)
                     :     +- BroadcastExchange (88)
                     :        +- Filter (87)
                     :           +- Scan parquet (86)
                     +- BroadcastExchange (94)
                        +- Project (93)
                           +- Filter (92)
                              +- Scan parquet (91)


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

(2) NoopFilter
Input [2]: [c_custkey#X, c_nationkey#X]
Arguments: [c_custkey#X, c_nationkey#X]

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

(4) ColumnarBroadcastExchange
Input [2]: [c_custkey#X, c_nationkey#X]
Arguments: HashedRelationBroadcastMode(List(input[0, bigint, false]),false), [plan_id=X]

(5) BroadcastQueryStage
Output [2]: [c_custkey#X, c_nationkey#X]
Arguments: X

(6) InputAdapter
Input [2]: [c_custkey#X, c_nationkey#X]

(7) InputIteratorTransformer
Input [2]: [c_custkey#X, c_nationkey#X]

(8) Scan parquet
Output [3]: [o_orderkey#X, o_custkey#X, o_orderdate#X]
Batched: true
Location: InMemoryFileIndex [*]
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>

(9) NoopFilter
Input [3]: [o_orderkey#X, o_custkey#X, o_orderdate#X]
Arguments: [o_orderkey#X, o_custkey#X, o_orderdate#X]

(10) ProjectExecTransformer
Output [2]: [o_orderkey#X, o_custkey#X]
Input [3]: [o_orderkey#X, o_custkey#X, o_orderdate#X]

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

(12) ProjectExecTransformer
Output [2]: [c_nationkey#X, o_orderkey#X]
Input [4]: [c_custkey#X, c_nationkey#X, o_orderkey#X, o_custkey#X]

(13) Scan parquet
Output [4]: [l_orderkey#X, l_suppkey#X, l_extendedprice#X, l_discount#X]
Batched: true
Location: InMemoryFileIndex [*]
PushedFilters: [IsNotNull(l_orderkey), IsNotNull(l_suppkey)]
ReadSchema: struct<l_orderkey:bigint,l_suppkey:bigint,l_extendedprice:decimal(12,2),l_discount:decimal(12,2)>

(14) NoopFilter
Input [4]: [l_orderkey#X, l_suppkey#X, l_extendedprice#X, l_discount#X]
Arguments: [l_orderkey#X, l_suppkey#X, l_extendedprice#X, l_discount#X]

(15) WholeStageCodegenTransformer (X)
Input [4]: [l_orderkey#X, l_suppkey#X, l_extendedprice#X, l_discount#X]
Arguments: false

(16) ColumnarBroadcastExchange
Input [4]: [l_orderkey#X, l_suppkey#X, l_extendedprice#X, l_discount#X]
Arguments: HashedRelationBroadcastMode(List(input[0, bigint, false]),false), [plan_id=X]

(17) BroadcastQueryStage
Output [4]: [l_orderkey#X, l_suppkey#X, l_extendedprice#X, l_discount#X]
Arguments: X

(18) InputAdapter
Input [4]: [l_orderkey#X, l_suppkey#X, l_extendedprice#X, l_discount#X]

(19) InputIteratorTransformer
Input [4]: [l_orderkey#X, l_suppkey#X, l_extendedprice#X, l_discount#X]

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

(21) ProjectExecTransformer
Output [4]: [c_nationkey#X, l_suppkey#X, l_extendedprice#X, l_discount#X]
Input [6]: [c_nationkey#X, o_orderkey#X, l_orderkey#X, l_suppkey#X, l_extendedprice#X, l_discount#X]

(22) Scan parquet
Output [2]: [s_suppkey#X, s_nationkey#X]
Batched: true
Location: InMemoryFileIndex [*]
PushedFilters: [IsNotNull(s_suppkey), IsNotNull(s_nationkey)]
ReadSchema: struct<s_suppkey:bigint,s_nationkey:bigint>

(23) NoopFilter
Input [2]: [s_suppkey#X, s_nationkey#X]
Arguments: [s_suppkey#X, s_nationkey#X]

(24) WholeStageCodegenTransformer (X)
Input [2]: [s_suppkey#X, s_nationkey#X]
Arguments: false

(25) ColumnarBroadcastExchange
Input [2]: [s_suppkey#X, s_nationkey#X]
Arguments: HashedRelationBroadcastMode(List(input[0, bigint, false], input[1, bigint, false]),false), [plan_id=X]

(26) BroadcastQueryStage
Output [2]: [s_suppkey#X, s_nationkey#X]
Arguments: X

(27) InputAdapter
Input [2]: [s_suppkey#X, s_nationkey#X]

(28) InputIteratorTransformer
Input [2]: [s_suppkey#X, s_nationkey#X]

(29) BroadcastHashJoinExecTransformer
Left keys [2]: [l_suppkey#X, c_nationkey#X]
Right keys [2]: [s_suppkey#X, s_nationkey#X]
Join type: Inner
Join condition: None

(30) ProjectExecTransformer
Output [3]: [l_extendedprice#X, l_discount#X, s_nationkey#X]
Input [6]: [c_nationkey#X, l_suppkey#X, l_extendedprice#X, l_discount#X, s_suppkey#X, s_nationkey#X]

(31) Scan parquet
Output [3]: [n_nationkey#X, n_name#X, n_regionkey#X]
Batched: true
Location: InMemoryFileIndex [*]
PushedFilters: [IsNotNull(n_nationkey), IsNotNull(n_regionkey)]
ReadSchema: struct<n_nationkey:bigint,n_name:string,n_regionkey:bigint>

(32) NoopFilter
Input [3]: [n_nationkey#X, n_name#X, n_regionkey#X]
Arguments: [n_nationkey#X, n_name#X, n_regionkey#X]

(33) WholeStageCodegenTransformer (X)
Input [3]: [n_nationkey#X, n_name#X, n_regionkey#X]
Arguments: false

(34) ColumnarBroadcastExchange
Input [3]: [n_nationkey#X, n_name#X, n_regionkey#X]
Arguments: HashedRelationBroadcastMode(List(input[0, bigint, false]),false), [plan_id=X]

(35) BroadcastQueryStage
Output [3]: [n_nationkey#X, n_name#X, n_regionkey#X]
Arguments: X

(36) InputAdapter
Input [3]: [n_nationkey#X, n_name#X, n_regionkey#X]

(37) InputIteratorTransformer
Input [3]: [n_nationkey#X, n_name#X, n_regionkey#X]

(38) BroadcastHashJoinExecTransformer
Left keys [1]: [s_nationkey#X]
Right keys [1]: [n_nationkey#X]
Join type: Inner
Join condition: None

(39) ProjectExecTransformer
Output [4]: [l_extendedprice#X, l_discount#X, n_name#X, n_regionkey#X]
Input [6]: [l_extendedprice#X, l_discount#X, s_nationkey#X, n_nationkey#X, n_name#X, n_regionkey#X]

(40) Scan parquet
Output [2]: [r_regionkey#X, r_name#X]
Batched: true
Location: InMemoryFileIndex [*]
PushedFilters: [IsNotNull(r_name), EqualTo(r_name,ASIA), IsNotNull(r_regionkey)]
ReadSchema: struct<r_regionkey:bigint,r_name:string>

(41) NoopFilter
Input [2]: [r_regionkey#X, r_name#X]
Arguments: [r_regionkey#X, r_name#X]

(42) ProjectExecTransformer
Output [1]: [r_regionkey#X]
Input [2]: [r_regionkey#X, r_name#X]

(43) WholeStageCodegenTransformer (X)
Input [1]: [r_regionkey#X]
Arguments: false

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

(45) BroadcastQueryStage
Output [1]: [r_regionkey#X]
Arguments: X

(46) InputAdapter
Input [1]: [r_regionkey#X]

(47) InputIteratorTransformer
Input [1]: [r_regionkey#X]

(48) BroadcastHashJoinExecTransformer
Left keys [1]: [n_regionkey#X]
Right keys [1]: [r_regionkey#X]
Join type: Inner
Join condition: None

(49) ProjectExecTransformer
Output [4]: [l_extendedprice#X, l_discount#X, n_name#X, (l_extendedprice#X * (1 - l_discount#X)) AS _pre_X#X]
Input [5]: [l_extendedprice#X, l_discount#X, n_name#X, n_regionkey#X, r_regionkey#X]

(50) FlushableHashAggregateExecTransformer
Input [4]: [l_extendedprice#X, l_discount#X, n_name#X, _pre_X#X]
Keys [1]: [n_name#X]
Functions [1]: [partial_sum(_pre_X#X)]
Aggregate Attributes [2]: [sum#X, isEmpty#X]
Results [3]: [n_name#X, sum#X, isEmpty#X]

(51) ProjectExecTransformer
Output [4]: [hash(n_name#X, 42) AS hash_partition_key#X, n_name#X, sum#X, isEmpty#X]
Input [3]: [n_name#X, sum#X, isEmpty#X]

(52) WholeStageCodegenTransformer (X)
Input [4]: [hash_partition_key#X, n_name#X, sum#X, isEmpty#X]
Arguments: false

(53) VeloxAppendBatches
Input [4]: [hash_partition_key#X, n_name#X, sum#X, isEmpty#X]
Arguments: X

(54) ColumnarExchange
Input [4]: [hash_partition_key#X, n_name#X, sum#X, isEmpty#X]
Arguments: hashpartitioning(n_name#X, 1), ENSURE_REQUIREMENTS, [n_name#X, sum#X, isEmpty#X], [plan_id=X], [id=#X]

(55) ShuffleQueryStage
Output [3]: [n_name#X, sum#X, isEmpty#X]
Arguments: X

(56) InputAdapter
Input [3]: [n_name#X, sum#X, isEmpty#X]

(57) InputIteratorTransformer
Input [3]: [n_name#X, sum#X, isEmpty#X]

(58) RegularHashAggregateExecTransformer
Input [3]: [n_name#X, sum#X, isEmpty#X]
Keys [1]: [n_name#X]
Functions [1]: [sum((l_extendedprice#X * (1 - l_discount#X)))]
Aggregate Attributes [1]: [sum((l_extendedprice#X * (1 - l_discount#X)))#X]
Results [2]: [n_name#X, sum((l_extendedprice#X * (1 - l_discount#X)))#X AS revenue#X]

(59) WholeStageCodegenTransformer (X)
Input [2]: [n_name#X, revenue#X]
Arguments: false

(60) VeloxAppendBatches
Input [2]: [n_name#X, revenue#X]
Arguments: X

(61) ColumnarExchange
Input [2]: [n_name#X, revenue#X]
Arguments: rangepartitioning(revenue#X DESC NULLS LAST, 1), ENSURE_REQUIREMENTS, [plan_id=X], [id=#X]

(62) ShuffleQueryStage
Output [2]: [n_name#X, revenue#X]
Arguments: X

(63) InputAdapter
Input [2]: [n_name#X, revenue#X]

(64) InputIteratorTransformer
Input [2]: [n_name#X, revenue#X]

(65) SortExecTransformer
Input [2]: [n_name#X, revenue#X]
Arguments: [revenue#X DESC NULLS LAST], true, 0

(66) WholeStageCodegenTransformer (X)
Input [2]: [n_name#X, revenue#X]
Arguments: false

(67) VeloxColumnarToRowExec
Input [2]: [n_name#X, revenue#X]

(68) Scan parquet
Output [2]: [c_custkey#X, c_nationkey#X]
Batched: true
Location: InMemoryFileIndex [*]
PushedFilters: [IsNotNull(c_custkey), IsNotNull(c_nationkey)]
ReadSchema: struct<c_custkey:bigint,c_nationkey:bigint>

(69) Filter
Input [2]: [c_custkey#X, c_nationkey#X]
Condition : (isnotnull(c_custkey#X) AND isnotnull(c_nationkey#X))

(70) BroadcastExchange
Input [2]: [c_custkey#X, c_nationkey#X]
Arguments: HashedRelationBroadcastMode(List(input[0, bigint, false]),false), [plan_id=X]

(71) Scan parquet
Output [3]: [o_orderkey#X, o_custkey#X, o_orderdate#X]
Batched: true
Location: InMemoryFileIndex [*]
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>

(72) Filter
Input [3]: [o_orderkey#X, o_custkey#X, o_orderdate#X]
Condition : ((((isnotnull(o_orderdate#X) AND (o_orderdate#X >= 1994-01-01)) AND (o_orderdate#X < 1995-01-01)) AND isnotnull(o_custkey#X)) AND isnotnull(o_orderkey#X))

(73) Project
Output [2]: [o_orderkey#X, o_custkey#X]
Input [3]: [o_orderkey#X, o_custkey#X, o_orderdate#X]

(74) BroadcastHashJoin
Left keys [1]: [c_custkey#X]
Right keys [1]: [o_custkey#X]
Join type: Inner
Join condition: None

(75) Project
Output [2]: [c_nationkey#X, o_orderkey#X]
Input [4]: [c_custkey#X, c_nationkey#X, o_orderkey#X, o_custkey#X]

(76) Scan parquet
Output [4]: [l_orderkey#X, l_suppkey#X, l_extendedprice#X, l_discount#X]
Batched: true
Location: InMemoryFileIndex [*]
PushedFilters: [IsNotNull(l_orderkey), IsNotNull(l_suppkey)]
ReadSchema: struct<l_orderkey:bigint,l_suppkey:bigint,l_extendedprice:decimal(12,2),l_discount:decimal(12,2)>

(77) Filter
Input [4]: [l_orderkey#X, l_suppkey#X, l_extendedprice#X, l_discount#X]
Condition : (isnotnull(l_orderkey#X) AND isnotnull(l_suppkey#X))

(78) BroadcastExchange
Input [4]: [l_orderkey#X, l_suppkey#X, l_extendedprice#X, l_discount#X]
Arguments: HashedRelationBroadcastMode(List(input[0, bigint, false]),false), [plan_id=X]

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

(80) Project
Output [4]: [c_nationkey#X, l_suppkey#X, l_extendedprice#X, l_discount#X]
Input [6]: [c_nationkey#X, o_orderkey#X, l_orderkey#X, l_suppkey#X, l_extendedprice#X, l_discount#X]

(81) Scan parquet
Output [2]: [s_suppkey#X, s_nationkey#X]
Batched: true
Location: InMemoryFileIndex [*]
PushedFilters: [IsNotNull(s_suppkey), IsNotNull(s_nationkey)]
ReadSchema: struct<s_suppkey:bigint,s_nationkey:bigint>

(82) Filter
Input [2]: [s_suppkey#X, s_nationkey#X]
Condition : (isnotnull(s_suppkey#X) AND isnotnull(s_nationkey#X))

(83) BroadcastExchange
Input [2]: [s_suppkey#X, s_nationkey#X]
Arguments: HashedRelationBroadcastMode(List(input[0, bigint, false], input[1, bigint, false]),false), [plan_id=X]

(84) BroadcastHashJoin
Left keys [2]: [l_suppkey#X, c_nationkey#X]
Right keys [2]: [s_suppkey#X, s_nationkey#X]
Join type: Inner
Join condition: None

(85) Project
Output [3]: [l_extendedprice#X, l_discount#X, s_nationkey#X]
Input [6]: [c_nationkey#X, l_suppkey#X, l_extendedprice#X, l_discount#X, s_suppkey#X, s_nationkey#X]

(86) Scan parquet
Output [3]: [n_nationkey#X, n_name#X, n_regionkey#X]
Batched: true
Location: InMemoryFileIndex [*]
PushedFilters: [IsNotNull(n_nationkey), IsNotNull(n_regionkey)]
ReadSchema: struct<n_nationkey:bigint,n_name:string,n_regionkey:bigint>

(87) Filter
Input [3]: [n_nationkey#X, n_name#X, n_regionkey#X]
Condition : (isnotnull(n_nationkey#X) AND isnotnull(n_regionkey#X))

(88) BroadcastExchange
Input [3]: [n_nationkey#X, n_name#X, n_regionkey#X]
Arguments: HashedRelationBroadcastMode(List(input[0, bigint, false]),false), [plan_id=X]

(89) BroadcastHashJoin
Left keys [1]: [s_nationkey#X]
Right keys [1]: [n_nationkey#X]
Join type: Inner
Join condition: None

(90) Project
Output [4]: [l_extendedprice#X, l_discount#X, n_name#X, n_regionkey#X]
Input [6]: [l_extendedprice#X, l_discount#X, s_nationkey#X, n_nationkey#X, n_name#X, n_regionkey#X]

(91) Scan parquet
Output [2]: [r_regionkey#X, r_name#X]
Batched: true
Location: InMemoryFileIndex [*]
PushedFilters: [IsNotNull(r_name), EqualTo(r_name,ASIA), IsNotNull(r_regionkey)]
ReadSchema: struct<r_regionkey:bigint,r_name:string>

(92) Filter
Input [2]: [r_regionkey#X, r_name#X]
Condition : ((isnotnull(r_name#X) AND (r_name#X = ASIA)) AND isnotnull(r_regionkey#X))

(93) Project
Output [1]: [r_regionkey#X]
Input [2]: [r_regionkey#X, r_name#X]

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

(95) BroadcastHashJoin
Left keys [1]: [n_regionkey#X]
Right keys [1]: [r_regionkey#X]
Join type: Inner
Join condition: None

(96) Project
Output [3]: [l_extendedprice#X, l_discount#X, n_name#X]
Input [5]: [l_extendedprice#X, l_discount#X, n_name#X, n_regionkey#X, r_regionkey#X]

(97) HashAggregate
Input [3]: [l_extendedprice#X, l_discount#X, n_name#X]
Keys [1]: [n_name#X]
Functions [1]: [partial_sum((l_extendedprice#X * (1 - l_discount#X)))]
Aggregate Attributes [2]: [sum#X, isEmpty#X]
Results [3]: [n_name#X, sum#X, isEmpty#X]

(98) Exchange
Input [3]: [n_name#X, sum#X, isEmpty#X]
Arguments: hashpartitioning(n_name#X, 1), ENSURE_REQUIREMENTS, [plan_id=X]

(99) HashAggregate
Input [3]: [n_name#X, sum#X, isEmpty#X]
Keys [1]: [n_name#X]
Functions [1]: [sum((l_extendedprice#X * (1 - l_discount#X)))]
Aggregate Attributes [1]: [sum((l_extendedprice#X * (1 - l_discount#X)))#X]
Results [2]: [n_name#X, sum((l_extendedprice#X * (1 - l_discount#X)))#X AS revenue#X]

(100) Exchange
Input [2]: [n_name#X, revenue#X]
Arguments: rangepartitioning(revenue#X DESC NULLS LAST, 1), ENSURE_REQUIREMENTS, [plan_id=X]

(101) Sort
Input [2]: [n_name#X, revenue#X]
Arguments: [revenue#X DESC NULLS LAST], true, 0

(102) AdaptiveSparkPlan
Output [2]: [n_name#X, revenue#X]
Arguments: isFinalPlan=true