== Physical Plan ==
AdaptiveSparkPlan (112)
+- == Final Plan ==
   VeloxColumnarToRow (73)
   +- ^ SortExecTransformer (71)
      +- ^ InputIteratorTransformer (70)
         +- ShuffleQueryStage (68)
            +- ColumnarExchange (67)
               +- VeloxResizeBatches (66)
                  +- ^ ProjectExecTransformer (64)
                     +- ^ BroadcastHashJoinExecTransformer Inner BuildRight (63)
                        :- ^ ProjectExecTransformer (54)
                        :  +- ^ BroadcastHashJoinExecTransformer LeftSemi BuildRight (53)
                        :     :- ^ InputIteratorTransformer (10)
                        :     :  +- AQEShuffleRead (8)
                        :     :     +- ShuffleQueryStage (7)
                        :     :        +- ColumnarExchange (6)
                        :     :           +- VeloxResizeBatches (5)
                        :     :              +- ^ ProjectExecTransformer (3)
                        :     :                 +- ^ FilterExecTransformer (2)
                        :     :                    +- ^ ScanTransformer parquet  (1)
                        :     +- ^ InputIteratorTransformer (52)
                        :        +- BroadcastQueryStage (50)
                        :           +- ColumnarBroadcastExchange (49)
                        :              +- ^ ProjectExecTransformer (47)
                        :                 +- ^ BroadcastHashJoinExecTransformer Inner BuildLeft (46)
                        :                    :- ^ InputIteratorTransformer (26)
                        :                    :  +- BroadcastQueryStage (24)
                        :                    :     +- ColumnarBroadcastExchange (23)
                        :                    :        +- ^ BroadcastHashJoinExecTransformer LeftSemi BuildRight (21)
                        :                    :           :- ^ FilterExecTransformer (12)
                        :                    :           :  +- ^ ScanTransformer parquet  (11)
                        :                    :           +- ^ InputIteratorTransformer (20)
                        :                    :              +- BroadcastQueryStage (18)
                        :                    :                 +- ColumnarBroadcastExchange (17)
                        :                    :                    +- ^ ProjectExecTransformer (15)
                        :                    :                       +- ^ FilterExecTransformer (14)
                        :                    :                          +- ^ ScanTransformer parquet  (13)
                        :                    +- ^ FilterExecTransformer (45)
                        :                       +- ^ ProjectExecTransformer (44)
                        :                          +- ^ RegularHashAggregateExecTransformer (43)
                        :                             +- ^ InputIteratorTransformer (42)
                        :                                +- ShuffleQueryStage (40)
                        :                                   +- ColumnarExchange (39)
                        :                                      +- VeloxResizeBatches (38)
                        :                                         +- ^ ProjectExecTransformer (36)
                        :                                            +- ^ FlushableHashAggregateExecTransformer (35)
                        :                                               +- ^ BroadcastHashJoinExecTransformer LeftSemi BuildRight (34)
                        :                                                  :- ^ ProjectExecTransformer (29)
                        :                                                  :  +- ^ FilterExecTransformer (28)
                        :                                                  :     +- ^ ScanTransformer parquet  (27)
                        :                                                  +- ^ InputIteratorTransformer (33)
                        :                                                     +- BroadcastQueryStage (31)
                        :                                                        +- ReusedExchange (30)
                        +- ^ InputIteratorTransformer (62)
                           +- BroadcastQueryStage (60)
                              +- ColumnarBroadcastExchange (59)
                                 +- ^ ProjectExecTransformer (57)
                                    +- ^ FilterExecTransformer (56)
                                       +- ^ ScanTransformer parquet  (55)
