== Physical Plan ==
AdaptiveSparkPlan (138)
+- == Final Plan ==
   VeloxColumnarToRowExec (92)
   +- TakeOrderedAndProjectExecTransformer (91)
      +- ^ RegularHashAggregateExecTransformer (89)
         +- ^ InputIteratorTransformer (88)
            +- ShuffleQueryStage (86)
               +- ColumnarExchange (85)
                  +- VeloxAppendBatches (84)
                     +- ^ ProjectExecTransformer (82)
                        +- ^ FlushableHashAggregateExecTransformer (81)
                           +- ^ ProjectExecTransformer (80)
                              +- ^ ShuffledHashJoinExecTransformer Inner BuildRight (79)
                                 :- ^ InputIteratorTransformer (69)
                                 :  +- ShuffleQueryStage (67)
                                 :     +- ColumnarExchange (66)
                                 :        +- VeloxAppendBatches (65)
                                 :           +- ^ ProjectExecTransformer (63)
                                 :              +- ^ ShuffledHashJoinExecTransformer Inner BuildRight (62)
                                 :                 :- ^ InputIteratorTransformer (52)
                                 :                 :  +- ShuffleQueryStage (50)
                                 :                 :     +- ColumnarExchange (49)
                                 :                 :        +- VeloxAppendBatches (48)
                                 :                 :           +- ^ ProjectExecTransformer (46)
                                 :                 :              +- ^ ShuffledHashJoinExecTransformer Inner BuildLeft (45)
                                 :                 :                 :- ^ InputIteratorTransformer (9)
                                 :                 :                 :  +- ShuffleQueryStage (7)
                                 :                 :                 :     +- ColumnarExchange (6)
                                 :                 :                 :        +- VeloxAppendBatches (5)
                                 :                 :                 :           +- ^ ProjectExecTransformer (3)
                                 :                 :                 :              +- ^ NoopFilter (2)
                                 :                 :                 :                 +- ^ Scan parquet (1)
                                 :                 :                 +- ^ InputIteratorTransformer (44)
                                 :                 :                    +- ShuffleQueryStage (42)
                                 :                 :                       +- ColumnarExchange (41)
                                 :                 :                          +- VeloxAppendBatches (40)
                                 :                 :                             +- ^ ProjectExecTransformer (38)
                                 :                 :                                +- ^ ShuffledHashJoinExecTransformer LeftAnti BuildRight (37)
                                 :                 :                                   :- ^ ShuffledHashJoinExecTransformer LeftSemi BuildRight (27)
                                 :                 :                                   :  :- ^ InputIteratorTransformer (18)
                                 :                 :                                   :  :  +- ShuffleQueryStage (16)
                                 :                 :                                   :  :     +- ColumnarExchange (15)
                                 :                 :                                   :  :        +- VeloxAppendBatches (14)
                                 :                 :                                   :  :           +- ^ ProjectExecTransformer (12)
                                 :                 :                                   :  :              +- ^ NoopFilter (11)
                                 :                 :                                   :  :                 +- ^ Scan parquet (10)
                                 :                 :                                   :  +- ^ InputIteratorTransformer (26)
                                 :                 :                                   :     +- ShuffleQueryStage (24)
                                 :                 :                                   :        +- ColumnarExchange (23)
                                 :                 :                                   :           +- VeloxAppendBatches (22)
                                 :                 :                                   :              +- ^ ProjectExecTransformer (20)
                                 :                 :                                   :                 +- ^ Scan parquet (19)
                                 :                 :                                   +- ^ InputIteratorTransformer (36)
                                 :                 :                                      +- ShuffleQueryStage (34)
                                 :                 :                                         +- ColumnarExchange (33)
                                 :                 :                                            +- VeloxAppendBatches (32)
                                 :                 :                                               +- ^ ProjectExecTransformer (30)
                                 :                 :                                                  +- ^ NoopFilter (29)
                                 :                 :                                                     +- ^ Scan parquet (28)
                                 :                 +- ^ InputIteratorTransformer (61)
                                 :                    +- ShuffleQueryStage (59)
                                 :                       +- ColumnarExchange (58)
                                 :                          +- VeloxAppendBatches (57)
                                 :                             +- ^ ProjectExecTransformer (55)
                                 :                                +- ^ NoopFilter (54)
                                 :                                   +- ^ Scan parquet (53)
                                 +- ^ InputIteratorTransformer (78)
                                    +- ShuffleQueryStage (76)
                                       +- ColumnarExchange (75)
                                          +- VeloxAppendBatches (74)
                                             +- ^ ProjectExecTransformer (72)
                                                +- ^ NoopFilter (71)
                                                   +- ^ Scan parquet (70)
