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


(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)) 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(ps_availqty#X 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) AQEShuffleRead
Input [2]: [s_name#X, s_address#X]
Arguments: local

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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