== Physical Plan ==
AdaptiveSparkPlan (110)
+- == Final Plan ==
   VeloxColumnarToRowExec (70)
   +- TakeOrderedAndProjectExecTransformer (69)
      +- ^ RegularHashAggregateExecTransformer (67)
         +- ^ RegularHashAggregateExecTransformer (66)
            +- ^ ProjectExecTransformer (65)
               +- ^ ShuffledHashJoinExecTransformer Inner BuildLeft (64)
                  :- ^ InputIteratorTransformer (46)
                  :  +- ShuffleQueryStage (44)
                  :     +- ColumnarExchange (43)
                  :        +- VeloxAppendBatches (42)
                  :           +- ^ ProjectExecTransformer (40)
                  :              +- ^ ShuffledHashJoinExecTransformer Inner BuildRight (39)
                  :                 :- ^ InputIteratorTransformer (9)
                  :                 :  +- ShuffleQueryStage (7)
                  :                 :     +- ColumnarExchange (6)
                  :                 :        +- VeloxAppendBatches (5)
                  :                 :           +- ^ ProjectExecTransformer (3)
                  :                 :              +- ^ FilterExecTransformer (2)
                  :                 :                 +- ^ Scan parquet (1)
                  :                 +- ^ InputIteratorTransformer (38)
                  :                    +- ShuffleQueryStage (36)
                  :                       +- ColumnarExchange (35)
                  :                          +- VeloxAppendBatches (34)
                  :                             +- ^ ProjectExecTransformer (32)
                  :                                +- ^ ShuffledHashJoinExecTransformer LeftSemi BuildRight (31)
                  :                                   :- ^ InputIteratorTransformer (18)
                  :                                   :  +- ShuffleQueryStage (16)
                  :                                   :     +- ColumnarExchange (15)
                  :                                   :        +- VeloxAppendBatches (14)
                  :                                   :           +- ^ ProjectExecTransformer (12)
                  :                                   :              +- ^ FilterExecTransformer (11)
                  :                                   :                 +- ^ Scan parquet (10)
                  :                                   +- ^ ProjectExecTransformer (30)
                  :                                      +- ^ FilterExecTransformer (29)
                  :                                         +- ^ RegularHashAggregateExecTransformer (28)
                  :                                            +- ^ InputIteratorTransformer (27)
                  :                                               +- ShuffleQueryStage (25)
                  :                                                  +- ColumnarExchange (24)
                  :                                                     +- VeloxAppendBatches (23)
                  :                                                        +- ^ ProjectExecTransformer (21)
                  :                                                           +- ^ FlushableHashAggregateExecTransformer (20)
                  :                                                              +- ^ Scan parquet (19)
                  +- ^ ShuffledHashJoinExecTransformer LeftSemi BuildRight (63)
                     :- ^ InputIteratorTransformer (55)
                     :  +- ShuffleQueryStage (53)
                     :     +- ColumnarExchange (52)
                     :        +- VeloxAppendBatches (51)
                     :           +- ^ ProjectExecTransformer (49)
                     :              +- ^ FilterExecTransformer (48)
                     :                 +- ^ Scan parquet (47)
                     +- ^ ProjectExecTransformer (62)
                        +- ^ FilterExecTransformer (61)
                           +- ^ RegularHashAggregateExecTransformer (60)
                              +- ^ InputIteratorTransformer (59)
                                 +- ShuffleQueryStage (57)
                                    +- ReusedExchange (56)
