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


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

(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) VeloxAppendBatches
Input [4]: [hash_partition_key#X, ps_partkey#X, ps_suppkey#X, ps_availqty#X]
Arguments: 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], [id=#X]

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

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

(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) VeloxAppendBatches
Input [4]: [hash_partition_key#X, ps_partkey#X, ps_suppkey#X, ps_availqty#X]
Arguments: 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], [id=#X]

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

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

(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]: [partial_sum(l_quantity#X)]
Aggregate Attributes [2]: [sum#X, isEmpty#X]
Results [4]: [l_partkey#X, l_suppkey#X, sum#X, isEmpty#X]

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

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

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

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

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

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

(57) 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], [id=#X]

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

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

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

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

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

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

(64) VeloxAppendBatches
Input [2]: [hash_partition_key#X, ps_suppkey#X]
Arguments: X

(65) ColumnarExchange
Input [2]: [hash_partition_key#X, ps_suppkey#X]
Arguments: hashpartitioning(ps_suppkey#X, 1), ENSURE_REQUIREMENTS, [ps_suppkey#X], [plan_id=X], [id=#X]

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

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

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

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

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

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

(72) VeloxAppendBatches
Input [4]: [hash_partition_key#X, s_name#X, s_address#X, s_nationkey#X]
Arguments: X

(73) 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], [id=#X]

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

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

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

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

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

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

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

(81) VeloxAppendBatches
Input [2]: [hash_partition_key#X, n_nationkey#X]
Arguments: X

(82) ColumnarExchange
Input [2]: [hash_partition_key#X, n_nationkey#X]
Arguments: hashpartitioning(n_nationkey#X, 1), ENSURE_REQUIREMENTS, [n_nationkey#X], [plan_id=X], [id=#X]

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

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

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

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

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

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

(89) VeloxAppendBatches
Input [2]: [s_name#X, s_address#X]
Arguments: X

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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