== Physical Plan ==
AdaptiveSparkPlan (145)
+- == Final Plan ==
   VeloxColumnarToRow (95)
   +- ^ SortExecTransformer (93)
      +- ^ InputIteratorTransformer (92)
         +- ShuffleQueryStage (90)
            +- ColumnarExchange (89)
               +- VeloxResizeBatches (88)
                  +- ^ ProjectExecTransformer (86)
                     +- ^ ShuffledHashJoinExecTransformer Inner BuildRight (85)
                        :- ^ InputIteratorTransformer (75)
                        :  +- ShuffleQueryStage (73)
                        :     +- ColumnarExchange (72)
                        :        +- VeloxResizeBatches (71)
                        :           +- ^ ProjectExecTransformer (69)
                        :              +- ^ ShuffledHashJoinExecTransformer LeftSemi BuildRight (68)
                        :                 :- ^ InputIteratorTransformer (9)
                        :                 :  +- ShuffleQueryStage (7)
                        :                 :     +- ColumnarExchange (6)
                        :                 :        +- VeloxResizeBatches (5)
                        :                 :           +- ^ ProjectExecTransformer (3)
                        :                 :              +- ^ FilterExecTransformer (2)
                        :                 :                 +- ^ ScanTransformer parquet  (1)
                        :                 +- ^ InputIteratorTransformer (67)
                        :                    +- ShuffleQueryStage (65)
                        :                       +- ColumnarExchange (64)
                        :                          +- VeloxResizeBatches (63)
                        :                             +- ^ ProjectExecTransformer (61)
                        :                                +- ^ ShuffledHashJoinExecTransformer Inner BuildLeft (60)
                        :                                   :- ^ InputIteratorTransformer (35)
                        :                                   :  +- ShuffleQueryStage (33)
                        :                                   :     +- ColumnarExchange (32)
                        :                                   :        +- VeloxResizeBatches (31)
                        :                                   :           +- ^ ProjectExecTransformer (29)
                        :                                   :              +- ^ ShuffledHashJoinExecTransformer LeftSemi BuildRight (28)
                        :                                   :                 :- ^ InputIteratorTransformer (18)
                        :                                   :                 :  +- ShuffleQueryStage (16)
                        :                                   :                 :     +- ColumnarExchange (15)
                        :                                   :                 :        +- VeloxResizeBatches (14)
                        :                                   :                 :           +- ^ ProjectExecTransformer (12)
                        :                                   :                 :              +- ^ FilterExecTransformer (11)
                        :                                   :                 :                 +- ^ ScanTransformer parquet  (10)
                        :                                   :                 +- ^ InputIteratorTransformer (27)
                        :                                   :                    +- ShuffleQueryStage (25)
                        :                                   :                       +- ColumnarExchange (24)
                        :                                   :                          +- VeloxResizeBatches (23)
                        :                                   :                             +- ^ ProjectExecTransformer (21)
                        :                                   :                                +- ^ FilterExecTransformer (20)
                        :                                   :                                   +- ^ ScanTransformer parquet  (19)
                        :                                   +- ^ InputIteratorTransformer (59)
                        :                                      +- ShuffleQueryStage (57)
                        :                                         +- ColumnarExchange (56)
                        :                                            +- VeloxResizeBatches (55)
                        :                                               +- ^ ProjectExecTransformer (53)
                        :                                                  +- ^ FilterExecTransformer (52)
                        :                                                     +- ^ ProjectExecTransformer (51)
                        :                                                        +- ^ RegularHashAggregateExecTransformer (50)
                        :                                                           +- ^ ShuffledHashJoinExecTransformer LeftSemi BuildRight (49)
                        :                                                              :- ^ InputIteratorTransformer (44)
                        :                                                              :  +- ShuffleQueryStage (42)
                        :                                                              :     +- ColumnarExchange (41)
                        :                                                              :        +- VeloxResizeBatches (40)
                        :                                                              :           +- ^ ProjectExecTransformer (38)
                        :                                                              :              +- ^ FilterExecTransformer (37)
                        :                                                              :                 +- ^ ScanTransformer parquet  (36)
                        :                                                              +- ^ InputIteratorTransformer (48)
                        :                                                                 +- ShuffleQueryStage (46)
                        :                                                                    +- ReusedExchange (45)
                        +- ^ InputIteratorTransformer (84)
                           +- ShuffleQueryStage (82)
                              +- ColumnarExchange (81)
                                 +- VeloxResizeBatches (80)
                                    +- ^ ProjectExecTransformer (78)
                                       +- ^ FilterExecTransformer (77)
                                          +- ^ ScanTransformer parquet  (76)