+- == Initial Plan ==
   TakeOrderedAndProject (109)
   +- HashAggregate (108)
      +- HashAggregate (107)
         +- Project (106)
            +- SortMergeJoin Inner (105)
               :- Sort (92)
               :  +- Exchange (91)
               :     +- Project (90)
               :        +- SortMergeJoin Inner (89)
               :           :- Sort (74)
               :           :  +- Exchange (73)
               :           :     +- Filter (72)
               :           :        +- Scan parquet (71)
               :           +- Sort (88)
               :              +- Exchange (87)
               :                 +- SortMergeJoin LeftSemi (86)
               :                    :- Sort (78)
               :                    :  +- Exchange (77)
               :                    :     +- Filter (76)
               :                    :        +- Scan parquet (75)
               :                    +- Sort (85)
               :                       +- Project (84)
               :                          +- Filter (83)
               :                             +- HashAggregate (82)
               :                                +- Exchange (81)
               :                                   +- HashAggregate (80)
               :                                      +- Scan parquet (79)
               +- SortMergeJoin LeftSemi (104)
                  :- Sort (96)
                  :  +- Exchange (95)
                  :     +- Filter (94)
                  :        +- Scan parquet (93)
                  +- Sort (103)
                     +- Project (102)
                        +- Filter (101)
                           +- HashAggregate (100)
                              +- Exchange (99)
                                 +- HashAggregate (98)
                                    +- Scan parquet (97)