+- == Initial Plan ==
   TakeOrderedAndProject (137)
   +- HashAggregate (136)
      +- Exchange (135)
         +- HashAggregate (134)
            +- Project (133)
               +- SortMergeJoin Inner (132)
                  :- Sort (126)
                  :  +- Exchange (125)
                  :     +- Project (124)
                  :        +- SortMergeJoin Inner (123)
                  :           :- Sort (117)
                  :           :  +- Exchange (116)
                  :           :     +- Project (115)
                  :           :        +- SortMergeJoin Inner (114)
                  :           :           :- Sort (96)
                  :           :           :  +- Exchange (95)
                  :           :           :     +- Filter (94)
                  :           :           :        +- Scan parquet (93)
                  :           :           +- Sort (113)
                  :           :              +- Exchange (112)
                  :           :                 +- SortMergeJoin LeftAnti (111)
                  :           :                    :- SortMergeJoin LeftSemi (105)
                  :           :                    :  :- Sort (101)
                  :           :                    :  :  +- Exchange (100)
                  :           :                    :  :     +- Project (99)
                  :           :                    :  :        +- Filter (98)
                  :           :                    :  :           +- Scan parquet (97)
                  :           :                    :  +- Sort (104)
                  :           :                    :     +- Exchange (103)
                  :           :                    :        +- Scan parquet (102)
                  :           :                    +- Sort (110)
                  :           :                       +- Exchange (109)
                  :           :                          +- Project (108)
                  :           :                             +- Filter (107)
                  :           :                                +- Scan parquet (106)
                  :           +- Sort (122)
                  :              +- Exchange (121)
                  :                 +- Project (120)
                  :                    +- Filter (119)
                  :                       +- Scan parquet (118)
                  +- Sort (131)
                     +- Exchange (130)
                        +- Project (129)
                           +- Filter (128)
                              +- Scan parquet (127)


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