+- == Initial Plan ==
   Sort (144)
   +- Exchange (143)
      +- Project (142)
         +- SortMergeJoin Inner (141)
            :- Sort (135)
            :  +- Exchange (134)
            :     +- Project (133)
            :        +- SortMergeJoin LeftSemi (132)
            :           :- Sort (99)
            :           :  +- Exchange (98)
            :           :     +- Filter (97)
            :           :        +- Scan parquet (96)
            :           +- Sort (131)
            :              +- Exchange (130)
            :                 +- Project (129)
            :                    +- SortMergeJoin Inner (128)
            :                       :- Sort (111)
            :                       :  +- Exchange (110)
            :                       :     +- SortMergeJoin LeftSemi (109)
            :                       :        :- Sort (103)
            :                       :        :  +- Exchange (102)
            :                       :        :     +- Filter (101)
            :                       :        :        +- Scan parquet (100)
            :                       :        +- Sort (108)
            :                       :           +- Exchange (107)
            :                       :              +- Project (106)
            :                       :                 +- Filter (105)
            :                       :                    +- Scan parquet (104)
            :                       +- Sort (127)
            :                          +- Exchange (126)
            :                             +- Filter (125)
            :                                +- HashAggregate (124)
            :                                   +- HashAggregate (123)
            :                                      +- SortMergeJoin LeftSemi (122)
            :                                         :- Sort (116)
            :                                         :  +- Exchange (115)
            :                                         :     +- Project (114)
            :                                         :        +- Filter (113)
            :                                         :           +- Scan parquet (112)
            :                                         +- Sort (121)
            :                                            +- Exchange (120)
            :                                               +- Project (119)
            :                                                  +- Filter (118)
            :                                                     +- Scan parquet (117)
            +- Sort (140)
               +- Exchange (139)
                  +- Project (138)
                     +- Filter (137)
                        +- Scan parquet (136)


