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


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

(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) VeloxAppendBatches
Input [5]: [hash_partition_key#X, s_suppkey#X, s_name#X, s_address#X, s_nationkey#X]
Arguments: 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], [id=#X]

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

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

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

(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) VeloxAppendBatches
Input [5]: [hash_partition_key#X, l_partkey#X, l_suppkey#X, sum#X, isEmpty#X]
Arguments: 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], [id=#X]

(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)) 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(ps_availqty#X 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) 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>

(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) VeloxAppendBatches
Input [2]: [s_name#X, s_address#X]
Arguments: 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], [id=#X]

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

(69) AQEShuffleRead
Input [2]: [s_name#X, s_address#X]
Arguments: local

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

(93) 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)) AS (0.5 * sum(l_quantity))#X, l_partkey#X, l_suppkey#X]

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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