+- == Initial Plan ==
   Sort (111)
   +- Exchange (110)
      +- Project (109)
         +- BroadcastHashJoin Inner BuildRight (108)
            :- Project (103)
            :  +- SortMergeJoin LeftSemi (102)
            :     :- Sort (77)
            :     :  +- Exchange (76)
            :     :     +- Filter (75)
            :     :        +- Scan parquet (74)
            :     +- Sort (101)
            :        +- Exchange (100)
            :           +- Project (99)
            :              +- BroadcastHashJoin Inner BuildLeft (98)
            :                 :- BroadcastExchange (85)
            :                 :  +- BroadcastHashJoin LeftSemi BuildRight (84)
            :                 :     :- Filter (79)
            :                 :     :  +- Scan parquet (78)
            :                 :     +- BroadcastExchange (83)
            :                 :        +- Project (82)
            :                 :           +- Filter (81)
            :                 :              +- Scan parquet (80)
            :                 +- Filter (97)
            :                    +- HashAggregate (96)
            :                       +- Exchange (95)
            :                          +- HashAggregate (94)
            :                             +- BroadcastHashJoin LeftSemi BuildRight (93)
            :                                :- Project (88)
            :                                :  +- Filter (87)
            :                                :     +- Scan parquet (86)
            :                                +- BroadcastExchange (92)
            :                                   +- Project (91)
            :                                      +- Filter (90)
            :                                         +- Scan parquet (89)
            +- BroadcastExchange (107)
               +- Project (106)
                  +- Filter (105)
                     +- Scan parquet (104)