(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) InputAdapter
Input [4]: [s_suppkey#X, s_name#X, s_address#X, s_nationkey#X]

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

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

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

(12) ProjectExecTransformer
Output [4]: [hash(ps_partkey#X, 42) AS hash_partition_key#X, ps_partkey#X, ps_suppkey#X, ps_availqty#X]
Input [3]: [ps_partkey#X, ps_suppkey#X, ps_availqty#X]

(13) WholeStageCodegenTransformer (X)
Input [4]: [hash_partition_key#X, ps_partkey#X, ps_suppkey#X, ps_availqty#X]
Arguments: false

(14) VeloxResizeBatches
Input [4]: [hash_partition_key#X, ps_partkey#X, ps_suppkey#X, ps_availqty#X]
Arguments: X, X

(15) ColumnarExchange
Input [4]: [hash_partition_key#X, ps_partkey#X, ps_suppkey#X, ps_availqty#X]
Arguments: hashpartitioning(ps_partkey#X, 1), ENSURE_REQUIREMENTS, [ps_partkey#X, ps_suppkey#X, ps_availqty#X], [plan_id=X], [shuffle_writer_type=hash]

(16) ShuffleQueryStage
Output [3]: [ps_partkey#X, ps_suppkey#X, ps_availqty#X]
Arguments: X

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

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

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

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

(21) ProjectExecTransformer
Output [2]: [hash(p_partkey#X, 42) AS hash_partition_key#X, p_partkey#X]
Input [2]: [p_partkey#X, p_name#X]

(22) WholeStageCodegenTransformer (X)
Input [2]: [hash_partition_key#X, p_partkey#X]
Arguments: false

(23) VeloxResizeBatches
Input [2]: [hash_partition_key#X, p_partkey#X]
Arguments: X, X

(24) ColumnarExchange
Input [2]: [hash_partition_key#X, p_partkey#X]
Arguments: hashpartitioning(p_partkey#X, 1), ENSURE_REQUIREMENTS, [p_partkey#X], [plan_id=X], [shuffle_writer_type=hash]

(25) ShuffleQueryStage
Output [1]: [p_partkey#X]
Arguments: X

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

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

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

(29) ProjectExecTransformer
Output [4]: [hash(ps_partkey#X, ps_suppkey#X, 42) AS hash_partition_key#X, ps_partkey#X, ps_suppkey#X, ps_availqty#X]
Input [3]: [ps_partkey#X, ps_suppkey#X, ps_availqty#X]

(30) WholeStageCodegenTransformer (X)
Input [4]: [hash_partition_key#X, ps_partkey#X, ps_suppkey#X, ps_availqty#X]
Arguments: false

(31) VeloxResizeBatches
Input [4]: [hash_partition_key#X, ps_partkey#X, ps_suppkey#X, ps_availqty#X]
Arguments: X, X

(32) ColumnarExchange
Input [4]: [hash_partition_key#X, ps_partkey#X, ps_suppkey#X, ps_availqty#X]
Arguments: hashpartitioning(ps_partkey#X, ps_suppkey#X, 1), ENSURE_REQUIREMENTS, [ps_partkey#X, ps_suppkey#X, ps_availqty#X], [plan_id=X], [shuffle_writer_type=hash]

(33) ShuffleQueryStage
Output [3]: [ps_partkey#X, ps_suppkey#X, ps_availqty#X]
Arguments: X

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

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

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

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

(38) ProjectExecTransformer
Output [4]: [hash(l_partkey#X, 42) AS hash_partition_key#X, l_partkey#X, l_suppkey#X, l_quantity#X]
Input [4]: [l_partkey#X, l_suppkey#X, l_quantity#X, l_shipdate#X]

(39) WholeStageCodegenTransformer (X)
Input [4]: [hash_partition_key#X, l_partkey#X, l_suppkey#X, l_quantity#X]
Arguments: false

(40) VeloxResizeBatches
Input [4]: [hash_partition_key#X, l_partkey#X, l_suppkey#X, l_quantity#X]
Arguments: X, X

(41) ColumnarExchange
Input [4]: [hash_partition_key#X, l_partkey#X, l_suppkey#X, l_quantity#X]
Arguments: hashpartitioning(l_partkey#X, 1), ENSURE_REQUIREMENTS, [l_partkey#X, l_suppkey#X, l_quantity#X], [plan_id=X], [shuffle_writer_type=hash]

(42) ShuffleQueryStage
Output [3]: [l_partkey#X, l_suppkey#X, l_quantity#X]
Arguments: X

(43) InputAdapter
Input [3]: [l_partkey#X, l_suppkey#X, l_quantity#X]

(44) InputIteratorTransformer
Input [3]: [l_partkey#X, l_suppkey#X, l_quantity#X]

(45) ReusedExchange [Reuses operator id: 24]
Output [1]: [p_partkey#X]

(46) ShuffleQueryStage
Output [1]: [p_partkey#X]
Arguments: X

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

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

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

(50) RegularHashAggregateExecTransformer
Input [3]: [l_partkey#X, l_suppkey#X, l_quantity#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]

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

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

(53) ProjectExecTransformer
Output [4]: [hash(l_partkey#X, l_suppkey#X, 42) AS hash_partition_key#X, (0.5 * sum(l_quantity))#X, l_partkey#X, l_suppkey#X]
Input [3]: [(0.5 * sum(l_quantity))#X, l_partkey#X, l_suppkey#X]

(54) WholeStageCodegenTransformer (X)
Input [4]: [hash_partition_key#X, (0.5 * sum(l_quantity))#X, l_partkey#X, l_suppkey#X]
Arguments: false

(55) VeloxResizeBatches
Input [4]: [hash_partition_key#X, (0.5 * sum(l_quantity))#X, l_partkey#X, l_suppkey#X]
Arguments: X, X

(56) ColumnarExchange
Input [4]: [hash_partition_key#X, (0.5 * sum(l_quantity))#X, l_partkey#X, l_suppkey#X]
Arguments: hashpartitioning(l_partkey#X, l_suppkey#X, 1), ENSURE_REQUIREMENTS, [(0.5 * sum(l_quantity))#X, l_partkey#X, l_suppkey#X], [plan_id=X], [shuffle_writer_type=hash]

(57) ShuffleQueryStage
Output [3]: [(0.5 * sum(l_quantity))#X, l_partkey#X, l_suppkey#X]
Arguments: X

(58) InputAdapter
Input [3]: [(0.5 * sum(l_quantity))#X, l_partkey#X, l_suppkey#X]

(59) InputIteratorTransformer
Input [3]: [(0.5 * sum(l_quantity))#X, l_partkey#X, l_suppkey#X]

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

(61) ProjectExecTransformer
Output [2]: [hash(ps_suppkey#X, 42) AS hash_partition_key#X, 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]

(62) WholeStageCodegenTransformer (X)
Input [2]: [hash_partition_key#X, ps_suppkey#X]
Arguments: false

(63) VeloxResizeBatches
Input [2]: [hash_partition_key#X, ps_suppkey#X]
Arguments: X, X

(64) ColumnarExchange
Input [2]: [hash_partition_key#X, ps_suppkey#X]
Arguments: hashpartitioning(ps_suppkey#X, 1), ENSURE_REQUIREMENTS, [ps_suppkey#X], [plan_id=X], [shuffle_writer_type=hash]

(65) ShuffleQueryStage
Output [1]: [ps_suppkey#X]
Arguments: X

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

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

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

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

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

(71) VeloxResizeBatches
Input [4]: [hash_partition_key#X, s_name#X, s_address#X, s_nationkey#X]
Arguments: X, X

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

(73) ShuffleQueryStage
Output [3]: [s_name#X, s_address#X, s_nationkey#X]
Arguments: X

(74) InputAdapter
Input [3]: [s_name#X, s_address#X, s_nationkey#X]

(75) InputIteratorTransformer
Input [3]: [s_name#X, s_address#X, s_nationkey#X]

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

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

(78) ProjectExecTransformer
Output [2]: [hash(n_nationkey#X, 42) AS hash_partition_key#X, n_nationkey#X]
Input [2]: [n_nationkey#X, n_name#X]

(79) WholeStageCodegenTransformer (X)
Input [2]: [hash_partition_key#X, n_nationkey#X]
Arguments: false

(80) VeloxResizeBatches
Input [2]: [hash_partition_key#X, n_nationkey#X]
Arguments: X, X

(81) ColumnarExchange
Input [2]: [hash_partition_key#X, n_nationkey#X]
Arguments: hashpartitioning(n_nationkey#X, 1), ENSURE_REQUIREMENTS, [n_nationkey#X], [plan_id=X], [shuffle_writer_type=hash]

(82) ShuffleQueryStage
Output [1]: [n_nationkey#X]
Arguments: X

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

(102) Exchange
Input [3]: [ps_partkey#X, ps_suppkey#X, ps_availqty#X]
Arguments: hashpartitioning(ps_partkey#X, 1), ENSURE_REQUIREMENTS, [plan_id=X]

(103) Sort
Input [3]: [ps_partkey#X, ps_suppkey#X, ps_availqty#X]
Arguments: [ps_partkey#X ASC NULLS FIRST], false, 0

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

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

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

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

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

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

(110) Exchange
Input [3]: [ps_partkey#X, ps_suppkey#X, ps_availqty#X]
Arguments: hashpartitioning(ps_partkey#X, ps_suppkey#X, 1), ENSURE_REQUIREMENTS, [plan_id=X]

(111) Sort
Input [3]: [ps_partkey#X, ps_suppkey#X, ps_availqty#X]
Arguments: [ps_partkey#X ASC NULLS FIRST, ps_suppkey#X ASC NULLS FIRST], false, 0

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

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

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

(115) Exchange
Input [3]: [l_partkey#X, l_suppkey#X, l_quantity#X]
Arguments: hashpartitioning(l_partkey#X, 1), ENSURE_REQUIREMENTS, [plan_id=X]

(116) Sort
Input [3]: [l_partkey#X, l_suppkey#X, l_quantity#X]
Arguments: [l_partkey#X ASC NULLS FIRST], false, 0

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

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

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

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

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

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

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

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

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

(126) Exchange
Input [3]: [(0.5 * sum(l_quantity))#X, l_partkey#X, l_suppkey#X]
Arguments: hashpartitioning(l_partkey#X, l_suppkey#X, 1), ENSURE_REQUIREMENTS, [plan_id=X]

(127) Sort
Input [3]: [(0.5 * sum(l_quantity))#X, l_partkey#X, l_suppkey#X]
Arguments: [l_partkey#X ASC NULLS FIRST, l_suppkey#X ASC NULLS FIRST], false, 0

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

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

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

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

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

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

(134) Exchange
Input [3]: [s_name#X, s_address#X, s_nationkey#X]
Arguments: hashpartitioning(s_nationkey#X, 1), ENSURE_REQUIREMENTS, [plan_id=X]

(135) Sort
Input [3]: [s_name#X, s_address#X, s_nationkey#X]
Arguments: [s_nationkey#X ASC NULLS FIRST], false, 0

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

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

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

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

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

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

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

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

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

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