== Physical Plan ==
AdaptiveSparkPlan (88)
+- == Final Plan ==
   VeloxColumnarToRowExec (55)
   +- TakeOrderedAndProjectExecTransformer (54)
      +- ^ RegularHashAggregateExecTransformer (52)
         +- ^ InputIteratorTransformer (51)
            +- ShuffleQueryStage (49), Statistics(X)
               +- ColumnarExchange (48)
                  +- VeloxAppendBatches (47)
                     +- ^ ProjectExecTransformer (45)
                        +- ^ FlushableHashAggregateExecTransformer (44)
                           +- ^ ProjectExecTransformer (43)
                              +- ^ BroadcastHashJoinExecTransformer Inner BuildRight (42)
                                 :- ^ ProjectExecTransformer (29)
                                 :  +- ^ BroadcastHashJoinExecTransformer Inner BuildLeft (28)
                                 :     :- ^ InputIteratorTransformer (7)
                                 :     :  +- BroadcastQueryStage (5), Statistics(X)
                                 :     :     +- ColumnarBroadcastExchange (4)
                                 :     :        +- ^ NoopFilter (2)
                                 :     :           +- ^ Scan parquet (1)
                                 :     +- ^ BroadcastHashJoinExecTransformer LeftSemi BuildRight (27)
                                 :        :- ^ NoopFilter (9)
                                 :        :  +- ^ Scan parquet (8)
                                 :        +- ^ InputIteratorTransformer (26)
                                 :           +- BroadcastQueryStage (24), Statistics(X)
                                 :              +- ColumnarBroadcastExchange (23)
                                 :                 +- ^ ProjectExecTransformer (21)
                                 :                    +- ^ FilterExecTransformer (20)
                                 :                       +- ^ RegularHashAggregateExecTransformer (19)
                                 :                          +- ^ InputIteratorTransformer (18)
                                 :                             +- ShuffleQueryStage (16), Statistics(X)
                                 :                                +- ColumnarExchange (15)
                                 :                                   +- VeloxAppendBatches (14)
                                 :                                      +- ^ ProjectExecTransformer (12)
                                 :                                         +- ^ FlushableHashAggregateExecTransformer (11)
                                 :                                            +- ^ Scan parquet (10)
                                 +- ^ InputIteratorTransformer (41)
                                    +- BroadcastQueryStage (39), Statistics(X)
                                       +- ColumnarBroadcastExchange (38)
                                          +- ^ BroadcastHashJoinExecTransformer LeftSemi BuildRight (36)
                                             :- ^ NoopFilter (31)
                                             :  +- ^ Scan parquet (30)
                                             +- ^ InputIteratorTransformer (35)
                                                +- BroadcastQueryStage (33), Statistics(X)
                                                   +- ReusedExchange (32)
+- == Initial Plan ==
   TakeOrderedAndProject (87)
   +- HashAggregate (86)
      +- Exchange (85)
         +- HashAggregate (84)
            +- Project (83)
               +- BroadcastHashJoin Inner BuildRight (82)
                  :- Project (70)
                  :  +- BroadcastHashJoin Inner BuildLeft (69)
                  :     :- BroadcastExchange (58)
                  :     :  +- Filter (57)
                  :     :     +- Scan parquet (56)
                  :     +- BroadcastHashJoin LeftSemi BuildRight (68)
                  :        :- Filter (60)
                  :        :  +- Scan parquet (59)
                  :        +- BroadcastExchange (67)
                  :           +- Project (66)
                  :              +- Filter (65)
                  :                 +- HashAggregate (64)
                  :                    +- Exchange (63)
                  :                       +- HashAggregate (62)
                  :                          +- Scan parquet (61)
                  +- BroadcastExchange (81)
                     +- BroadcastHashJoin LeftSemi BuildRight (80)
                        :- Filter (72)
                        :  +- Scan parquet (71)
                        +- BroadcastExchange (79)
                           +- Project (78)
                              +- Filter (77)
                                 +- HashAggregate (76)
                                    +- Exchange (75)
                                       +- HashAggregate (74)
                                          +- Scan parquet (73)