(1) ScanTransformer parquet 
Output [4]: [s_suppkey#X, s_name#X, s_address#X, s_nationkey#X]
Batched: true
Location: InMemoryFileIndex [*]
PushedFilters: [IsNotNull(s_nationkey)]
ReadSchema: struct<s_suppkey:bigint,s_name:string,s_address:string,s_nationkey:bigint>

(2) FilterExecTransformer
Input [4]: [s_suppkey#X, s_name#X, s_address#X, s_nationkey#X]
Arguments: isnotnull(s_nationkey#X)

(3) ProjectExecTransformer
Output [5]: [hash(s_suppkey#X, 42) AS hash_partition_key#X, s_suppkey#X, s_name#X, s_address#X, s_nationkey#X]
Input [4]: [s_suppkey#X, s_name#X, s_address#X, s_nationkey#X]

(4) WholeStageCodegenTransformer (X)
Input [5]: [hash_partition_key#X, s_suppkey#X, s_name#X, s_address#X, s_nationkey#X]
Arguments: false

(5) VeloxResizeBatches
Input [5]: [hash_partition_key#X, s_suppkey#X, s_name#X, s_address#X, s_nationkey#X]
Arguments: X, X

(6) ColumnarExchange
Input [5]: [hash_partition_key#X, s_suppkey#X, s_name#X, s_address#X, s_nationkey#X]
Arguments: hashpartitioning(s_suppkey#X, 1), ENSURE_REQUIREMENTS, [s_suppkey#X, s_name#X, s_address#X, s_nationkey#X], [plan_id=X], [shuffle_writer_type=hash]

(7) ShuffleQueryStage
Output [4]: [s_suppkey#X, s_name#X, s_address#X, s_nationkey#X]
Arguments: X

(8) AQEShuffleRead
Input [4]: [s_suppkey#X, s_name#X, s_address#X, s_nationkey#X]
Arguments: local

(9) InputAdapter
Input [4]: [s_suppkey#X, s_name#X, s_address#X, s_nationkey#X]

(10) InputIteratorTransformer
Input [4]: [s_suppkey#X, s_name#X, s_address#X, s_nationkey#X]

(11) ScanTransformer parquet 
Output [3]: [ps_partkey#X, ps_suppkey#X, ps_availqty#X]
Batched: true
Location: InMemoryFileIndex [*]
PushedFilters: [IsNotNull(ps_availqty), IsNotNull(ps_partkey), IsNotNull(ps_suppkey)]
ReadSchema: struct<ps_partkey:bigint,ps_suppkey:bigint,ps_availqty:int>

(12) FilterExecTransformer
Input [3]: [ps_partkey#X, ps_suppkey#X, ps_availqty#X]
Arguments: ((isnotnull(ps_availqty#X) AND isnotnull(ps_partkey#X)) AND isnotnull(ps_suppkey#X))

(13) ScanTransformer parquet 
Output [2]: [p_partkey#X, p_name#X]
Batched: true
Location: InMemoryFileIndex [*]
PushedFilters: [IsNotNull(p_name), StringStartsWith(p_name,forest)]
ReadSchema: struct<p_partkey:bigint,p_name:string>

(14) FilterExecTransformer
Input [2]: [p_partkey#X, p_name#X]
Arguments: (isnotnull(p_name#X) AND StartsWith(p_name#X, forest))

(15) ProjectExecTransformer
Output [1]: [p_partkey#X]
Input [2]: [p_partkey#X, p_name#X]

(16) WholeStageCodegenTransformer (X)
Input [1]: [p_partkey#X]
Arguments: false

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

(18) BroadcastQueryStage
Output [1]: [p_partkey#X]
Arguments: X

(19) InputAdapter
Input [1]: [p_partkey#X]

(20) InputIteratorTransformer
Input [1]: [p_partkey#X]

(21) BroadcastHashJoinExecTransformer
Left keys [1]: [ps_partkey#X]
Right keys [1]: [p_partkey#X]
Join condition: None

(22) WholeStageCodegenTransformer (X)
Input [3]: [ps_partkey#X, ps_suppkey#X, ps_availqty#X]
Arguments: false

(23) ColumnarBroadcastExchange
Input [3]: [ps_partkey#X, ps_suppkey#X, ps_availqty#X]
Arguments: HashedRelationBroadcastMode(List(input[0, bigint, false], input[1, bigint, false]),false), [plan_id=X]

(24) BroadcastQueryStage
Output [3]: [ps_partkey#X, ps_suppkey#X, ps_availqty#X]
Arguments: X

(25) InputAdapter
Input [3]: [ps_partkey#X, ps_suppkey#X, ps_availqty#X]

(26) InputIteratorTransformer
Input [3]: [ps_partkey#X, ps_suppkey#X, ps_availqty#X]

(27) ScanTransformer parquet 
Output [4]: [l_partkey#X, l_suppkey#X, l_quantity#X, l_shipdate#X]
Batched: true
Location: InMemoryFileIndex [*]
PushedFilters: [IsNotNull(l_shipdate), GreaterThanOrEqual(l_shipdate,1994-01-01), LessThan(l_shipdate,1995-01-01), IsNotNull(l_partkey), IsNotNull(l_suppkey)]
ReadSchema: struct<l_partkey:bigint,l_suppkey:bigint,l_quantity:decimal(12,2),l_shipdate:date>

(28) FilterExecTransformer
Input [4]: [l_partkey#X, l_suppkey#X, l_quantity#X, l_shipdate#X]
Arguments: ((((isnotnull(l_shipdate#X) AND (l_shipdate#X >= 1994-01-01)) AND (l_shipdate#X < 1995-01-01)) AND isnotnull(l_partkey#X)) AND isnotnull(l_suppkey#X))

(29) ProjectExecTransformer
Output [3]: [l_partkey#X, l_suppkey#X, l_quantity#X]
Input [4]: [l_partkey#X, l_suppkey#X, l_quantity#X, l_shipdate#X]

(30) ReusedExchange [Reuses operator id: 17]
Output [1]: [p_partkey#X]

(31) BroadcastQueryStage
Output [1]: [p_partkey#X]
Arguments: X

(32) InputAdapter
Input [1]: [p_partkey#X]

(33) InputIteratorTransformer
Input [1]: [p_partkey#X]

(34) BroadcastHashJoinExecTransformer
Left keys [1]: [l_partkey#X]
Right keys [1]: [p_partkey#X]
Join condition: None

(35) FlushableHashAggregateExecTransformer
Input [3]: [l_partkey#X, l_suppkey#X, l_quantity#X]
Keys [2]: [l_partkey#X, l_suppkey#X]
Functions [1]: [partial_sum(l_quantity#X)]
Aggregate Attributes [2]: [sum#X, isEmpty#X]
Results [4]: [l_partkey#X, l_suppkey#X, sum#X, isEmpty#X]

(36) ProjectExecTransformer
Output [5]: [hash(l_partkey#X, l_suppkey#X, 42) AS hash_partition_key#X, l_partkey#X, l_suppkey#X, sum#X, isEmpty#X]
Input [4]: [l_partkey#X, l_suppkey#X, sum#X, isEmpty#X]

(37) WholeStageCodegenTransformer (X)
Input [5]: [hash_partition_key#X, l_partkey#X, l_suppkey#X, sum#X, isEmpty#X]
Arguments: false

(38) VeloxResizeBatches
Input [5]: [hash_partition_key#X, l_partkey#X, l_suppkey#X, sum#X, isEmpty#X]
Arguments: X, X

(39) ColumnarExchange
Input [5]: [hash_partition_key#X, l_partkey#X, l_suppkey#X, sum#X, isEmpty#X]
Arguments: hashpartitioning(l_partkey#X, l_suppkey#X, 1), ENSURE_REQUIREMENTS, [l_partkey#X, l_suppkey#X, sum#X, isEmpty#X], [plan_id=X], [shuffle_writer_type=hash]

(40) ShuffleQueryStage
Output [4]: [l_partkey#X, l_suppkey#X, sum#X, isEmpty#X]
Arguments: X

(41) InputAdapter
Input [4]: [l_partkey#X, l_suppkey#X, sum#X, isEmpty#X]

(42) InputIteratorTransformer
Input [4]: [l_partkey#X, l_suppkey#X, sum#X, isEmpty#X]

(43) RegularHashAggregateExecTransformer
Input [4]: [l_partkey#X, l_suppkey#X, sum#X, isEmpty#X]
Keys [2]: [l_partkey#X, l_suppkey#X]
Functions [1]: [sum(l_quantity#X)]
Aggregate Attributes [1]: [sum(l_quantity#X)#X]
Results [3]: [l_partkey#X, l_suppkey#X, sum(l_quantity#X)#X]

(44) ProjectExecTransformer
Output [3]: [CheckOverflow((0.50 * promote_precision(sum(l_quantity#X)#X)), DecimalType(24,3), true) AS (0.5 * sum(l_quantity))#X, l_partkey#X, l_suppkey#X]
Input [3]: [l_partkey#X, l_suppkey#X, sum(l_quantity#X)#X]

(45) FilterExecTransformer
Input [3]: [(0.5 * sum(l_quantity))#X, l_partkey#X, l_suppkey#X]
Arguments: isnotnull((0.5 * sum(l_quantity))#X)

(46) BroadcastHashJoinExecTransformer
Left keys [2]: [ps_partkey#X, ps_suppkey#X]
Right keys [2]: [l_partkey#X, l_suppkey#X]
Join condition: (cast(cast(ps_availqty#X as decimal(10,0)) as decimal(24,3)) > (0.5 * sum(l_quantity))#X)

(47) ProjectExecTransformer
Output [1]: [ps_suppkey#X]
Input [6]: [ps_partkey#X, ps_suppkey#X, ps_availqty#X, (0.5 * sum(l_quantity))#X, l_partkey#X, l_suppkey#X]

(48) WholeStageCodegenTransformer (X)
Input [1]: [ps_suppkey#X]
Arguments: false

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

(50) BroadcastQueryStage
Output [1]: [ps_suppkey#X]
Arguments: X

(51) InputAdapter
Input [1]: [ps_suppkey#X]

(52) InputIteratorTransformer
Input [1]: [ps_suppkey#X]

(53) BroadcastHashJoinExecTransformer
Left keys [1]: [s_suppkey#X]
Right keys [1]: [ps_suppkey#X]
Join condition: None

(54) ProjectExecTransformer
Output [3]: [s_name#X, s_address#X, s_nationkey#X]
Input [4]: [s_suppkey#X, s_name#X, s_address#X, s_nationkey#X]

(55) ScanTransformer parquet 
Output [2]: [n_nationkey#X, n_name#X]
Batched: true
Location: InMemoryFileIndex [*]
PushedFilters: [IsNotNull(n_name), EqualTo(n_name,CANADA), IsNotNull(n_nationkey)]
ReadSchema: struct<n_nationkey:bigint,n_name:string>

(56) FilterExecTransformer
Input [2]: [n_nationkey#X, n_name#X]
Arguments: ((isnotnull(n_name#X) AND (n_name#X = CANADA)) AND isnotnull(n_nationkey#X))

(57) ProjectExecTransformer
Output [1]: [n_nationkey#X]
Input [2]: [n_nationkey#X, n_name#X]

(58) WholeStageCodegenTransformer (X)
Input [1]: [n_nationkey#X]
Arguments: false

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

(60) BroadcastQueryStage
Output [1]: [n_nationkey#X]
Arguments: X

(61) InputAdapter
Input [1]: [n_nationkey#X]

(62) InputIteratorTransformer
Input [1]: [n_nationkey#X]

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

(64) ProjectExecTransformer
Output [2]: [s_name#X, s_address#X]
Input [4]: [s_name#X, s_address#X, s_nationkey#X, n_nationkey#X]

(65) WholeStageCodegenTransformer (X)
Input [2]: [s_name#X, s_address#X]
Arguments: false

(66) VeloxResizeBatches
Input [2]: [s_name#X, s_address#X]
Arguments: X, X

(67) ColumnarExchange
Input [2]: [s_name#X, s_address#X]
Arguments: rangepartitioning(s_name#X ASC NULLS FIRST, 1), ENSURE_REQUIREMENTS, [plan_id=X], [shuffle_writer_type=hash]

(68) ShuffleQueryStage
Output [2]: [s_name#X, s_address#X]
Arguments: X

(69) InputAdapter
Input [2]: [s_name#X, s_address#X]

(70) InputIteratorTransformer
Input [2]: [s_name#X, s_address#X]

(71) SortExecTransformer
Input [2]: [s_name#X, s_address#X]
Arguments: [s_name#X ASC NULLS FIRST], true, 0

(72) WholeStageCodegenTransformer (X)
Input [2]: [s_name#X, s_address#X]
Arguments: false

(73) VeloxColumnarToRow
Input [2]: [s_name#X, s_address#X]

(74) Scan parquet
Output [4]: [s_suppkey#X, s_name#X, s_address#X, s_nationkey#X]
Batched: true
Location: InMemoryFileIndex [*]
PushedFilters: [IsNotNull(s_nationkey)]
ReadSchema: struct<s_suppkey:bigint,s_name:string,s_address:string,s_nationkey:bigint>

(75) Filter
Input [4]: [s_suppkey#X, s_name#X, s_address#X, s_nationkey#X]
Condition : isnotnull(s_nationkey#X)

(76) Exchange
Input [4]: [s_suppkey#X, s_name#X, s_address#X, s_nationkey#X]
Arguments: hashpartitioning(s_suppkey#X, 1), ENSURE_REQUIREMENTS, [plan_id=X]

(77) Sort
Input [4]: [s_suppkey#X, s_name#X, s_address#X, s_nationkey#X]
Arguments: [s_suppkey#X ASC NULLS FIRST], false, 0

(78) Scan parquet
Output [3]: [ps_partkey#X, ps_suppkey#X, ps_availqty#X]
Batched: true
Location: InMemoryFileIndex [*]
PushedFilters: [IsNotNull(ps_availqty), IsNotNull(ps_partkey), IsNotNull(ps_suppkey)]
ReadSchema: struct<ps_partkey:bigint,ps_suppkey:bigint,ps_availqty:int>

(79) Filter
Input [3]: [ps_partkey#X, ps_suppkey#X, ps_availqty#X]
Condition : ((isnotnull(ps_availqty#X) AND isnotnull(ps_partkey#X)) AND isnotnull(ps_suppkey#X))

(80) Scan parquet
Output [2]: [p_partkey#X, p_name#X]
Batched: true
Location: InMemoryFileIndex [*]
PushedFilters: [IsNotNull(p_name), StringStartsWith(p_name,forest)]
ReadSchema: struct<p_partkey:bigint,p_name:string>

(81) Filter
Input [2]: [p_partkey#X, p_name#X]
Condition : (isnotnull(p_name#X) AND StartsWith(p_name#X, forest))

(82) Project
Output [1]: [p_partkey#X]
Input [2]: [p_partkey#X, p_name#X]

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

(84) BroadcastHashJoin
Left keys [1]: [ps_partkey#X]
Right keys [1]: [p_partkey#X]
Join condition: None

(85) BroadcastExchange
Input [3]: [ps_partkey#X, ps_suppkey#X, ps_availqty#X]
Arguments: HashedRelationBroadcastMode(List(input[0, bigint, false], input[1, bigint, false]),false), [plan_id=X]

(86) Scan parquet
Output [4]: [l_partkey#X, l_suppkey#X, l_quantity#X, l_shipdate#X]
Batched: true
Location: InMemoryFileIndex [*]
PushedFilters: [IsNotNull(l_shipdate), GreaterThanOrEqual(l_shipdate,1994-01-01), LessThan(l_shipdate,1995-01-01), IsNotNull(l_partkey), IsNotNull(l_suppkey)]
ReadSchema: struct<l_partkey:bigint,l_suppkey:bigint,l_quantity:decimal(12,2),l_shipdate:date>

(87) Filter
Input [4]: [l_partkey#X, l_suppkey#X, l_quantity#X, l_shipdate#X]
Condition : ((((isnotnull(l_shipdate#X) AND (l_shipdate#X >= 1994-01-01)) AND (l_shipdate#X < 1995-01-01)) AND isnotnull(l_partkey#X)) AND isnotnull(l_suppkey#X))

(88) Project
Output [3]: [l_partkey#X, l_suppkey#X, l_quantity#X]
Input [4]: [l_partkey#X, l_suppkey#X, l_quantity#X, l_shipdate#X]

(89) Scan parquet
Output [2]: [p_partkey#X, p_name#X]
Batched: true
Location: InMemoryFileIndex [*]
PushedFilters: [IsNotNull(p_name), StringStartsWith(p_name,forest)]
ReadSchema: struct<p_partkey:bigint,p_name:string>

(90) Filter
Input [2]: [p_partkey#X, p_name#X]
Condition : (isnotnull(p_name#X) AND StartsWith(p_name#X, forest))

(91) Project
Output [1]: [p_partkey#X]
Input [2]: [p_partkey#X, p_name#X]

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

(93) BroadcastHashJoin
Left keys [1]: [l_partkey#X]
Right keys [1]: [p_partkey#X]
Join condition: None

(94) HashAggregate
Input [3]: [l_partkey#X, l_suppkey#X, l_quantity#X]
Keys [2]: [l_partkey#X, l_suppkey#X]
Functions [1]: [partial_sum(l_quantity#X)]
Aggregate Attributes [2]: [sum#X, isEmpty#X]
Results [4]: [l_partkey#X, l_suppkey#X, sum#X, isEmpty#X]

(95) Exchange
Input [4]: [l_partkey#X, l_suppkey#X, sum#X, isEmpty#X]
Arguments: hashpartitioning(l_partkey#X, l_suppkey#X, 1), ENSURE_REQUIREMENTS, [plan_id=X]

(96) HashAggregate
Input [4]: [l_partkey#X, l_suppkey#X, sum#X, isEmpty#X]
Keys [2]: [l_partkey#X, l_suppkey#X]
Functions [1]: [sum(l_quantity#X)]
Aggregate Attributes [1]: [sum(l_quantity#X)#X]
Results [3]: [CheckOverflow((0.50 * promote_precision(sum(l_quantity#X)#X)), DecimalType(24,3), true) AS (0.5 * sum(l_quantity))#X, l_partkey#X, l_suppkey#X]

(97) Filter
Input [3]: [(0.5 * sum(l_quantity))#X, l_partkey#X, l_suppkey#X]
Condition : isnotnull((0.5 * sum(l_quantity))#X)

(98) BroadcastHashJoin
Left keys [2]: [ps_partkey#X, ps_suppkey#X]
Right keys [2]: [l_partkey#X, l_suppkey#X]
Join condition: (cast(cast(ps_availqty#X as decimal(10,0)) as decimal(24,3)) > (0.5 * sum(l_quantity))#X)

(99) Project
Output [1]: [ps_suppkey#X]
Input [6]: [ps_partkey#X, ps_suppkey#X, ps_availqty#X, (0.5 * sum(l_quantity))#X, l_partkey#X, l_suppkey#X]

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

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

(102) SortMergeJoin
Left keys [1]: [s_suppkey#X]
Right keys [1]: [ps_suppkey#X]
Join condition: None

(103) Project
Output [3]: [s_name#X, s_address#X, s_nationkey#X]
Input [4]: [s_suppkey#X, s_name#X, s_address#X, s_nationkey#X]

(104) Scan parquet
Output [2]: [n_nationkey#X, n_name#X]
Batched: true
Location: InMemoryFileIndex [*]
PushedFilters: [IsNotNull(n_name), EqualTo(n_name,CANADA), IsNotNull(n_nationkey)]
ReadSchema: struct<n_nationkey:bigint,n_name:string>

(105) Filter
Input [2]: [n_nationkey#X, n_name#X]
Condition : ((isnotnull(n_name#X) AND (n_name#X = CANADA)) AND isnotnull(n_nationkey#X))

(106) Project
Output [1]: [n_nationkey#X]
Input [2]: [n_nationkey#X, n_name#X]

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

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

(109) Project
Output [2]: [s_name#X, s_address#X]
Input [4]: [s_name#X, s_address#X, s_nationkey#X, n_nationkey#X]

(110) Exchange
Input [2]: [s_name#X, s_address#X]
Arguments: rangepartitioning(s_name#X ASC NULLS FIRST, 1), ENSURE_REQUIREMENTS, [plan_id=X]

(111) Sort
Input [2]: [s_name#X, s_address#X]
Arguments: [s_name#X ASC NULLS FIRST], true, 0

(112) AdaptiveSparkPlan
Output [2]: [s_name#X, s_address#X]
Arguments: isFinalPlan=true