(1) Scan parquet
Output [2]: [c_custkey#X, c_name#X]
Batched: true
Location: InMemoryFileIndex [*]
PushedFilters: [IsNotNull(c_custkey)]
ReadSchema: struct<c_custkey:bigint,c_name:string>

(2) FilterExecTransformer
Input [2]: [c_custkey#X, c_name#X]
Arguments: isnotnull(c_custkey#X)

(3) ProjectExecTransformer
Output [3]: [hash(c_custkey#X, 42) AS hash_partition_key#X, c_custkey#X, c_name#X]
Input [2]: [c_custkey#X, c_name#X]

(4) WholeStageCodegenTransformer (X)
Input [3]: [hash_partition_key#X, c_custkey#X, c_name#X]
Arguments: false

(5) VeloxAppendBatches
Input [3]: [hash_partition_key#X, c_custkey#X, c_name#X]
Arguments: X

(6) ColumnarExchange
Input [3]: [hash_partition_key#X, c_custkey#X, c_name#X]
Arguments: hashpartitioning(c_custkey#X, 1), ENSURE_REQUIREMENTS, [c_custkey#X, c_name#X], [plan_id=X], [id=#X]

(7) ShuffleQueryStage
Output [2]: [c_custkey#X, c_name#X]
Arguments: X

(8) InputAdapter
Input [2]: [c_custkey#X, c_name#X]

(9) InputIteratorTransformer
Input [2]: [c_custkey#X, c_name#X]

(10) Scan parquet
Output [4]: [o_orderkey#X, o_custkey#X, o_totalprice#X, o_orderdate#X]
Batched: true
Location: InMemoryFileIndex [*]
PushedFilters: [IsNotNull(o_custkey), IsNotNull(o_orderkey)]
ReadSchema: struct<o_orderkey:bigint,o_custkey:bigint,o_totalprice:decimal(12,2),o_orderdate:date>

(11) FilterExecTransformer
Input [4]: [o_orderkey#X, o_custkey#X, o_totalprice#X, o_orderdate#X]
Arguments: (isnotnull(o_custkey#X) AND isnotnull(o_orderkey#X))

(12) ProjectExecTransformer
Output [5]: [hash(o_orderkey#X, 42) AS hash_partition_key#X, o_orderkey#X, o_custkey#X, o_totalprice#X, o_orderdate#X]
Input [4]: [o_orderkey#X, o_custkey#X, o_totalprice#X, o_orderdate#X]

(13) WholeStageCodegenTransformer (X)
Input [5]: [hash_partition_key#X, o_orderkey#X, o_custkey#X, o_totalprice#X, o_orderdate#X]
Arguments: false

(14) VeloxAppendBatches
Input [5]: [hash_partition_key#X, o_orderkey#X, o_custkey#X, o_totalprice#X, o_orderdate#X]
Arguments: X

(15) ColumnarExchange
Input [5]: [hash_partition_key#X, o_orderkey#X, o_custkey#X, o_totalprice#X, o_orderdate#X]
Arguments: hashpartitioning(o_orderkey#X, 1), ENSURE_REQUIREMENTS, [o_orderkey#X, o_custkey#X, o_totalprice#X, o_orderdate#X], [plan_id=X], [id=#X]

(16) ShuffleQueryStage
Output [4]: [o_orderkey#X, o_custkey#X, o_totalprice#X, o_orderdate#X]
Arguments: X

(17) InputAdapter
Input [4]: [o_orderkey#X, o_custkey#X, o_totalprice#X, o_orderdate#X]

(18) InputIteratorTransformer
Input [4]: [o_orderkey#X, o_custkey#X, o_totalprice#X, o_orderdate#X]

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

(20) FlushableHashAggregateExecTransformer
Input [2]: [l_orderkey#X, l_quantity#X]
Keys [1]: [l_orderkey#X]
Functions [1]: [partial_sum(l_quantity#X)]
Aggregate Attributes [2]: [sum#X, isEmpty#X]
Results [3]: [l_orderkey#X, sum#X, isEmpty#X]

(21) ProjectExecTransformer
Output [4]: [hash(l_orderkey#X, 42) AS hash_partition_key#X, l_orderkey#X, sum#X, isEmpty#X]
Input [3]: [l_orderkey#X, sum#X, isEmpty#X]

(22) WholeStageCodegenTransformer (X)
Input [4]: [hash_partition_key#X, l_orderkey#X, sum#X, isEmpty#X]
Arguments: false

(23) VeloxAppendBatches
Input [4]: [hash_partition_key#X, l_orderkey#X, sum#X, isEmpty#X]
Arguments: X

(24) ColumnarExchange
Input [4]: [hash_partition_key#X, l_orderkey#X, sum#X, isEmpty#X]
Arguments: hashpartitioning(l_orderkey#X, 1), ENSURE_REQUIREMENTS, [l_orderkey#X, sum#X, isEmpty#X], [plan_id=X], [id=#X]

(25) ShuffleQueryStage
Output [3]: [l_orderkey#X, sum#X, isEmpty#X]
Arguments: X

(26) InputAdapter
Input [3]: [l_orderkey#X, sum#X, isEmpty#X]

(27) InputIteratorTransformer
Input [3]: [l_orderkey#X, sum#X, isEmpty#X]

(28) RegularHashAggregateExecTransformer
Input [3]: [l_orderkey#X, sum#X, isEmpty#X]
Keys [1]: [l_orderkey#X]
Functions [1]: [sum(l_quantity#X)]
Aggregate Attributes [1]: [sum(l_quantity#X)#X]
Results [2]: [l_orderkey#X, sum(l_quantity#X)#X AS sum(l_quantity#X)#X]

(29) FilterExecTransformer
Input [2]: [l_orderkey#X, sum(l_quantity#X)#X]
Arguments: (isnotnull(sum(l_quantity#X)#X) AND (sum(l_quantity#X)#X > 300.00))

(30) ProjectExecTransformer
Output [1]: [l_orderkey#X]
Input [2]: [l_orderkey#X, sum(l_quantity#X)#X]

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

(32) ProjectExecTransformer
Output [5]: [hash(o_custkey#X, 42) AS hash_partition_key#X, o_orderkey#X, o_custkey#X, o_totalprice#X, o_orderdate#X]
Input [4]: [o_orderkey#X, o_custkey#X, o_totalprice#X, o_orderdate#X]

(33) WholeStageCodegenTransformer (X)
Input [5]: [hash_partition_key#X, o_orderkey#X, o_custkey#X, o_totalprice#X, o_orderdate#X]
Arguments: false

(34) VeloxAppendBatches
Input [5]: [hash_partition_key#X, o_orderkey#X, o_custkey#X, o_totalprice#X, o_orderdate#X]
Arguments: X

(35) ColumnarExchange
Input [5]: [hash_partition_key#X, o_orderkey#X, o_custkey#X, o_totalprice#X, o_orderdate#X]
Arguments: hashpartitioning(o_custkey#X, 1), ENSURE_REQUIREMENTS, [o_orderkey#X, o_custkey#X, o_totalprice#X, o_orderdate#X], [plan_id=X], [id=#X]

(36) ShuffleQueryStage
Output [4]: [o_orderkey#X, o_custkey#X, o_totalprice#X, o_orderdate#X]
Arguments: X

(37) InputAdapter
Input [4]: [o_orderkey#X, o_custkey#X, o_totalprice#X, o_orderdate#X]

(38) InputIteratorTransformer
Input [4]: [o_orderkey#X, o_custkey#X, o_totalprice#X, o_orderdate#X]

(39) ShuffledHashJoinExecTransformer
Left keys [1]: [c_custkey#X]
Right keys [1]: [o_custkey#X]
Join condition: None

(40) ProjectExecTransformer
Output [6]: [hash(o_orderkey#X, 42) AS hash_partition_key#X, c_custkey#X, c_name#X, o_orderkey#X, o_totalprice#X, o_orderdate#X]
Input [6]: [c_custkey#X, c_name#X, o_orderkey#X, o_custkey#X, o_totalprice#X, o_orderdate#X]

(41) WholeStageCodegenTransformer (X)
Input [6]: [hash_partition_key#X, c_custkey#X, c_name#X, o_orderkey#X, o_totalprice#X, o_orderdate#X]
Arguments: false

(42) VeloxAppendBatches
Input [6]: [hash_partition_key#X, c_custkey#X, c_name#X, o_orderkey#X, o_totalprice#X, o_orderdate#X]
Arguments: X

(43) ColumnarExchange
Input [6]: [hash_partition_key#X, c_custkey#X, c_name#X, o_orderkey#X, o_totalprice#X, o_orderdate#X]
Arguments: hashpartitioning(o_orderkey#X, 1), ENSURE_REQUIREMENTS, [c_custkey#X, c_name#X, o_orderkey#X, o_totalprice#X, o_orderdate#X], [plan_id=X], [id=#X]

(44) ShuffleQueryStage
Output [5]: [c_custkey#X, c_name#X, o_orderkey#X, o_totalprice#X, o_orderdate#X]
Arguments: X

(45) InputAdapter
Input [5]: [c_custkey#X, c_name#X, o_orderkey#X, o_totalprice#X, o_orderdate#X]

(46) InputIteratorTransformer
Input [5]: [c_custkey#X, c_name#X, o_orderkey#X, o_totalprice#X, o_orderdate#X]

(47) Scan parquet
Output [2]: [l_orderkey#X, l_quantity#X]
Batched: true
Location: InMemoryFileIndex [*]
PushedFilters: [IsNotNull(l_orderkey)]
ReadSchema: struct<l_orderkey:bigint,l_quantity:decimal(12,2)>

(48) FilterExecTransformer
Input [2]: [l_orderkey#X, l_quantity#X]
Arguments: isnotnull(l_orderkey#X)

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

(50) WholeStageCodegenTransformer (X)
Input [3]: [hash_partition_key#X, l_orderkey#X, l_quantity#X]
Arguments: false

(51) VeloxAppendBatches
Input [3]: [hash_partition_key#X, l_orderkey#X, l_quantity#X]
Arguments: X

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

(53) ShuffleQueryStage
Output [2]: [l_orderkey#X, l_quantity#X]
Arguments: X

(54) InputAdapter
Input [2]: [l_orderkey#X, l_quantity#X]

(55) InputIteratorTransformer
Input [2]: [l_orderkey#X, l_quantity#X]

(56) ReusedExchange [Reuses operator id: 24]
Output [3]: [l_orderkey#X, sum#X, isEmpty#X]

(57) ShuffleQueryStage
Output [3]: [l_orderkey#X, sum#X, isEmpty#X]
Arguments: X

(58) InputAdapter
Input [3]: [l_orderkey#X, sum#X, isEmpty#X]

(59) InputIteratorTransformer
Input [3]: [l_orderkey#X, sum#X, isEmpty#X]

(60) RegularHashAggregateExecTransformer
Input [3]: [l_orderkey#X, sum#X, isEmpty#X]
Keys [1]: [l_orderkey#X]
Functions [1]: [sum(l_quantity#X)]
Aggregate Attributes [1]: [sum(l_quantity#X)#X]
Results [2]: [l_orderkey#X, sum(l_quantity#X)#X AS sum(l_quantity#X)#X]

(61) FilterExecTransformer
Input [2]: [l_orderkey#X, sum(l_quantity#X)#X]
Arguments: (isnotnull(sum(l_quantity#X)#X) AND (sum(l_quantity#X)#X > 300.00))

(62) ProjectExecTransformer
Output [1]: [l_orderkey#X]
Input [2]: [l_orderkey#X, sum(l_quantity#X)#X]

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

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

(65) ProjectExecTransformer
Output [6]: [c_custkey#X, c_name#X, o_orderkey#X, o_totalprice#X, o_orderdate#X, l_quantity#X]
Input [7]: [c_custkey#X, c_name#X, o_orderkey#X, o_totalprice#X, o_orderdate#X, l_orderkey#X, l_quantity#X]

(66) RegularHashAggregateExecTransformer
Input [6]: [c_custkey#X, c_name#X, o_orderkey#X, o_totalprice#X, o_orderdate#X, l_quantity#X]
Keys [5]: [c_name#X, c_custkey#X, o_orderkey#X, o_orderdate#X, o_totalprice#X]
Functions [1]: [partial_sum(l_quantity#X)]
Aggregate Attributes [2]: [sum#X, isEmpty#X]
Results [7]: [c_name#X, c_custkey#X, o_orderkey#X, o_orderdate#X, o_totalprice#X, sum#X, isEmpty#X]

(67) RegularHashAggregateExecTransformer
Input [7]: [c_name#X, c_custkey#X, o_orderkey#X, o_orderdate#X, o_totalprice#X, sum#X, isEmpty#X]
Keys [5]: [c_name#X, c_custkey#X, o_orderkey#X, o_orderdate#X, o_totalprice#X]
Functions [1]: [sum(l_quantity#X)]
Aggregate Attributes [1]: [sum(l_quantity#X)#X]
Results [6]: [c_name#X, c_custkey#X, o_orderkey#X, o_orderdate#X, o_totalprice#X, sum(l_quantity#X)#X AS sum(l_quantity)#X]

(68) WholeStageCodegenTransformer (X)
Input [6]: [c_name#X, c_custkey#X, o_orderkey#X, o_orderdate#X, o_totalprice#X, sum(l_quantity)#X]
Arguments: false

(69) TakeOrderedAndProjectExecTransformer
Input [6]: [c_name#X, c_custkey#X, o_orderkey#X, o_orderdate#X, o_totalprice#X, sum(l_quantity)#X]
Arguments: X, [o_totalprice#X DESC NULLS LAST, o_orderdate#X ASC NULLS FIRST], [c_name#X, c_custkey#X, o_orderkey#X, o_orderdate#X, o_totalprice#X, sum(l_quantity)#X], 0

(70) VeloxColumnarToRowExec
Input [6]: [c_name#X, c_custkey#X, o_orderkey#X, o_orderdate#X, o_totalprice#X, sum(l_quantity)#X]

(71) Scan parquet
Output [2]: [c_custkey#X, c_name#X]
Batched: true
Location: InMemoryFileIndex [*]
PushedFilters: [IsNotNull(c_custkey)]
ReadSchema: struct<c_custkey:bigint,c_name:string>

(72) Filter
Input [2]: [c_custkey#X, c_name#X]
Condition : isnotnull(c_custkey#X)

(73) Exchange
Input [2]: [c_custkey#X, c_name#X]
Arguments: hashpartitioning(c_custkey#X, 1), ENSURE_REQUIREMENTS, [plan_id=X]

(74) Sort
Input [2]: [c_custkey#X, c_name#X]
Arguments: [c_custkey#X ASC NULLS FIRST], false, 0

(75) Scan parquet
Output [4]: [o_orderkey#X, o_custkey#X, o_totalprice#X, o_orderdate#X]
Batched: true
Location: InMemoryFileIndex [*]
PushedFilters: [IsNotNull(o_custkey), IsNotNull(o_orderkey)]
ReadSchema: struct<o_orderkey:bigint,o_custkey:bigint,o_totalprice:decimal(12,2),o_orderdate:date>

(76) Filter
Input [4]: [o_orderkey#X, o_custkey#X, o_totalprice#X, o_orderdate#X]
Condition : (isnotnull(o_custkey#X) AND isnotnull(o_orderkey#X))

(77) Exchange
Input [4]: [o_orderkey#X, o_custkey#X, o_totalprice#X, o_orderdate#X]
Arguments: hashpartitioning(o_orderkey#X, 1), ENSURE_REQUIREMENTS, [plan_id=X]

(78) Sort
Input [4]: [o_orderkey#X, o_custkey#X, o_totalprice#X, o_orderdate#X]
Arguments: [o_orderkey#X ASC NULLS FIRST], false, 0

(79) Scan parquet
Output [2]: [l_orderkey#X, l_quantity#X]
Batched: true
Location: InMemoryFileIndex [*]
ReadSchema: struct<l_orderkey:bigint,l_quantity:decimal(12,2)>

(80) HashAggregate
Input [2]: [l_orderkey#X, l_quantity#X]
Keys [1]: [l_orderkey#X]
Functions [1]: [partial_sum(l_quantity#X)]
Aggregate Attributes [2]: [sum#X, isEmpty#X]
Results [3]: [l_orderkey#X, sum#X, isEmpty#X]

(81) Exchange
Input [3]: [l_orderkey#X, sum#X, isEmpty#X]
Arguments: hashpartitioning(l_orderkey#X, 1), ENSURE_REQUIREMENTS, [plan_id=X]

(82) HashAggregate
Input [3]: [l_orderkey#X, sum#X, isEmpty#X]
Keys [1]: [l_orderkey#X]
Functions [1]: [sum(l_quantity#X)]
Aggregate Attributes [1]: [sum(l_quantity#X)#X]
Results [2]: [l_orderkey#X, sum(l_quantity#X)#X AS sum(l_quantity#X)#X]

(83) Filter
Input [2]: [l_orderkey#X, sum(l_quantity#X)#X]
Condition : (isnotnull(sum(l_quantity#X)#X) AND (sum(l_quantity#X)#X > 300.00))

(84) Project
Output [1]: [l_orderkey#X]
Input [2]: [l_orderkey#X, sum(l_quantity#X)#X]

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

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

(87) Exchange
Input [4]: [o_orderkey#X, o_custkey#X, o_totalprice#X, o_orderdate#X]
Arguments: hashpartitioning(o_custkey#X, 1), ENSURE_REQUIREMENTS, [plan_id=X]

(88) Sort
Input [4]: [o_orderkey#X, o_custkey#X, o_totalprice#X, o_orderdate#X]
Arguments: [o_custkey#X ASC NULLS FIRST], false, 0

(89) SortMergeJoin
Left keys [1]: [c_custkey#X]
Right keys [1]: [o_custkey#X]
Join condition: None

(90) Project
Output [5]: [c_custkey#X, c_name#X, o_orderkey#X, o_totalprice#X, o_orderdate#X]
Input [6]: [c_custkey#X, c_name#X, o_orderkey#X, o_custkey#X, o_totalprice#X, o_orderdate#X]

(91) Exchange
Input [5]: [c_custkey#X, c_name#X, o_orderkey#X, o_totalprice#X, o_orderdate#X]
Arguments: hashpartitioning(o_orderkey#X, 1), ENSURE_REQUIREMENTS, [plan_id=X]

(92) Sort
Input [5]: [c_custkey#X, c_name#X, o_orderkey#X, o_totalprice#X, o_orderdate#X]
Arguments: [o_orderkey#X ASC NULLS FIRST], false, 0

(93) Scan parquet
Output [2]: [l_orderkey#X, l_quantity#X]
Batched: true
Location: InMemoryFileIndex [*]
PushedFilters: [IsNotNull(l_orderkey)]
ReadSchema: struct<l_orderkey:bigint,l_quantity:decimal(12,2)>

(94) Filter
Input [2]: [l_orderkey#X, l_quantity#X]
Condition : isnotnull(l_orderkey#X)

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

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

(97) Scan parquet
Output [2]: [l_orderkey#X, l_quantity#X]
Batched: true
Location: InMemoryFileIndex [*]
ReadSchema: struct<l_orderkey:bigint,l_quantity:decimal(12,2)>

(98) HashAggregate
Input [2]: [l_orderkey#X, l_quantity#X]
Keys [1]: [l_orderkey#X]
Functions [1]: [partial_sum(l_quantity#X)]
Aggregate Attributes [2]: [sum#X, isEmpty#X]
Results [3]: [l_orderkey#X, sum#X, isEmpty#X]

(99) Exchange
Input [3]: [l_orderkey#X, sum#X, isEmpty#X]
Arguments: hashpartitioning(l_orderkey#X, 1), ENSURE_REQUIREMENTS, [plan_id=X]

(100) HashAggregate
Input [3]: [l_orderkey#X, sum#X, isEmpty#X]
Keys [1]: [l_orderkey#X]
Functions [1]: [sum(l_quantity#X)]
Aggregate Attributes [1]: [sum(l_quantity#X)#X]
Results [2]: [l_orderkey#X, sum(l_quantity#X)#X AS sum(l_quantity#X)#X]

(101) Filter
Input [2]: [l_orderkey#X, sum(l_quantity#X)#X]
Condition : (isnotnull(sum(l_quantity#X)#X) AND (sum(l_quantity#X)#X > 300.00))

(102) Project
Output [1]: [l_orderkey#X]
Input [2]: [l_orderkey#X, sum(l_quantity#X)#X]

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

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

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

(106) Project
Output [6]: [c_custkey#X, c_name#X, o_orderkey#X, o_totalprice#X, o_orderdate#X, l_quantity#X]
Input [7]: [c_custkey#X, c_name#X, o_orderkey#X, o_totalprice#X, o_orderdate#X, l_orderkey#X, l_quantity#X]

(107) HashAggregate
Input [6]: [c_custkey#X, c_name#X, o_orderkey#X, o_totalprice#X, o_orderdate#X, l_quantity#X]
Keys [5]: [c_name#X, c_custkey#X, o_orderkey#X, o_orderdate#X, o_totalprice#X]
Functions [1]: [partial_sum(l_quantity#X)]
Aggregate Attributes [2]: [sum#X, isEmpty#X]
Results [7]: [c_name#X, c_custkey#X, o_orderkey#X, o_orderdate#X, o_totalprice#X, sum#X, isEmpty#X]

(108) HashAggregate
Input [7]: [c_name#X, c_custkey#X, o_orderkey#X, o_orderdate#X, o_totalprice#X, sum#X, isEmpty#X]
Keys [5]: [c_name#X, c_custkey#X, o_orderkey#X, o_orderdate#X, o_totalprice#X]
Functions [1]: [sum(l_quantity#X)]
Aggregate Attributes [1]: [sum(l_quantity#X)#X]
Results [6]: [c_name#X, c_custkey#X, o_orderkey#X, o_orderdate#X, o_totalprice#X, sum(l_quantity#X)#X AS sum(l_quantity)#X]

(109) TakeOrderedAndProject
Input [6]: [c_name#X, c_custkey#X, o_orderkey#X, o_orderdate#X, o_totalprice#X, sum(l_quantity)#X]
Arguments: X, [o_totalprice#X DESC NULLS LAST, o_orderdate#X ASC NULLS FIRST], [c_name#X, c_custkey#X, o_orderkey#X, o_orderdate#X, o_totalprice#X, sum(l_quantity)#X]

(110) AdaptiveSparkPlan
Output [6]: [c_name#X, c_custkey#X, o_orderkey#X, o_orderdate#X, o_totalprice#X, sum(l_quantity)#X]
Arguments: isFinalPlan=true