(2) NoopFilter
Input [3]: [s_suppkey#X, s_name#X, s_nationkey#X]
Arguments: [s_suppkey#X, s_name#X, s_nationkey#X]

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

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

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

(6) ColumnarExchange
Input [4]: [hash_partition_key#X, s_suppkey#X, s_name#X, s_nationkey#X]
Arguments: hashpartitioning(s_suppkey#X, 1), ENSURE_REQUIREMENTS, [s_suppkey#X, s_name#X, s_nationkey#X], [plan_id=X], [id=#X]

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

(8) InputAdapter
Input [3]: [s_suppkey#X, s_name#X, s_nationkey#X]

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

(10) Scan parquet
Output [4]: [l_orderkey#X, l_suppkey#X, l_commitdate#X, l_receiptdate#X]
Batched: true
Location: InMemoryFileIndex [*]
PushedFilters: [IsNotNull(l_receiptdate), IsNotNull(l_commitdate), IsNotNull(l_suppkey), IsNotNull(l_orderkey)]
ReadSchema: struct<l_orderkey:bigint,l_suppkey:bigint,l_commitdate:date,l_receiptdate:date>

(11) NoopFilter
Input [4]: [l_orderkey#X, l_suppkey#X, l_commitdate#X, l_receiptdate#X]
Arguments: [l_orderkey#X, l_suppkey#X, l_commitdate#X, l_receiptdate#X]

(12) ProjectExecTransformer
Output [3]: [hash(l_orderkey#X, 42) AS hash_partition_key#X, l_orderkey#X, l_suppkey#X]
Input [4]: [l_orderkey#X, l_suppkey#X, l_commitdate#X, l_receiptdate#X]

(13) WholeStageCodegenTransformer (X)
Input [3]: [hash_partition_key#X, l_orderkey#X, l_suppkey#X]
Arguments: false

(14) VeloxAppendBatches
Input [3]: [hash_partition_key#X, l_orderkey#X, l_suppkey#X]
Arguments: X

(15) ColumnarExchange
Input [3]: [hash_partition_key#X, l_orderkey#X, l_suppkey#X]
Arguments: hashpartitioning(l_orderkey#X, 1), ENSURE_REQUIREMENTS, [l_orderkey#X, l_suppkey#X], [plan_id=X], [id=#X]

(16) ShuffleQueryStage
Output [2]: [l_orderkey#X, l_suppkey#X]
Arguments: X

(17) InputAdapter
Input [2]: [l_orderkey#X, l_suppkey#X]

(18) InputIteratorTransformer
Input [2]: [l_orderkey#X, l_suppkey#X]

(19) Scan parquet
Output [2]: [l_orderkey#X, l_suppkey#X]
Batched: true
Location: InMemoryFileIndex [*]
ReadSchema: struct<l_orderkey:bigint,l_suppkey:bigint>

(20) ProjectExecTransformer
Output [3]: [hash(l_orderkey#X, 42) AS hash_partition_key#X, l_orderkey#X, l_suppkey#X]
Input [2]: [l_orderkey#X, l_suppkey#X]

(21) WholeStageCodegenTransformer (X)
Input [3]: [hash_partition_key#X, l_orderkey#X, l_suppkey#X]
Arguments: false

(22) VeloxAppendBatches
Input [3]: [hash_partition_key#X, l_orderkey#X, l_suppkey#X]
Arguments: X

(23) ColumnarExchange
Input [3]: [hash_partition_key#X, l_orderkey#X, l_suppkey#X]
Arguments: hashpartitioning(l_orderkey#X, 1), ENSURE_REQUIREMENTS, [l_orderkey#X, l_suppkey#X], [plan_id=X], [id=#X]

(24) ShuffleQueryStage
Output [2]: [l_orderkey#X, l_suppkey#X]
Arguments: X

(25) InputAdapter
Input [2]: [l_orderkey#X, l_suppkey#X]

(26) InputIteratorTransformer
Input [2]: [l_orderkey#X, l_suppkey#X]

(27) ShuffledHashJoinExecTransformer
Left keys [1]: [l_orderkey#X]
Right keys [1]: [l_orderkey#X]
Join condition: NOT (l_suppkey#X = l_suppkey#X)

(28) Scan parquet
Output [4]: [l_orderkey#X, l_suppkey#X, l_commitdate#X, l_receiptdate#X]
Batched: true
Location: InMemoryFileIndex [*]
PushedFilters: [IsNotNull(l_receiptdate), IsNotNull(l_commitdate)]
ReadSchema: struct<l_orderkey:bigint,l_suppkey:bigint,l_commitdate:date,l_receiptdate:date>

(29) NoopFilter
Input [4]: [l_orderkey#X, l_suppkey#X, l_commitdate#X, l_receiptdate#X]
Arguments: [l_orderkey#X, l_suppkey#X, l_commitdate#X, l_receiptdate#X]

(30) ProjectExecTransformer
Output [3]: [hash(l_orderkey#X, 42) AS hash_partition_key#X, l_orderkey#X, l_suppkey#X]
Input [4]: [l_orderkey#X, l_suppkey#X, l_commitdate#X, l_receiptdate#X]

(31) WholeStageCodegenTransformer (X)
Input [3]: [hash_partition_key#X, l_orderkey#X, l_suppkey#X]
Arguments: false

(32) VeloxAppendBatches
Input [3]: [hash_partition_key#X, l_orderkey#X, l_suppkey#X]
Arguments: X

(33) ColumnarExchange
Input [3]: [hash_partition_key#X, l_orderkey#X, l_suppkey#X]
Arguments: hashpartitioning(l_orderkey#X, 1), ENSURE_REQUIREMENTS, [l_orderkey#X, l_suppkey#X], [plan_id=X], [id=#X]

(34) ShuffleQueryStage
Output [2]: [l_orderkey#X, l_suppkey#X]
Arguments: X

(35) InputAdapter
Input [2]: [l_orderkey#X, l_suppkey#X]

(36) InputIteratorTransformer
Input [2]: [l_orderkey#X, l_suppkey#X]

(37) ShuffledHashJoinExecTransformer
Left keys [1]: [l_orderkey#X]
Right keys [1]: [l_orderkey#X]
Join condition: NOT (l_suppkey#X = l_suppkey#X)

(38) ProjectExecTransformer
Output [3]: [hash(l_suppkey#X, 42) AS hash_partition_key#X, l_orderkey#X, l_suppkey#X]
Input [2]: [l_orderkey#X, l_suppkey#X]

(39) WholeStageCodegenTransformer (X)
Input [3]: [hash_partition_key#X, l_orderkey#X, l_suppkey#X]
Arguments: false

(40) VeloxAppendBatches
Input [3]: [hash_partition_key#X, l_orderkey#X, l_suppkey#X]
Arguments: X

(41) ColumnarExchange
Input [3]: [hash_partition_key#X, l_orderkey#X, l_suppkey#X]
Arguments: hashpartitioning(l_suppkey#X, 1), ENSURE_REQUIREMENTS, [l_orderkey#X, l_suppkey#X], [plan_id=X], [id=#X]

(42) ShuffleQueryStage
Output [2]: [l_orderkey#X, l_suppkey#X]
Arguments: X

(43) InputAdapter
Input [2]: [l_orderkey#X, l_suppkey#X]

(44) InputIteratorTransformer
Input [2]: [l_orderkey#X, l_suppkey#X]

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

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

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

(48) VeloxAppendBatches
Input [4]: [hash_partition_key#X, s_name#X, s_nationkey#X, l_orderkey#X]
Arguments: X

(49) ColumnarExchange
Input [4]: [hash_partition_key#X, s_name#X, s_nationkey#X, l_orderkey#X]
Arguments: hashpartitioning(l_orderkey#X, 1), ENSURE_REQUIREMENTS, [s_name#X, s_nationkey#X, l_orderkey#X], [plan_id=X], [id=#X]

(50) ShuffleQueryStage
Output [3]: [s_name#X, s_nationkey#X, l_orderkey#X]
Arguments: X

(51) InputAdapter
Input [3]: [s_name#X, s_nationkey#X, l_orderkey#X]

(52) InputIteratorTransformer
Input [3]: [s_name#X, s_nationkey#X, l_orderkey#X]

(53) Scan parquet
Output [2]: [o_orderkey#X, o_orderstatus#X]
Batched: true
Location: InMemoryFileIndex [*]
PushedFilters: [IsNotNull(o_orderstatus), EqualTo(o_orderstatus,F), IsNotNull(o_orderkey)]
ReadSchema: struct<o_orderkey:bigint,o_orderstatus:string>

(54) NoopFilter
Input [2]: [o_orderkey#X, o_orderstatus#X]
Arguments: [o_orderkey#X, o_orderstatus#X]

(55) ProjectExecTransformer
Output [2]: [hash(o_orderkey#X, 42) AS hash_partition_key#X, o_orderkey#X]
Input [2]: [o_orderkey#X, o_orderstatus#X]

(56) WholeStageCodegenTransformer (X)
Input [2]: [hash_partition_key#X, o_orderkey#X]
Arguments: false

(57) VeloxAppendBatches
Input [2]: [hash_partition_key#X, o_orderkey#X]
Arguments: X

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

(59) ShuffleQueryStage
Output [1]: [o_orderkey#X]
Arguments: X

(60) InputAdapter
Input [1]: [o_orderkey#X]

(61) InputIteratorTransformer
Input [1]: [o_orderkey#X]

(62) ShuffledHashJoinExecTransformer
Left keys [1]: [l_orderkey#X]
Right keys [1]: [o_orderkey#X]
Join condition: None

(63) ProjectExecTransformer
Output [3]: [hash(s_nationkey#X, 42) AS hash_partition_key#X, s_name#X, s_nationkey#X]
Input [4]: [s_name#X, s_nationkey#X, l_orderkey#X, o_orderkey#X]

(64) WholeStageCodegenTransformer (X)
Input [3]: [hash_partition_key#X, s_name#X, s_nationkey#X]
Arguments: false

(65) VeloxAppendBatches
Input [3]: [hash_partition_key#X, s_name#X, s_nationkey#X]
Arguments: X

(66) ColumnarExchange
Input [3]: [hash_partition_key#X, s_name#X, s_nationkey#X]
Arguments: hashpartitioning(s_nationkey#X, 1), ENSURE_REQUIREMENTS, [s_name#X, s_nationkey#X], [plan_id=X], [id=#X]

(67) ShuffleQueryStage
Output [2]: [s_name#X, s_nationkey#X]
Arguments: X

(68) InputAdapter
Input [2]: [s_name#X, s_nationkey#X]

(69) InputIteratorTransformer
Input [2]: [s_name#X, s_nationkey#X]

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

(71) NoopFilter
Input [2]: [n_nationkey#X, n_name#X]
Arguments: [n_nationkey#X, n_name#X]

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

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

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

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

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

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

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

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

(80) ProjectExecTransformer
Output [1]: [s_name#X]
Input [3]: [s_name#X, s_nationkey#X, n_nationkey#X]

(81) FlushableHashAggregateExecTransformer
Input [1]: [s_name#X]
Keys [1]: [s_name#X]
Functions [1]: [partial_count(1)]
Aggregate Attributes [1]: [count#X]
Results [2]: [s_name#X, count#X]

(82) ProjectExecTransformer
Output [3]: [hash(s_name#X, 42) AS hash_partition_key#X, s_name#X, count#X]
Input [2]: [s_name#X, count#X]

(83) WholeStageCodegenTransformer (X)
Input [3]: [hash_partition_key#X, s_name#X, count#X]
Arguments: false

(84) VeloxAppendBatches
Input [3]: [hash_partition_key#X, s_name#X, count#X]
Arguments: X

(85) ColumnarExchange
Input [3]: [hash_partition_key#X, s_name#X, count#X]
Arguments: hashpartitioning(s_name#X, 1), ENSURE_REQUIREMENTS, [s_name#X, count#X], [plan_id=X], [id=#X]

(86) ShuffleQueryStage
Output [2]: [s_name#X, count#X]
Arguments: X

(87) InputAdapter
Input [2]: [s_name#X, count#X]

(88) InputIteratorTransformer
Input [2]: [s_name#X, count#X]

(89) RegularHashAggregateExecTransformer
Input [2]: [s_name#X, count#X]
Keys [1]: [s_name#X]
Functions [1]: [count(1)]
Aggregate Attributes [1]: [count(1)#X]
Results [2]: [s_name#X, count(1)#X AS numwait#X]

(90) WholeStageCodegenTransformer (X)
Input [2]: [s_name#X, numwait#X]
Arguments: false

(91) TakeOrderedAndProjectExecTransformer
Input [2]: [s_name#X, numwait#X]
Arguments: X, [numwait#X DESC NULLS LAST, s_name#X ASC NULLS FIRST], [s_name#X, numwait#X], 0

(92) VeloxColumnarToRowExec
Input [2]: [s_name#X, numwait#X]

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

(94) Filter
Input [3]: [s_suppkey#X, s_name#X, s_nationkey#X]
Condition : (isnotnull(s_suppkey#X) AND isnotnull(s_nationkey#X))

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

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

(97) Scan parquet
Output [4]: [l_orderkey#X, l_suppkey#X, l_commitdate#X, l_receiptdate#X]
Batched: true
Location: InMemoryFileIndex [*]
PushedFilters: [IsNotNull(l_receiptdate), IsNotNull(l_commitdate), IsNotNull(l_suppkey), IsNotNull(l_orderkey)]
ReadSchema: struct<l_orderkey:bigint,l_suppkey:bigint,l_commitdate:date,l_receiptdate:date>

(98) Filter
Input [4]: [l_orderkey#X, l_suppkey#X, l_commitdate#X, l_receiptdate#X]
Condition : ((((isnotnull(l_receiptdate#X) AND isnotnull(l_commitdate#X)) AND (l_receiptdate#X > l_commitdate#X)) AND isnotnull(l_suppkey#X)) AND isnotnull(l_orderkey#X))

(99) Project
Output [2]: [l_orderkey#X, l_suppkey#X]
Input [4]: [l_orderkey#X, l_suppkey#X, l_commitdate#X, l_receiptdate#X]

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

(101) Sort
Input [2]: [l_orderkey#X, l_suppkey#X]
Arguments: [l_orderkey#X ASC NULLS FIRST], false, 0

(102) Scan parquet
Output [2]: [l_orderkey#X, l_suppkey#X]
Batched: true
Location: InMemoryFileIndex [*]
ReadSchema: struct<l_orderkey:bigint,l_suppkey:bigint>

(103) Exchange
Input [2]: [l_orderkey#X, l_suppkey#X]
Arguments: hashpartitioning(l_orderkey#X, 1), ENSURE_REQUIREMENTS, [plan_id=X]

(104) Sort
Input [2]: [l_orderkey#X, l_suppkey#X]
Arguments: [l_orderkey#X ASC NULLS FIRST], false, 0

(105) SortMergeJoin
Left keys [1]: [l_orderkey#X]
Right keys [1]: [l_orderkey#X]
Join condition: NOT (l_suppkey#X = l_suppkey#X)

(106) Scan parquet
Output [4]: [l_orderkey#X, l_suppkey#X, l_commitdate#X, l_receiptdate#X]
Batched: true
Location: InMemoryFileIndex [*]
PushedFilters: [IsNotNull(l_receiptdate), IsNotNull(l_commitdate)]
ReadSchema: struct<l_orderkey:bigint,l_suppkey:bigint,l_commitdate:date,l_receiptdate:date>

(107) Filter
Input [4]: [l_orderkey#X, l_suppkey#X, l_commitdate#X, l_receiptdate#X]
Condition : ((isnotnull(l_receiptdate#X) AND isnotnull(l_commitdate#X)) AND (l_receiptdate#X > l_commitdate#X))

(108) Project
Output [2]: [l_orderkey#X, l_suppkey#X]
Input [4]: [l_orderkey#X, l_suppkey#X, l_commitdate#X, l_receiptdate#X]

(109) Exchange
Input [2]: [l_orderkey#X, l_suppkey#X]
Arguments: hashpartitioning(l_orderkey#X, 1), ENSURE_REQUIREMENTS, [plan_id=X]

(110) Sort
Input [2]: [l_orderkey#X, l_suppkey#X]
Arguments: [l_orderkey#X ASC NULLS FIRST], false, 0

(111) SortMergeJoin
Left keys [1]: [l_orderkey#X]
Right keys [1]: [l_orderkey#X]
Join condition: NOT (l_suppkey#X = l_suppkey#X)

(112) Exchange
Input [2]: [l_orderkey#X, l_suppkey#X]
Arguments: hashpartitioning(l_suppkey#X, 1), ENSURE_REQUIREMENTS, [plan_id=X]

(113) Sort
Input [2]: [l_orderkey#X, l_suppkey#X]
Arguments: [l_suppkey#X ASC NULLS FIRST], false, 0

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

(115) Project
Output [3]: [s_name#X, s_nationkey#X, l_orderkey#X]
Input [5]: [s_suppkey#X, s_name#X, s_nationkey#X, l_orderkey#X, l_suppkey#X]

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

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

(118) Scan parquet
Output [2]: [o_orderkey#X, o_orderstatus#X]
Batched: true
Location: InMemoryFileIndex [*]
PushedFilters: [IsNotNull(o_orderstatus), EqualTo(o_orderstatus,F), IsNotNull(o_orderkey)]
ReadSchema: struct<o_orderkey:bigint,o_orderstatus:string>

(119) Filter
Input [2]: [o_orderkey#X, o_orderstatus#X]
Condition : ((isnotnull(o_orderstatus#X) AND (o_orderstatus#X = F)) AND isnotnull(o_orderkey#X))

(120) Project
Output [1]: [o_orderkey#X]
Input [2]: [o_orderkey#X, o_orderstatus#X]

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

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

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

(124) Project
Output [2]: [s_name#X, s_nationkey#X]
Input [4]: [s_name#X, s_nationkey#X, l_orderkey#X, o_orderkey#X]

(125) Exchange
Input [2]: [s_name#X, s_nationkey#X]
Arguments: hashpartitioning(s_nationkey#X, 1), ENSURE_REQUIREMENTS, [plan_id=X]

(126) Sort
Input [2]: [s_name#X, s_nationkey#X]
Arguments: [s_nationkey#X ASC NULLS FIRST], false, 0

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

(128) Filter
Input [2]: [n_nationkey#X, n_name#X]
Condition : ((isnotnull(n_name#X) AND (n_name#X = SAUDI ARABIA)) AND isnotnull(n_nationkey#X))

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

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

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

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

(133) Project
Output [1]: [s_name#X]
Input [3]: [s_name#X, s_nationkey#X, n_nationkey#X]

(134) HashAggregate
Input [1]: [s_name#X]
Keys [1]: [s_name#X]
Functions [1]: [partial_count(1)]
Aggregate Attributes [1]: [count#X]
Results [2]: [s_name#X, count#X]

(135) Exchange
Input [2]: [s_name#X, count#X]
Arguments: hashpartitioning(s_name#X, 1), ENSURE_REQUIREMENTS, [plan_id=X]

(136) HashAggregate
Input [2]: [s_name#X, count#X]
Keys [1]: [s_name#X]
Functions [1]: [count(1)]
Aggregate Attributes [1]: [count(1)#X]
Results [2]: [s_name#X, count(1)#X AS numwait#X]

(137) TakeOrderedAndProject
Input [2]: [s_name#X, numwait#X]
Arguments: X, [numwait#X DESC NULLS LAST, s_name#X ASC NULLS FIRST], [s_name#X, numwait#X]

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