(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) NoopFilter
Input [2]: [c_custkey#X, c_name#X]
Arguments: [c_custkey#X, c_name#X]

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

(4) ColumnarBroadcastExchange
Input [2]: [c_custkey#X, c_name#X]
Arguments: HashedRelationBroadcastMode(List(input[0, bigint, false]),false), [plan_id=X]

(5) BroadcastQueryStage
Output [2]: [c_custkey#X, c_name#X]
Arguments: X

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

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

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

(9) NoopFilter
Input [4]: [o_orderkey#X, o_custkey#X, o_totalprice#X, o_orderdate#X]
Arguments: [o_orderkey#X, o_custkey#X, o_totalprice#X, o_orderdate#X]

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

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

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

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

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

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

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

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

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

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

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

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

(22) WholeStageCodegenTransformer (X)
Input [1]: [l_orderkey#X]
Arguments: false

(23) ColumnarBroadcastExchange
Input [1]: [l_orderkey#X]
Arguments: HashedRelationBroadcastMode(List(input[0, bigint, true]),false), [plan_id=X]

(24) BroadcastQueryStage
Output [1]: [l_orderkey#X]
Arguments: X

(25) InputAdapter
Input [1]: [l_orderkey#X]

(26) InputIteratorTransformer
Input [1]: [l_orderkey#X]

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

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

(29) ProjectExecTransformer
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]

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

(31) NoopFilter
Input [2]: [l_orderkey#X, l_quantity#X]
Arguments: [l_orderkey#X, l_quantity#X]

(32) ReusedExchange [Reuses operator id: 23]
Output [1]: [l_orderkey#X]

(33) BroadcastQueryStage
Output [1]: [l_orderkey#X]
Arguments: X

(34) InputAdapter
Input [1]: [l_orderkey#X]

(35) InputIteratorTransformer
Input [1]: [l_orderkey#X]

(36) BroadcastHashJoinExecTransformer
Left keys [1]: [l_orderkey#X]
Right keys [1]: [l_orderkey#X]
Join condition: None

(37) WholeStageCodegenTransformer (X)
Input [2]: [l_orderkey#X, l_quantity#X]
Arguments: false

(38) ColumnarBroadcastExchange
Input [2]: [l_orderkey#X, l_quantity#X]
Arguments: HashedRelationBroadcastMode(List(input[0, bigint, false]),false), [plan_id=X]

(39) BroadcastQueryStage
Output [2]: [l_orderkey#X, l_quantity#X]
Arguments: X

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

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

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

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

(44) FlushableHashAggregateExecTransformer
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]

(45) ProjectExecTransformer
Output [8]: [hash(c_name#X, c_custkey#X, o_orderkey#X, o_orderdate#X, o_totalprice#X, 42) AS hash_partition_key#X, c_name#X, c_custkey#X, o_orderkey#X, o_orderdate#X, o_totalprice#X, sum#X, isEmpty#X]
Input [7]: [c_name#X, c_custkey#X, o_orderkey#X, o_orderdate#X, o_totalprice#X, sum#X, isEmpty#X]

(46) WholeStageCodegenTransformer (X)
Input [8]: [hash_partition_key#X, c_name#X, c_custkey#X, o_orderkey#X, o_orderdate#X, o_totalprice#X, sum#X, isEmpty#X]
Arguments: false

(47) VeloxAppendBatches
Input [8]: [hash_partition_key#X, c_name#X, c_custkey#X, o_orderkey#X, o_orderdate#X, o_totalprice#X, sum#X, isEmpty#X]
Arguments: X

(48) ColumnarExchange
Input [8]: [hash_partition_key#X, c_name#X, c_custkey#X, o_orderkey#X, o_orderdate#X, o_totalprice#X, sum#X, isEmpty#X]
Arguments: hashpartitioning(c_name#X, c_custkey#X, o_orderkey#X, o_orderdate#X, o_totalprice#X, 1), ENSURE_REQUIREMENTS, [c_name#X, c_custkey#X, o_orderkey#X, o_orderdate#X, o_totalprice#X, sum#X, isEmpty#X], [plan_id=X], [id=#X]

(49) ShuffleQueryStage
Output [7]: [c_name#X, c_custkey#X, o_orderkey#X, o_orderdate#X, o_totalprice#X, sum#X, isEmpty#X]
Arguments: X

(50) InputAdapter
Input [7]: [c_name#X, c_custkey#X, o_orderkey#X, o_orderdate#X, o_totalprice#X, sum#X, isEmpty#X]

(51) InputIteratorTransformer
Input [7]: [c_name#X, c_custkey#X, o_orderkey#X, o_orderdate#X, o_totalprice#X, sum#X, isEmpty#X]

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

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

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

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

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

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

(58) BroadcastExchange
Input [2]: [c_custkey#X, c_name#X]
Arguments: HashedRelationBroadcastMode(List(input[0, bigint, false]),false), [plan_id=X]

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

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

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

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

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

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

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

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

(67) BroadcastExchange
Input [1]: [l_orderkey#X]
Arguments: HashedRelationBroadcastMode(List(input[0, bigint, true]),false), [plan_id=X]

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

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

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

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

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

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

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

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

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

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

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

(79) BroadcastExchange
Input [1]: [l_orderkey#X]
Arguments: HashedRelationBroadcastMode(List(input[0, bigint, true]),false), [plan_id=X]

(80) BroadcastHashJoin
Left keys [1]: [l_orderkey#X]
Right keys [1]: [l_orderkey#X]
Join condition: None

(81) BroadcastExchange
Input [2]: [l_orderkey#X, l_quantity#X]
Arguments: HashedRelationBroadcastMode(List(input[0, bigint, false]),false), [plan_id=X]

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

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

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

(85) Exchange
Input [7]: [c_name#X, c_custkey#X, o_orderkey#X, o_orderdate#X, o_totalprice#X, sum#X, isEmpty#X]
Arguments: hashpartitioning(c_name#X, c_custkey#X, o_orderkey#X, o_orderdate#X, o_totalprice#X, 1), ENSURE_REQUIREMENTS, [plan_id=X]

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

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

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