== Physical Plan ==
AdaptiveSparkPlan (161)
+- == Final Plan ==
   CartesianProduct Inner (101)
   :- CartesianProduct Inner (84)
   :  :- CartesianProduct Inner (67)
   :  :  :- CartesianProduct Inner (50)
   :  :  :  :- CartesianProduct Inner (33)
   :  :  :  :  :- NativeProject (16)
   :  :  :  :  :  +- NativeHashAggregate (15)
   :  :  :  :  :     +- ShuffleQueryStage (14), Statistics(X)
   :  :  :  :  :        +- NativeShuffleExchange (13)
   :  :  :  :  :           +- NativeHashAggregate (12)
   :  :  :  :  :              +- NativeHashAggregate (11)
   :  :  :  :  :                 +- InputAdapter (10)
   :  :  :  :  :                    +- AQEShuffleRead (9)
   :  :  :  :  :                       +- ShuffleQueryStage (8), Statistics(X)
   :  :  :  :  :                          +- NativeShuffleExchange (7)
   :  :  :  :  :                             +- NativeHashAggregate (6)
   :  :  :  :  :                                +- NativeProject (5)
   :  :  :  :  :                                   +- NativeProject (4)
   :  :  :  :  :                                      +- NativeFilter (3)
   :  :  :  :  :                                         +- InputAdapter (2)
   :  :  :  :  :                                            +- NativeParquetScan  (1)
   :  :  :  :  +- NativeProject (32)
   :  :  :  :     +- NativeHashAggregate (31)
   :  :  :  :        +- ShuffleQueryStage (30), Statistics(X)
   :  :  :  :           +- NativeShuffleExchange (29)
   :  :  :  :              +- NativeHashAggregate (28)
   :  :  :  :                 +- NativeHashAggregate (27)
   :  :  :  :                    +- InputAdapter (26)
   :  :  :  :                       +- AQEShuffleRead (25)
   :  :  :  :                          +- ShuffleQueryStage (24), Statistics(X)
   :  :  :  :                             +- NativeShuffleExchange (23)
   :  :  :  :                                +- NativeHashAggregate (22)
   :  :  :  :                                   +- NativeProject (21)
   :  :  :  :                                      +- NativeProject (20)
   :  :  :  :                                         +- NativeFilter (19)
   :  :  :  :                                            +- InputAdapter (18)
   :  :  :  :                                               +- NativeParquetScan  (17)
   :  :  :  +- NativeProject (49)
   :  :  :     +- NativeHashAggregate (48)
   :  :  :        +- ShuffleQueryStage (47), Statistics(X)
   :  :  :           +- NativeShuffleExchange (46)
   :  :  :              +- NativeHashAggregate (45)
   :  :  :                 +- NativeHashAggregate (44)
   :  :  :                    +- InputAdapter (43)
   :  :  :                       +- AQEShuffleRead (42)
   :  :  :                          +- ShuffleQueryStage (41), Statistics(X)
   :  :  :                             +- NativeShuffleExchange (40)
   :  :  :                                +- NativeHashAggregate (39)
   :  :  :                                   +- NativeProject (38)
   :  :  :                                      +- NativeProject (37)
   :  :  :                                         +- NativeFilter (36)
   :  :  :                                            +- InputAdapter (35)
   :  :  :                                               +- NativeParquetScan  (34)
   :  :  +- NativeProject (66)
   :  :     +- NativeHashAggregate (65)
   :  :        +- ShuffleQueryStage (64), Statistics(X)
   :  :           +- NativeShuffleExchange (63)
   :  :              +- NativeHashAggregate (62)
   :  :                 +- NativeHashAggregate (61)
   :  :                    +- InputAdapter (60)
   :  :                       +- AQEShuffleRead (59)
   :  :                          +- ShuffleQueryStage (58), Statistics(X)
   :  :                             +- NativeShuffleExchange (57)
   :  :                                +- NativeHashAggregate (56)
   :  :                                   +- NativeProject (55)
   :  :                                      +- NativeProject (54)
   :  :                                         +- NativeFilter (53)
   :  :                                            +- InputAdapter (52)
   :  :                                               +- NativeParquetScan  (51)
   :  +- NativeProject (83)
   :     +- NativeHashAggregate (82)
   :        +- ShuffleQueryStage (81), Statistics(X)
   :           +- NativeShuffleExchange (80)
   :              +- NativeHashAggregate (79)
   :                 +- NativeHashAggregate (78)
   :                    +- InputAdapter (77)
   :                       +- AQEShuffleRead (76)
   :                          +- ShuffleQueryStage (75), Statistics(X)
   :                             +- NativeShuffleExchange (74)
   :                                +- NativeHashAggregate (73)
   :                                   +- NativeProject (72)
   :                                      +- NativeProject (71)
   :                                         +- NativeFilter (70)
   :                                            +- InputAdapter (69)
   :                                               +- NativeParquetScan  (68)
   +- NativeProject (100)
      +- NativeHashAggregate (99)
         +- ShuffleQueryStage (98), Statistics(X)
            +- NativeShuffleExchange (97)
               +- NativeHashAggregate (96)
                  +- NativeHashAggregate (95)
                     +- InputAdapter (94)
                        +- AQEShuffleRead (93)
                           +- ShuffleQueryStage (92), Statistics(X)
                              +- NativeShuffleExchange (91)
                                 +- NativeHashAggregate (90)
                                    +- NativeProject (89)
                                       +- NativeProject (88)
                                          +- NativeFilter (87)
                                             +- InputAdapter (86)
                                                +- NativeParquetScan  (85)
+- == Initial Plan ==
   CartesianProduct Inner (160)
   :- CartesianProduct Inner (150)
   :  :- CartesianProduct Inner (140)
   :  :  :- CartesianProduct Inner (130)
   :  :  :  :- CartesianProduct Inner (120)
   :  :  :  :  :- HashAggregate (110)
   :  :  :  :  :  +- Exchange (109)
   :  :  :  :  :     +- HashAggregate (108)
   :  :  :  :  :        +- HashAggregate (107)
   :  :  :  :  :           +- Exchange (106)
   :  :  :  :  :              +- HashAggregate (105)
   :  :  :  :  :                 +- Project (104)
   :  :  :  :  :                    +- Filter (103)
   :  :  :  :  :                       +- Scan parquet (102)
   :  :  :  :  +- HashAggregate (119)
   :  :  :  :     +- Exchange (118)
   :  :  :  :        +- HashAggregate (117)
   :  :  :  :           +- HashAggregate (116)
   :  :  :  :              +- Exchange (115)
   :  :  :  :                 +- HashAggregate (114)
   :  :  :  :                    +- Project (113)
   :  :  :  :                       +- Filter (112)
   :  :  :  :                          +- Scan parquet (111)
   :  :  :  +- HashAggregate (129)
   :  :  :     +- Exchange (128)
   :  :  :        +- HashAggregate (127)
   :  :  :           +- HashAggregate (126)
   :  :  :              +- Exchange (125)
   :  :  :                 +- HashAggregate (124)
   :  :  :                    +- Project (123)
   :  :  :                       +- Filter (122)
   :  :  :                          +- Scan parquet (121)
   :  :  +- HashAggregate (139)
   :  :     +- Exchange (138)
   :  :        +- HashAggregate (137)
   :  :           +- HashAggregate (136)
   :  :              +- Exchange (135)
   :  :                 +- HashAggregate (134)
   :  :                    +- Project (133)
   :  :                       +- Filter (132)
   :  :                          +- Scan parquet (131)
   :  +- HashAggregate (149)
   :     +- Exchange (148)
   :        +- HashAggregate (147)
   :           +- HashAggregate (146)
   :              +- Exchange (145)
   :                 +- HashAggregate (144)
   :                    +- Project (143)
   :                       +- Filter (142)
   :                          +- Scan parquet (141)
   +- HashAggregate (159)
      +- Exchange (158)
         +- HashAggregate (157)
            +- HashAggregate (156)
               +- Exchange (155)
                  +- HashAggregate (154)
                     +- Project (153)
                        +- Filter (152)
                           +- Scan parquet (151)


(102) Scan parquet
Output [4]: [ss_quantity#1, ss_wholesale_cost#2, ss_list_price#3, ss_coupon_amt#4]
Batched: true
Location: InMemoryFileIndex [file:/<warehouse_dir>]
PushedFilters: [IsNotNull(ss_quantity), GreaterThanOrEqual(ss_quantity,0), LessThanOrEqual(ss_quantity,5), Or(Or(And(GreaterThanOrEqual(ss_list_price,8.00),LessThanOrEqual(ss_list_price,18.00)),And(GreaterThanOrEqual(ss_coupon_amt,459.00),LessThanOrEqual(ss_coupon_amt,1459.00))),And(GreaterThanOrEqual(ss_wholesale_cost,57.00),LessThanOrEqual(ss_wholesale_cost,77.00)))]
ReadSchema: struct<ss_quantity:int,ss_wholesale_cost:decimal(7,2),ss_list_price:decimal(7,2),ss_coupon_amt:decimal(7,2)>

(2) InputAdapter
Input [4]: [ss_quantity#1, ss_wholesale_cost#2, ss_list_price#3, ss_coupon_amt#4]
Arguments: [#1, #2, #3, #4]

(3) NativeFilter
Input [4]: [#1#1, #2#2, #3#3, #4#4]
Condition : (((isnotnull(ss_quantity#1) AND (ss_quantity#1 >= 0)) AND (ss_quantity#1 <= 5)) AND ((((ss_list_price#3 >= 8.00) AND (ss_list_price#3 <= 18.00)) OR ((ss_coupon_amt#4 >= 459.00) AND (ss_coupon_amt#4 <= 1459.00))) OR ((ss_wholesale_cost#2 >= 57.00) AND (ss_wholesale_cost#2 <= 77.00))))

(4) NativeProject
Output [1]: [ss_list_price#3]
Input [4]: [#1#1, #2#2, #3#3, #4#4]

(5) NativeProject
Output [2]: [ss_list_price#3 AS ss_list_price#3, UnscaledValue(ss_list_price#3) AS _c1#5]
Input [1]: [ss_list_price#3]

(6) NativeHashAggregate
Input [2]: [ss_list_price#3, _c1#5]
Keys [1]: [ss_list_price#3]
Functions [2]: [partial_avg(_c1#5), partial_count(ss_list_price#3)]
Aggregate Attributes [2]: [avg(UnscaledValue(ss_list_price#3))#6, count(ss_list_price#3)#7]
Results [4]: [ss_list_price#3, #8, #9, #9]

(7) NativeShuffleExchange
Input [4]: [ss_list_price#3, #8, #9, #9]
Arguments: hashpartitioning(ss_list_price#3, 100), ENSURE_REQUIREMENTS, [plan_id=1]

(8) ShuffleQueryStage
Output [4]: [ss_list_price#3, #8, #9, #9]
Arguments: X

(9) AQEShuffleRead
Input [4]: [ss_list_price#3, #8, #9, #9]
Arguments: coalesced

(10) InputAdapter
Input [4]: [ss_list_price#3, #8, #9, #9]

(11) NativeHashAggregate
Input [4]: [ss_list_price#3, #8, #9, #9]
Keys [1]: [ss_list_price#3]
Functions [2]: [merge_avg(UnscaledValue(ss_list_price#3)), merge_count(ss_list_price#3)]
Aggregate Attributes [2]: [avg(UnscaledValue(ss_list_price#3))#6, count(ss_list_price#3)#7]
Results [4]: [ss_list_price#3, #8, #9, #9]

(12) NativeHashAggregate
Input [4]: [ss_list_price#3, #8, #9, #9]
Keys: []
Functions [3]: [merge_avg(UnscaledValue(ss_list_price#3)), merge_count(ss_list_price#3), partial_count(distinct ss_list_price#3)]
Aggregate Attributes [3]: [avg(UnscaledValue(ss_list_price#3))#6, count(ss_list_price#3)#7, count(ss_list_price#3)#10]
Results [4]: [#8, #9, #9, #9]

(13) NativeShuffleExchange
Input [4]: [#8, #9, #9, #9]
Arguments: SinglePartition, ENSURE_REQUIREMENTS, [plan_id=2]

(14) ShuffleQueryStage
Output [4]: [#8, #9, #9, #9]
Arguments: X

(15) NativeHashAggregate
Input [4]: [#8, #9, #9, #9]
Keys: []
Functions [3]: [avg(UnscaledValue(ss_list_price#3)), count(ss_list_price#3), count(distinct ss_list_price#3)]
Aggregate Attributes [3]: [avg(UnscaledValue(ss_list_price#3))#6, count(ss_list_price#3)#7, count(ss_list_price#3)#10]
Results [3]: [avg(UnscaledValue(ss_list_price#3))#6, count(ss_list_price#3)#7, count(ss_list_price#3)#10]

(16) NativeProject
Output [3]: [cast((avg(UnscaledValue(ss_list_price#3))#6 / 100.0) as decimal(11,6)) AS B1_LP#11, count(ss_list_price#3)#7 AS B1_CNT#12, count(ss_list_price#3)#10 AS B1_CNTD#13]
Input [3]: [avg(UnscaledValue(ss_list_price#3))#6, count(ss_list_price#3)#7, count(ss_list_price#3)#10]

(111) Scan parquet
Output [4]: [ss_quantity#14, ss_wholesale_cost#15, ss_list_price#16, ss_coupon_amt#17]
Batched: true
Location: InMemoryFileIndex [file:/<warehouse_dir>]
PushedFilters: [IsNotNull(ss_quantity), GreaterThanOrEqual(ss_quantity,6), LessThanOrEqual(ss_quantity,10), Or(Or(And(GreaterThanOrEqual(ss_list_price,90.00),LessThanOrEqual(ss_list_price,100.00)),And(GreaterThanOrEqual(ss_coupon_amt,2323.00),LessThanOrEqual(ss_coupon_amt,3323.00))),And(GreaterThanOrEqual(ss_wholesale_cost,31.00),LessThanOrEqual(ss_wholesale_cost,51.00)))]
ReadSchema: struct<ss_quantity:int,ss_wholesale_cost:decimal(7,2),ss_list_price:decimal(7,2),ss_coupon_amt:decimal(7,2)>

(18) InputAdapter
Input [4]: [ss_quantity#14, ss_wholesale_cost#15, ss_list_price#16, ss_coupon_amt#17]
Arguments: [#14, #15, #16, #17]

(19) NativeFilter
Input [4]: [#14#14, #15#15, #16#16, #17#17]
Condition : (((isnotnull(ss_quantity#14) AND (ss_quantity#14 >= 6)) AND (ss_quantity#14 <= 10)) AND ((((ss_list_price#16 >= 90.00) AND (ss_list_price#16 <= 100.00)) OR ((ss_coupon_amt#17 >= 2323.00) AND (ss_coupon_amt#17 <= 3323.00))) OR ((ss_wholesale_cost#15 >= 31.00) AND (ss_wholesale_cost#15 <= 51.00))))

(20) NativeProject
Output [1]: [ss_list_price#16]
Input [4]: [#14#14, #15#15, #16#16, #17#17]

(21) NativeProject
Output [2]: [ss_list_price#16 AS ss_list_price#16, UnscaledValue(ss_list_price#16) AS _c1#18]
Input [1]: [ss_list_price#16]

(22) NativeHashAggregate
Input [2]: [ss_list_price#16, _c1#18]
Keys [1]: [ss_list_price#16]
Functions [2]: [partial_avg(_c1#18), partial_count(ss_list_price#16)]
Aggregate Attributes [2]: [avg(UnscaledValue(ss_list_price#16))#19, count(ss_list_price#16)#20]
Results [4]: [ss_list_price#16, #8, #9, #9]

(23) NativeShuffleExchange
Input [4]: [ss_list_price#16, #8, #9, #9]
Arguments: hashpartitioning(ss_list_price#16, 100), ENSURE_REQUIREMENTS, [plan_id=3]

(24) ShuffleQueryStage
Output [4]: [ss_list_price#16, #8, #9, #9]
Arguments: X

(25) AQEShuffleRead
Input [4]: [ss_list_price#16, #8, #9, #9]
Arguments: coalesced

(26) InputAdapter
Input [4]: [ss_list_price#16, #8, #9, #9]

(27) NativeHashAggregate
Input [4]: [ss_list_price#16, #8, #9, #9]
Keys [1]: [ss_list_price#16]
Functions [2]: [merge_avg(UnscaledValue(ss_list_price#16)), merge_count(ss_list_price#16)]
Aggregate Attributes [2]: [avg(UnscaledValue(ss_list_price#16))#19, count(ss_list_price#16)#20]
Results [4]: [ss_list_price#16, #8, #9, #9]

(28) NativeHashAggregate
Input [4]: [ss_list_price#16, #8, #9, #9]
Keys: []
Functions [3]: [merge_avg(UnscaledValue(ss_list_price#16)), merge_count(ss_list_price#16), partial_count(distinct ss_list_price#16)]
Aggregate Attributes [3]: [avg(UnscaledValue(ss_list_price#16))#19, count(ss_list_price#16)#20, count(ss_list_price#16)#21]
Results [4]: [#8, #9, #9, #9]

(29) NativeShuffleExchange
Input [4]: [#8, #9, #9, #9]
Arguments: SinglePartition, ENSURE_REQUIREMENTS, [plan_id=4]

(30) ShuffleQueryStage
Output [4]: [#8, #9, #9, #9]
Arguments: X

(31) NativeHashAggregate
Input [4]: [#8, #9, #9, #9]
Keys: []
Functions [3]: [avg(UnscaledValue(ss_list_price#16)), count(ss_list_price#16), count(distinct ss_list_price#16)]
Aggregate Attributes [3]: [avg(UnscaledValue(ss_list_price#16))#19, count(ss_list_price#16)#20, count(ss_list_price#16)#21]
Results [3]: [avg(UnscaledValue(ss_list_price#16))#19, count(ss_list_price#16)#20, count(ss_list_price#16)#21]

(32) NativeProject
Output [3]: [cast((avg(UnscaledValue(ss_list_price#16))#19 / 100.0) as decimal(11,6)) AS B2_LP#22, count(ss_list_price#16)#20 AS B2_CNT#23, count(ss_list_price#16)#21 AS B2_CNTD#24]
Input [3]: [avg(UnscaledValue(ss_list_price#16))#19, count(ss_list_price#16)#20, count(ss_list_price#16)#21]

(33) CartesianProduct
Join type: Inner
Join condition: None

(121) Scan parquet
Output [4]: [ss_quantity#25, ss_wholesale_cost#26, ss_list_price#27, ss_coupon_amt#28]
Batched: true
Location: InMemoryFileIndex [file:/<warehouse_dir>]
PushedFilters: [IsNotNull(ss_quantity), GreaterThanOrEqual(ss_quantity,11), LessThanOrEqual(ss_quantity,15), Or(Or(And(GreaterThanOrEqual(ss_list_price,142.00),LessThanOrEqual(ss_list_price,152.00)),And(GreaterThanOrEqual(ss_coupon_amt,12214.00),LessThanOrEqual(ss_coupon_amt,13214.00))),And(GreaterThanOrEqual(ss_wholesale_cost,79.00),LessThanOrEqual(ss_wholesale_cost,99.00)))]
ReadSchema: struct<ss_quantity:int,ss_wholesale_cost:decimal(7,2),ss_list_price:decimal(7,2),ss_coupon_amt:decimal(7,2)>

(35) InputAdapter
Input [4]: [ss_quantity#25, ss_wholesale_cost#26, ss_list_price#27, ss_coupon_amt#28]
Arguments: [#25, #26, #27, #28]

(36) NativeFilter
Input [4]: [#25#25, #26#26, #27#27, #28#28]
Condition : (((isnotnull(ss_quantity#25) AND (ss_quantity#25 >= 11)) AND (ss_quantity#25 <= 15)) AND ((((ss_list_price#27 >= 142.00) AND (ss_list_price#27 <= 152.00)) OR ((ss_coupon_amt#28 >= 12214.00) AND (ss_coupon_amt#28 <= 13214.00))) OR ((ss_wholesale_cost#26 >= 79.00) AND (ss_wholesale_cost#26 <= 99.00))))

(37) NativeProject
Output [1]: [ss_list_price#27]
Input [4]: [#25#25, #26#26, #27#27, #28#28]

(38) NativeProject
Output [2]: [ss_list_price#27 AS ss_list_price#27, UnscaledValue(ss_list_price#27) AS _c1#29]
Input [1]: [ss_list_price#27]

(39) NativeHashAggregate
Input [2]: [ss_list_price#27, _c1#29]
Keys [1]: [ss_list_price#27]
Functions [2]: [partial_avg(_c1#29), partial_count(ss_list_price#27)]
Aggregate Attributes [2]: [avg(UnscaledValue(ss_list_price#27))#30, count(ss_list_price#27)#31]
Results [4]: [ss_list_price#27, #8, #9, #9]

(40) NativeShuffleExchange
Input [4]: [ss_list_price#27, #8, #9, #9]
Arguments: hashpartitioning(ss_list_price#27, 100), ENSURE_REQUIREMENTS, [plan_id=5]

(41) ShuffleQueryStage
Output [4]: [ss_list_price#27, #8, #9, #9]
Arguments: X

(42) AQEShuffleRead
Input [4]: [ss_list_price#27, #8, #9, #9]
Arguments: coalesced

(43) InputAdapter
Input [4]: [ss_list_price#27, #8, #9, #9]

(44) NativeHashAggregate
Input [4]: [ss_list_price#27, #8, #9, #9]
Keys [1]: [ss_list_price#27]
Functions [2]: [merge_avg(UnscaledValue(ss_list_price#27)), merge_count(ss_list_price#27)]
Aggregate Attributes [2]: [avg(UnscaledValue(ss_list_price#27))#30, count(ss_list_price#27)#31]
Results [4]: [ss_list_price#27, #8, #9, #9]

(45) NativeHashAggregate
Input [4]: [ss_list_price#27, #8, #9, #9]
Keys: []
Functions [3]: [merge_avg(UnscaledValue(ss_list_price#27)), merge_count(ss_list_price#27), partial_count(distinct ss_list_price#27)]
Aggregate Attributes [3]: [avg(UnscaledValue(ss_list_price#27))#30, count(ss_list_price#27)#31, count(ss_list_price#27)#32]
Results [4]: [#8, #9, #9, #9]

(46) NativeShuffleExchange
Input [4]: [#8, #9, #9, #9]
Arguments: SinglePartition, ENSURE_REQUIREMENTS, [plan_id=6]

(47) ShuffleQueryStage
Output [4]: [#8, #9, #9, #9]
Arguments: X

(48) NativeHashAggregate
Input [4]: [#8, #9, #9, #9]
Keys: []
Functions [3]: [avg(UnscaledValue(ss_list_price#27)), count(ss_list_price#27), count(distinct ss_list_price#27)]
Aggregate Attributes [3]: [avg(UnscaledValue(ss_list_price#27))#30, count(ss_list_price#27)#31, count(ss_list_price#27)#32]
Results [3]: [avg(UnscaledValue(ss_list_price#27))#30, count(ss_list_price#27)#31, count(ss_list_price#27)#32]

(49) NativeProject
Output [3]: [cast((avg(UnscaledValue(ss_list_price#27))#30 / 100.0) as decimal(11,6)) AS B3_LP#33, count(ss_list_price#27)#31 AS B3_CNT#34, count(ss_list_price#27)#32 AS B3_CNTD#35]
Input [3]: [avg(UnscaledValue(ss_list_price#27))#30, count(ss_list_price#27)#31, count(ss_list_price#27)#32]

(50) CartesianProduct
Join type: Inner
Join condition: None

(131) Scan parquet
Output [4]: [ss_quantity#36, ss_wholesale_cost#37, ss_list_price#38, ss_coupon_amt#39]
Batched: true
Location: InMemoryFileIndex [file:/<warehouse_dir>]
PushedFilters: [IsNotNull(ss_quantity), GreaterThanOrEqual(ss_quantity,16), LessThanOrEqual(ss_quantity,20), Or(Or(And(GreaterThanOrEqual(ss_list_price,135.00),LessThanOrEqual(ss_list_price,145.00)),And(GreaterThanOrEqual(ss_coupon_amt,6071.00),LessThanOrEqual(ss_coupon_amt,7071.00))),And(GreaterThanOrEqual(ss_wholesale_cost,38.00),LessThanOrEqual(ss_wholesale_cost,58.00)))]
ReadSchema: struct<ss_quantity:int,ss_wholesale_cost:decimal(7,2),ss_list_price:decimal(7,2),ss_coupon_amt:decimal(7,2)>

(52) InputAdapter
Input [4]: [ss_quantity#36, ss_wholesale_cost#37, ss_list_price#38, ss_coupon_amt#39]
Arguments: [#36, #37, #38, #39]

(53) NativeFilter
Input [4]: [#36#36, #37#37, #38#38, #39#39]
Condition : (((isnotnull(ss_quantity#36) AND (ss_quantity#36 >= 16)) AND (ss_quantity#36 <= 20)) AND ((((ss_list_price#38 >= 135.00) AND (ss_list_price#38 <= 145.00)) OR ((ss_coupon_amt#39 >= 6071.00) AND (ss_coupon_amt#39 <= 7071.00))) OR ((ss_wholesale_cost#37 >= 38.00) AND (ss_wholesale_cost#37 <= 58.00))))

(54) NativeProject
Output [1]: [ss_list_price#38]
Input [4]: [#36#36, #37#37, #38#38, #39#39]

(55) NativeProject
Output [2]: [ss_list_price#38 AS ss_list_price#38, UnscaledValue(ss_list_price#38) AS _c1#40]
Input [1]: [ss_list_price#38]

(56) NativeHashAggregate
Input [2]: [ss_list_price#38, _c1#40]
Keys [1]: [ss_list_price#38]
Functions [2]: [partial_avg(_c1#40), partial_count(ss_list_price#38)]
Aggregate Attributes [2]: [avg(UnscaledValue(ss_list_price#38))#41, count(ss_list_price#38)#42]
Results [4]: [ss_list_price#38, #8, #9, #9]

(57) NativeShuffleExchange
Input [4]: [ss_list_price#38, #8, #9, #9]
Arguments: hashpartitioning(ss_list_price#38, 100), ENSURE_REQUIREMENTS, [plan_id=7]

(58) ShuffleQueryStage
Output [4]: [ss_list_price#38, #8, #9, #9]
Arguments: X

(59) AQEShuffleRead
Input [4]: [ss_list_price#38, #8, #9, #9]
Arguments: coalesced

(60) InputAdapter
Input [4]: [ss_list_price#38, #8, #9, #9]

(61) NativeHashAggregate
Input [4]: [ss_list_price#38, #8, #9, #9]
Keys [1]: [ss_list_price#38]
Functions [2]: [merge_avg(UnscaledValue(ss_list_price#38)), merge_count(ss_list_price#38)]
Aggregate Attributes [2]: [avg(UnscaledValue(ss_list_price#38))#41, count(ss_list_price#38)#42]
Results [4]: [ss_list_price#38, #8, #9, #9]

(62) NativeHashAggregate
Input [4]: [ss_list_price#38, #8, #9, #9]
Keys: []
Functions [3]: [merge_avg(UnscaledValue(ss_list_price#38)), merge_count(ss_list_price#38), partial_count(distinct ss_list_price#38)]
Aggregate Attributes [3]: [avg(UnscaledValue(ss_list_price#38))#41, count(ss_list_price#38)#42, count(ss_list_price#38)#43]
Results [4]: [#8, #9, #9, #9]

(63) NativeShuffleExchange
Input [4]: [#8, #9, #9, #9]
Arguments: SinglePartition, ENSURE_REQUIREMENTS, [plan_id=8]

(64) ShuffleQueryStage
Output [4]: [#8, #9, #9, #9]
Arguments: X

(65) NativeHashAggregate
Input [4]: [#8, #9, #9, #9]
Keys: []
Functions [3]: [avg(UnscaledValue(ss_list_price#38)), count(ss_list_price#38), count(distinct ss_list_price#38)]
Aggregate Attributes [3]: [avg(UnscaledValue(ss_list_price#38))#41, count(ss_list_price#38)#42, count(ss_list_price#38)#43]
Results [3]: [avg(UnscaledValue(ss_list_price#38))#41, count(ss_list_price#38)#42, count(ss_list_price#38)#43]

(66) NativeProject
Output [3]: [cast((avg(UnscaledValue(ss_list_price#38))#41 / 100.0) as decimal(11,6)) AS B4_LP#44, count(ss_list_price#38)#42 AS B4_CNT#45, count(ss_list_price#38)#43 AS B4_CNTD#46]
Input [3]: [avg(UnscaledValue(ss_list_price#38))#41, count(ss_list_price#38)#42, count(ss_list_price#38)#43]

(67) CartesianProduct
Join type: Inner
Join condition: None

(141) Scan parquet
Output [4]: [ss_quantity#47, ss_wholesale_cost#48, ss_list_price#49, ss_coupon_amt#50]
Batched: true
Location: InMemoryFileIndex [file:/<warehouse_dir>]
PushedFilters: [IsNotNull(ss_quantity), GreaterThanOrEqual(ss_quantity,21), LessThanOrEqual(ss_quantity,25), Or(Or(And(GreaterThanOrEqual(ss_list_price,122.00),LessThanOrEqual(ss_list_price,132.00)),And(GreaterThanOrEqual(ss_coupon_amt,836.00),LessThanOrEqual(ss_coupon_amt,1836.00))),And(GreaterThanOrEqual(ss_wholesale_cost,17.00),LessThanOrEqual(ss_wholesale_cost,37.00)))]
ReadSchema: struct<ss_quantity:int,ss_wholesale_cost:decimal(7,2),ss_list_price:decimal(7,2),ss_coupon_amt:decimal(7,2)>

(69) InputAdapter
Input [4]: [ss_quantity#47, ss_wholesale_cost#48, ss_list_price#49, ss_coupon_amt#50]
Arguments: [#47, #48, #49, #50]

(70) NativeFilter
Input [4]: [#47#47, #48#48, #49#49, #50#50]
Condition : (((isnotnull(ss_quantity#47) AND (ss_quantity#47 >= 21)) AND (ss_quantity#47 <= 25)) AND ((((ss_list_price#49 >= 122.00) AND (ss_list_price#49 <= 132.00)) OR ((ss_coupon_amt#50 >= 836.00) AND (ss_coupon_amt#50 <= 1836.00))) OR ((ss_wholesale_cost#48 >= 17.00) AND (ss_wholesale_cost#48 <= 37.00))))

(71) NativeProject
Output [1]: [ss_list_price#49]
Input [4]: [#47#47, #48#48, #49#49, #50#50]

(72) NativeProject
Output [2]: [ss_list_price#49 AS ss_list_price#49, UnscaledValue(ss_list_price#49) AS _c1#51]
Input [1]: [ss_list_price#49]

(73) NativeHashAggregate
Input [2]: [ss_list_price#49, _c1#51]
Keys [1]: [ss_list_price#49]
Functions [2]: [partial_avg(_c1#51), partial_count(ss_list_price#49)]
Aggregate Attributes [2]: [avg(UnscaledValue(ss_list_price#49))#52, count(ss_list_price#49)#53]
Results [4]: [ss_list_price#49, #8, #9, #9]

(74) NativeShuffleExchange
Input [4]: [ss_list_price#49, #8, #9, #9]
Arguments: hashpartitioning(ss_list_price#49, 100), ENSURE_REQUIREMENTS, [plan_id=9]

(75) ShuffleQueryStage
Output [4]: [ss_list_price#49, #8, #9, #9]
Arguments: X

(76) AQEShuffleRead
Input [4]: [ss_list_price#49, #8, #9, #9]
Arguments: coalesced

(77) InputAdapter
Input [4]: [ss_list_price#49, #8, #9, #9]

(78) NativeHashAggregate
Input [4]: [ss_list_price#49, #8, #9, #9]
Keys [1]: [ss_list_price#49]
Functions [2]: [merge_avg(UnscaledValue(ss_list_price#49)), merge_count(ss_list_price#49)]
Aggregate Attributes [2]: [avg(UnscaledValue(ss_list_price#49))#52, count(ss_list_price#49)#53]
Results [4]: [ss_list_price#49, #8, #9, #9]

(79) NativeHashAggregate
Input [4]: [ss_list_price#49, #8, #9, #9]
Keys: []
Functions [3]: [merge_avg(UnscaledValue(ss_list_price#49)), merge_count(ss_list_price#49), partial_count(distinct ss_list_price#49)]
Aggregate Attributes [3]: [avg(UnscaledValue(ss_list_price#49))#52, count(ss_list_price#49)#53, count(ss_list_price#49)#54]
Results [4]: [#8, #9, #9, #9]

(80) NativeShuffleExchange
Input [4]: [#8, #9, #9, #9]
Arguments: SinglePartition, ENSURE_REQUIREMENTS, [plan_id=10]

(81) ShuffleQueryStage
Output [4]: [#8, #9, #9, #9]
Arguments: X

(82) NativeHashAggregate
Input [4]: [#8, #9, #9, #9]
Keys: []
Functions [3]: [avg(UnscaledValue(ss_list_price#49)), count(ss_list_price#49), count(distinct ss_list_price#49)]
Aggregate Attributes [3]: [avg(UnscaledValue(ss_list_price#49))#52, count(ss_list_price#49)#53, count(ss_list_price#49)#54]
Results [3]: [avg(UnscaledValue(ss_list_price#49))#52, count(ss_list_price#49)#53, count(ss_list_price#49)#54]

(83) NativeProject
Output [3]: [cast((avg(UnscaledValue(ss_list_price#49))#52 / 100.0) as decimal(11,6)) AS B5_LP#55, count(ss_list_price#49)#53 AS B5_CNT#56, count(ss_list_price#49)#54 AS B5_CNTD#57]
Input [3]: [avg(UnscaledValue(ss_list_price#49))#52, count(ss_list_price#49)#53, count(ss_list_price#49)#54]

(84) CartesianProduct
Join type: Inner
Join condition: None

(151) Scan parquet
Output [4]: [ss_quantity#58, ss_wholesale_cost#59, ss_list_price#60, ss_coupon_amt#61]
Batched: true
Location: InMemoryFileIndex [file:/<warehouse_dir>]
PushedFilters: [IsNotNull(ss_quantity), GreaterThanOrEqual(ss_quantity,26), LessThanOrEqual(ss_quantity,30), Or(Or(And(GreaterThanOrEqual(ss_list_price,154.00),LessThanOrEqual(ss_list_price,164.00)),And(GreaterThanOrEqual(ss_coupon_amt,7326.00),LessThanOrEqual(ss_coupon_amt,8326.00))),And(GreaterThanOrEqual(ss_wholesale_cost,7.00),LessThanOrEqual(ss_wholesale_cost,27.00)))]
ReadSchema: struct<ss_quantity:int,ss_wholesale_cost:decimal(7,2),ss_list_price:decimal(7,2),ss_coupon_amt:decimal(7,2)>

(86) InputAdapter
Input [4]: [ss_quantity#58, ss_wholesale_cost#59, ss_list_price#60, ss_coupon_amt#61]
Arguments: [#58, #59, #60, #61]

(87) NativeFilter
Input [4]: [#58#58, #59#59, #60#60, #61#61]
Condition : (((isnotnull(ss_quantity#58) AND (ss_quantity#58 >= 26)) AND (ss_quantity#58 <= 30)) AND ((((ss_list_price#60 >= 154.00) AND (ss_list_price#60 <= 164.00)) OR ((ss_coupon_amt#61 >= 7326.00) AND (ss_coupon_amt#61 <= 8326.00))) OR ((ss_wholesale_cost#59 >= 7.00) AND (ss_wholesale_cost#59 <= 27.00))))

(88) NativeProject
Output [1]: [ss_list_price#60]
Input [4]: [#58#58, #59#59, #60#60, #61#61]

(89) NativeProject
Output [2]: [ss_list_price#60 AS ss_list_price#60, UnscaledValue(ss_list_price#60) AS _c1#62]
Input [1]: [ss_list_price#60]

(90) NativeHashAggregate
Input [2]: [ss_list_price#60, _c1#62]
Keys [1]: [ss_list_price#60]
Functions [2]: [partial_avg(_c1#62), partial_count(ss_list_price#60)]
Aggregate Attributes [2]: [avg(UnscaledValue(ss_list_price#60))#63, count(ss_list_price#60)#64]
Results [4]: [ss_list_price#60, #8, #9, #9]

(91) NativeShuffleExchange
Input [4]: [ss_list_price#60, #8, #9, #9]
Arguments: hashpartitioning(ss_list_price#60, 100), ENSURE_REQUIREMENTS, [plan_id=11]

(92) ShuffleQueryStage
Output [4]: [ss_list_price#60, #8, #9, #9]
Arguments: X

(93) AQEShuffleRead
Input [4]: [ss_list_price#60, #8, #9, #9]
Arguments: coalesced

(94) InputAdapter
Input [4]: [ss_list_price#60, #8, #9, #9]

(95) NativeHashAggregate
Input [4]: [ss_list_price#60, #8, #9, #9]
Keys [1]: [ss_list_price#60]
Functions [2]: [merge_avg(UnscaledValue(ss_list_price#60)), merge_count(ss_list_price#60)]
Aggregate Attributes [2]: [avg(UnscaledValue(ss_list_price#60))#63, count(ss_list_price#60)#64]
Results [4]: [ss_list_price#60, #8, #9, #9]

(96) NativeHashAggregate
Input [4]: [ss_list_price#60, #8, #9, #9]
Keys: []
Functions [3]: [merge_avg(UnscaledValue(ss_list_price#60)), merge_count(ss_list_price#60), partial_count(distinct ss_list_price#60)]
Aggregate Attributes [3]: [avg(UnscaledValue(ss_list_price#60))#63, count(ss_list_price#60)#64, count(ss_list_price#60)#65]
Results [4]: [#8, #9, #9, #9]

(97) NativeShuffleExchange
Input [4]: [#8, #9, #9, #9]
Arguments: SinglePartition, ENSURE_REQUIREMENTS, [plan_id=12]

(98) ShuffleQueryStage
Output [4]: [#8, #9, #9, #9]
Arguments: X

(99) NativeHashAggregate
Input [4]: [#8, #9, #9, #9]
Keys: []
Functions [3]: [avg(UnscaledValue(ss_list_price#60)), count(ss_list_price#60), count(distinct ss_list_price#60)]
Aggregate Attributes [3]: [avg(UnscaledValue(ss_list_price#60))#63, count(ss_list_price#60)#64, count(ss_list_price#60)#65]
Results [3]: [avg(UnscaledValue(ss_list_price#60))#63, count(ss_list_price#60)#64, count(ss_list_price#60)#65]

(100) NativeProject
Output [3]: [cast((avg(UnscaledValue(ss_list_price#60))#63 / 100.0) as decimal(11,6)) AS B6_LP#66, count(ss_list_price#60)#64 AS B6_CNT#67, count(ss_list_price#60)#65 AS B6_CNTD#68]
Input [3]: [avg(UnscaledValue(ss_list_price#60))#63, count(ss_list_price#60)#64, count(ss_list_price#60)#65]

(101) CartesianProduct
Join type: Inner
Join condition: None

(102) Scan parquet
Output [4]: [ss_quantity#1, ss_wholesale_cost#2, ss_list_price#3, ss_coupon_amt#4]
Batched: true
Location: InMemoryFileIndex [file:/<warehouse_dir>]
PushedFilters: [IsNotNull(ss_quantity), GreaterThanOrEqual(ss_quantity,0), LessThanOrEqual(ss_quantity,5), Or(Or(And(GreaterThanOrEqual(ss_list_price,8.00),LessThanOrEqual(ss_list_price,18.00)),And(GreaterThanOrEqual(ss_coupon_amt,459.00),LessThanOrEqual(ss_coupon_amt,1459.00))),And(GreaterThanOrEqual(ss_wholesale_cost,57.00),LessThanOrEqual(ss_wholesale_cost,77.00)))]
ReadSchema: struct<ss_quantity:int,ss_wholesale_cost:decimal(7,2),ss_list_price:decimal(7,2),ss_coupon_amt:decimal(7,2)>

(103) Filter
Input [4]: [ss_quantity#1, ss_wholesale_cost#2, ss_list_price#3, ss_coupon_amt#4]
Condition : (((isnotnull(ss_quantity#1) AND (ss_quantity#1 >= 0)) AND (ss_quantity#1 <= 5)) AND ((((ss_list_price#3 >= 8.00) AND (ss_list_price#3 <= 18.00)) OR ((ss_coupon_amt#4 >= 459.00) AND (ss_coupon_amt#4 <= 1459.00))) OR ((ss_wholesale_cost#2 >= 57.00) AND (ss_wholesale_cost#2 <= 77.00))))

(104) Project
Output [1]: [ss_list_price#3]
Input [4]: [ss_quantity#1, ss_wholesale_cost#2, ss_list_price#3, ss_coupon_amt#4]

(105) HashAggregate
Input [1]: [ss_list_price#3]
Keys [1]: [ss_list_price#3]
Functions [2]: [partial_avg(UnscaledValue(ss_list_price#3)), partial_count(ss_list_price#3)]
Aggregate Attributes [2]: [avg(UnscaledValue(ss_list_price#3))#6, count(ss_list_price#3)#7]
Results [4]: [ss_list_price#3, sum#69, count#70, count#71]

(106) Exchange
Input [4]: [ss_list_price#3, sum#69, count#70, count#71]
Arguments: hashpartitioning(ss_list_price#3, 100), ENSURE_REQUIREMENTS, [plan_id=13]

(107) HashAggregate
Input [4]: [ss_list_price#3, sum#69, count#70, count#71]
Keys [1]: [ss_list_price#3]
Functions [2]: [merge_avg(UnscaledValue(ss_list_price#3)), merge_count(ss_list_price#3)]
Aggregate Attributes [2]: [avg(UnscaledValue(ss_list_price#3))#6, count(ss_list_price#3)#7]
Results [4]: [ss_list_price#3, sum#69, count#70, count#71]

(108) HashAggregate
Input [4]: [ss_list_price#3, sum#69, count#70, count#71]
Keys: []
Functions [3]: [merge_avg(UnscaledValue(ss_list_price#3)), merge_count(ss_list_price#3), partial_count(distinct ss_list_price#3)]
Aggregate Attributes [3]: [avg(UnscaledValue(ss_list_price#3))#6, count(ss_list_price#3)#7, count(ss_list_price#3)#10]
Results [4]: [sum#69, count#70, count#71, count#72]

(109) Exchange
Input [4]: [sum#69, count#70, count#71, count#72]
Arguments: SinglePartition, ENSURE_REQUIREMENTS, [plan_id=14]

(110) HashAggregate
Input [4]: [sum#69, count#70, count#71, count#72]
Keys: []
Functions [3]: [avg(UnscaledValue(ss_list_price#3)), count(ss_list_price#3), count(distinct ss_list_price#3)]
Aggregate Attributes [3]: [avg(UnscaledValue(ss_list_price#3))#6, count(ss_list_price#3)#7, count(ss_list_price#3)#10]
Results [3]: [cast((avg(UnscaledValue(ss_list_price#3))#6 / 100.0) as decimal(11,6)) AS B1_LP#11, count(ss_list_price#3)#7 AS B1_CNT#12, count(ss_list_price#3)#10 AS B1_CNTD#13]

(111) Scan parquet
Output [4]: [ss_quantity#14, ss_wholesale_cost#15, ss_list_price#16, ss_coupon_amt#17]
Batched: true
Location: InMemoryFileIndex [file:/<warehouse_dir>]
PushedFilters: [IsNotNull(ss_quantity), GreaterThanOrEqual(ss_quantity,6), LessThanOrEqual(ss_quantity,10), Or(Or(And(GreaterThanOrEqual(ss_list_price,90.00),LessThanOrEqual(ss_list_price,100.00)),And(GreaterThanOrEqual(ss_coupon_amt,2323.00),LessThanOrEqual(ss_coupon_amt,3323.00))),And(GreaterThanOrEqual(ss_wholesale_cost,31.00),LessThanOrEqual(ss_wholesale_cost,51.00)))]
ReadSchema: struct<ss_quantity:int,ss_wholesale_cost:decimal(7,2),ss_list_price:decimal(7,2),ss_coupon_amt:decimal(7,2)>

(112) Filter
Input [4]: [ss_quantity#14, ss_wholesale_cost#15, ss_list_price#16, ss_coupon_amt#17]
Condition : (((isnotnull(ss_quantity#14) AND (ss_quantity#14 >= 6)) AND (ss_quantity#14 <= 10)) AND ((((ss_list_price#16 >= 90.00) AND (ss_list_price#16 <= 100.00)) OR ((ss_coupon_amt#17 >= 2323.00) AND (ss_coupon_amt#17 <= 3323.00))) OR ((ss_wholesale_cost#15 >= 31.00) AND (ss_wholesale_cost#15 <= 51.00))))

(113) Project
Output [1]: [ss_list_price#16]
Input [4]: [ss_quantity#14, ss_wholesale_cost#15, ss_list_price#16, ss_coupon_amt#17]

(114) HashAggregate
Input [1]: [ss_list_price#16]
Keys [1]: [ss_list_price#16]
Functions [2]: [partial_avg(UnscaledValue(ss_list_price#16)), partial_count(ss_list_price#16)]
Aggregate Attributes [2]: [avg(UnscaledValue(ss_list_price#16))#19, count(ss_list_price#16)#20]
Results [4]: [ss_list_price#16, sum#73, count#74, count#75]

(115) Exchange
Input [4]: [ss_list_price#16, sum#73, count#74, count#75]
Arguments: hashpartitioning(ss_list_price#16, 100), ENSURE_REQUIREMENTS, [plan_id=15]

(116) HashAggregate
Input [4]: [ss_list_price#16, sum#73, count#74, count#75]
Keys [1]: [ss_list_price#16]
Functions [2]: [merge_avg(UnscaledValue(ss_list_price#16)), merge_count(ss_list_price#16)]
Aggregate Attributes [2]: [avg(UnscaledValue(ss_list_price#16))#19, count(ss_list_price#16)#20]
Results [4]: [ss_list_price#16, sum#73, count#74, count#75]

(117) HashAggregate
Input [4]: [ss_list_price#16, sum#73, count#74, count#75]
Keys: []
Functions [3]: [merge_avg(UnscaledValue(ss_list_price#16)), merge_count(ss_list_price#16), partial_count(distinct ss_list_price#16)]
Aggregate Attributes [3]: [avg(UnscaledValue(ss_list_price#16))#19, count(ss_list_price#16)#20, count(ss_list_price#16)#21]
Results [4]: [sum#73, count#74, count#75, count#76]

(118) Exchange
Input [4]: [sum#73, count#74, count#75, count#76]
Arguments: SinglePartition, ENSURE_REQUIREMENTS, [plan_id=16]

(119) HashAggregate
Input [4]: [sum#73, count#74, count#75, count#76]
Keys: []
Functions [3]: [avg(UnscaledValue(ss_list_price#16)), count(ss_list_price#16), count(distinct ss_list_price#16)]
Aggregate Attributes [3]: [avg(UnscaledValue(ss_list_price#16))#19, count(ss_list_price#16)#20, count(ss_list_price#16)#21]
Results [3]: [cast((avg(UnscaledValue(ss_list_price#16))#19 / 100.0) as decimal(11,6)) AS B2_LP#22, count(ss_list_price#16)#20 AS B2_CNT#23, count(ss_list_price#16)#21 AS B2_CNTD#24]

(120) CartesianProduct
Join type: Inner
Join condition: None

(121) Scan parquet
Output [4]: [ss_quantity#25, ss_wholesale_cost#26, ss_list_price#27, ss_coupon_amt#28]
Batched: true
Location: InMemoryFileIndex [file:/<warehouse_dir>]
PushedFilters: [IsNotNull(ss_quantity), GreaterThanOrEqual(ss_quantity,11), LessThanOrEqual(ss_quantity,15), Or(Or(And(GreaterThanOrEqual(ss_list_price,142.00),LessThanOrEqual(ss_list_price,152.00)),And(GreaterThanOrEqual(ss_coupon_amt,12214.00),LessThanOrEqual(ss_coupon_amt,13214.00))),And(GreaterThanOrEqual(ss_wholesale_cost,79.00),LessThanOrEqual(ss_wholesale_cost,99.00)))]
ReadSchema: struct<ss_quantity:int,ss_wholesale_cost:decimal(7,2),ss_list_price:decimal(7,2),ss_coupon_amt:decimal(7,2)>

(122) Filter
Input [4]: [ss_quantity#25, ss_wholesale_cost#26, ss_list_price#27, ss_coupon_amt#28]
Condition : (((isnotnull(ss_quantity#25) AND (ss_quantity#25 >= 11)) AND (ss_quantity#25 <= 15)) AND ((((ss_list_price#27 >= 142.00) AND (ss_list_price#27 <= 152.00)) OR ((ss_coupon_amt#28 >= 12214.00) AND (ss_coupon_amt#28 <= 13214.00))) OR ((ss_wholesale_cost#26 >= 79.00) AND (ss_wholesale_cost#26 <= 99.00))))

(123) Project
Output [1]: [ss_list_price#27]
Input [4]: [ss_quantity#25, ss_wholesale_cost#26, ss_list_price#27, ss_coupon_amt#28]

(124) HashAggregate
Input [1]: [ss_list_price#27]
Keys [1]: [ss_list_price#27]
Functions [2]: [partial_avg(UnscaledValue(ss_list_price#27)), partial_count(ss_list_price#27)]
Aggregate Attributes [2]: [avg(UnscaledValue(ss_list_price#27))#30, count(ss_list_price#27)#31]
Results [4]: [ss_list_price#27, sum#77, count#78, count#79]

(125) Exchange
Input [4]: [ss_list_price#27, sum#77, count#78, count#79]
Arguments: hashpartitioning(ss_list_price#27, 100), ENSURE_REQUIREMENTS, [plan_id=17]

(126) HashAggregate
Input [4]: [ss_list_price#27, sum#77, count#78, count#79]
Keys [1]: [ss_list_price#27]
Functions [2]: [merge_avg(UnscaledValue(ss_list_price#27)), merge_count(ss_list_price#27)]
Aggregate Attributes [2]: [avg(UnscaledValue(ss_list_price#27))#30, count(ss_list_price#27)#31]
Results [4]: [ss_list_price#27, sum#77, count#78, count#79]

(127) HashAggregate
Input [4]: [ss_list_price#27, sum#77, count#78, count#79]
Keys: []
Functions [3]: [merge_avg(UnscaledValue(ss_list_price#27)), merge_count(ss_list_price#27), partial_count(distinct ss_list_price#27)]
Aggregate Attributes [3]: [avg(UnscaledValue(ss_list_price#27))#30, count(ss_list_price#27)#31, count(ss_list_price#27)#32]
Results [4]: [sum#77, count#78, count#79, count#80]

(128) Exchange
Input [4]: [sum#77, count#78, count#79, count#80]
Arguments: SinglePartition, ENSURE_REQUIREMENTS, [plan_id=18]

(129) HashAggregate
Input [4]: [sum#77, count#78, count#79, count#80]
Keys: []
Functions [3]: [avg(UnscaledValue(ss_list_price#27)), count(ss_list_price#27), count(distinct ss_list_price#27)]
Aggregate Attributes [3]: [avg(UnscaledValue(ss_list_price#27))#30, count(ss_list_price#27)#31, count(ss_list_price#27)#32]
Results [3]: [cast((avg(UnscaledValue(ss_list_price#27))#30 / 100.0) as decimal(11,6)) AS B3_LP#33, count(ss_list_price#27)#31 AS B3_CNT#34, count(ss_list_price#27)#32 AS B3_CNTD#35]

(130) CartesianProduct
Join type: Inner
Join condition: None

(131) Scan parquet
Output [4]: [ss_quantity#36, ss_wholesale_cost#37, ss_list_price#38, ss_coupon_amt#39]
Batched: true
Location: InMemoryFileIndex [file:/<warehouse_dir>]
PushedFilters: [IsNotNull(ss_quantity), GreaterThanOrEqual(ss_quantity,16), LessThanOrEqual(ss_quantity,20), Or(Or(And(GreaterThanOrEqual(ss_list_price,135.00),LessThanOrEqual(ss_list_price,145.00)),And(GreaterThanOrEqual(ss_coupon_amt,6071.00),LessThanOrEqual(ss_coupon_amt,7071.00))),And(GreaterThanOrEqual(ss_wholesale_cost,38.00),LessThanOrEqual(ss_wholesale_cost,58.00)))]
ReadSchema: struct<ss_quantity:int,ss_wholesale_cost:decimal(7,2),ss_list_price:decimal(7,2),ss_coupon_amt:decimal(7,2)>

(132) Filter
Input [4]: [ss_quantity#36, ss_wholesale_cost#37, ss_list_price#38, ss_coupon_amt#39]
Condition : (((isnotnull(ss_quantity#36) AND (ss_quantity#36 >= 16)) AND (ss_quantity#36 <= 20)) AND ((((ss_list_price#38 >= 135.00) AND (ss_list_price#38 <= 145.00)) OR ((ss_coupon_amt#39 >= 6071.00) AND (ss_coupon_amt#39 <= 7071.00))) OR ((ss_wholesale_cost#37 >= 38.00) AND (ss_wholesale_cost#37 <= 58.00))))

(133) Project
Output [1]: [ss_list_price#38]
Input [4]: [ss_quantity#36, ss_wholesale_cost#37, ss_list_price#38, ss_coupon_amt#39]

(134) HashAggregate
Input [1]: [ss_list_price#38]
Keys [1]: [ss_list_price#38]
Functions [2]: [partial_avg(UnscaledValue(ss_list_price#38)), partial_count(ss_list_price#38)]
Aggregate Attributes [2]: [avg(UnscaledValue(ss_list_price#38))#41, count(ss_list_price#38)#42]
Results [4]: [ss_list_price#38, sum#81, count#82, count#83]

(135) Exchange
Input [4]: [ss_list_price#38, sum#81, count#82, count#83]
Arguments: hashpartitioning(ss_list_price#38, 100), ENSURE_REQUIREMENTS, [plan_id=19]

(136) HashAggregate
Input [4]: [ss_list_price#38, sum#81, count#82, count#83]
Keys [1]: [ss_list_price#38]
Functions [2]: [merge_avg(UnscaledValue(ss_list_price#38)), merge_count(ss_list_price#38)]
Aggregate Attributes [2]: [avg(UnscaledValue(ss_list_price#38))#41, count(ss_list_price#38)#42]
Results [4]: [ss_list_price#38, sum#81, count#82, count#83]

(137) HashAggregate
Input [4]: [ss_list_price#38, sum#81, count#82, count#83]
Keys: []
Functions [3]: [merge_avg(UnscaledValue(ss_list_price#38)), merge_count(ss_list_price#38), partial_count(distinct ss_list_price#38)]
Aggregate Attributes [3]: [avg(UnscaledValue(ss_list_price#38))#41, count(ss_list_price#38)#42, count(ss_list_price#38)#43]
Results [4]: [sum#81, count#82, count#83, count#84]

(138) Exchange
Input [4]: [sum#81, count#82, count#83, count#84]
Arguments: SinglePartition, ENSURE_REQUIREMENTS, [plan_id=20]

(139) HashAggregate
Input [4]: [sum#81, count#82, count#83, count#84]
Keys: []
Functions [3]: [avg(UnscaledValue(ss_list_price#38)), count(ss_list_price#38), count(distinct ss_list_price#38)]
Aggregate Attributes [3]: [avg(UnscaledValue(ss_list_price#38))#41, count(ss_list_price#38)#42, count(ss_list_price#38)#43]
Results [3]: [cast((avg(UnscaledValue(ss_list_price#38))#41 / 100.0) as decimal(11,6)) AS B4_LP#44, count(ss_list_price#38)#42 AS B4_CNT#45, count(ss_list_price#38)#43 AS B4_CNTD#46]

(140) CartesianProduct
Join type: Inner
Join condition: None

(141) Scan parquet
Output [4]: [ss_quantity#47, ss_wholesale_cost#48, ss_list_price#49, ss_coupon_amt#50]
Batched: true
Location: InMemoryFileIndex [file:/<warehouse_dir>]
PushedFilters: [IsNotNull(ss_quantity), GreaterThanOrEqual(ss_quantity,21), LessThanOrEqual(ss_quantity,25), Or(Or(And(GreaterThanOrEqual(ss_list_price,122.00),LessThanOrEqual(ss_list_price,132.00)),And(GreaterThanOrEqual(ss_coupon_amt,836.00),LessThanOrEqual(ss_coupon_amt,1836.00))),And(GreaterThanOrEqual(ss_wholesale_cost,17.00),LessThanOrEqual(ss_wholesale_cost,37.00)))]
ReadSchema: struct<ss_quantity:int,ss_wholesale_cost:decimal(7,2),ss_list_price:decimal(7,2),ss_coupon_amt:decimal(7,2)>

(142) Filter
Input [4]: [ss_quantity#47, ss_wholesale_cost#48, ss_list_price#49, ss_coupon_amt#50]
Condition : (((isnotnull(ss_quantity#47) AND (ss_quantity#47 >= 21)) AND (ss_quantity#47 <= 25)) AND ((((ss_list_price#49 >= 122.00) AND (ss_list_price#49 <= 132.00)) OR ((ss_coupon_amt#50 >= 836.00) AND (ss_coupon_amt#50 <= 1836.00))) OR ((ss_wholesale_cost#48 >= 17.00) AND (ss_wholesale_cost#48 <= 37.00))))

(143) Project
Output [1]: [ss_list_price#49]
Input [4]: [ss_quantity#47, ss_wholesale_cost#48, ss_list_price#49, ss_coupon_amt#50]

(144) HashAggregate
Input [1]: [ss_list_price#49]
Keys [1]: [ss_list_price#49]
Functions [2]: [partial_avg(UnscaledValue(ss_list_price#49)), partial_count(ss_list_price#49)]
Aggregate Attributes [2]: [avg(UnscaledValue(ss_list_price#49))#52, count(ss_list_price#49)#53]
Results [4]: [ss_list_price#49, sum#85, count#86, count#87]

(145) Exchange
Input [4]: [ss_list_price#49, sum#85, count#86, count#87]
Arguments: hashpartitioning(ss_list_price#49, 100), ENSURE_REQUIREMENTS, [plan_id=21]

(146) HashAggregate
Input [4]: [ss_list_price#49, sum#85, count#86, count#87]
Keys [1]: [ss_list_price#49]
Functions [2]: [merge_avg(UnscaledValue(ss_list_price#49)), merge_count(ss_list_price#49)]
Aggregate Attributes [2]: [avg(UnscaledValue(ss_list_price#49))#52, count(ss_list_price#49)#53]
Results [4]: [ss_list_price#49, sum#85, count#86, count#87]

(147) HashAggregate
Input [4]: [ss_list_price#49, sum#85, count#86, count#87]
Keys: []
Functions [3]: [merge_avg(UnscaledValue(ss_list_price#49)), merge_count(ss_list_price#49), partial_count(distinct ss_list_price#49)]
Aggregate Attributes [3]: [avg(UnscaledValue(ss_list_price#49))#52, count(ss_list_price#49)#53, count(ss_list_price#49)#54]
Results [4]: [sum#85, count#86, count#87, count#88]

(148) Exchange
Input [4]: [sum#85, count#86, count#87, count#88]
Arguments: SinglePartition, ENSURE_REQUIREMENTS, [plan_id=22]

(149) HashAggregate
Input [4]: [sum#85, count#86, count#87, count#88]
Keys: []
Functions [3]: [avg(UnscaledValue(ss_list_price#49)), count(ss_list_price#49), count(distinct ss_list_price#49)]
Aggregate Attributes [3]: [avg(UnscaledValue(ss_list_price#49))#52, count(ss_list_price#49)#53, count(ss_list_price#49)#54]
Results [3]: [cast((avg(UnscaledValue(ss_list_price#49))#52 / 100.0) as decimal(11,6)) AS B5_LP#55, count(ss_list_price#49)#53 AS B5_CNT#56, count(ss_list_price#49)#54 AS B5_CNTD#57]

(150) CartesianProduct
Join type: Inner
Join condition: None

(151) Scan parquet
Output [4]: [ss_quantity#58, ss_wholesale_cost#59, ss_list_price#60, ss_coupon_amt#61]
Batched: true
Location: InMemoryFileIndex [file:/<warehouse_dir>]
PushedFilters: [IsNotNull(ss_quantity), GreaterThanOrEqual(ss_quantity,26), LessThanOrEqual(ss_quantity,30), Or(Or(And(GreaterThanOrEqual(ss_list_price,154.00),LessThanOrEqual(ss_list_price,164.00)),And(GreaterThanOrEqual(ss_coupon_amt,7326.00),LessThanOrEqual(ss_coupon_amt,8326.00))),And(GreaterThanOrEqual(ss_wholesale_cost,7.00),LessThanOrEqual(ss_wholesale_cost,27.00)))]
ReadSchema: struct<ss_quantity:int,ss_wholesale_cost:decimal(7,2),ss_list_price:decimal(7,2),ss_coupon_amt:decimal(7,2)>

(152) Filter
Input [4]: [ss_quantity#58, ss_wholesale_cost#59, ss_list_price#60, ss_coupon_amt#61]
Condition : (((isnotnull(ss_quantity#58) AND (ss_quantity#58 >= 26)) AND (ss_quantity#58 <= 30)) AND ((((ss_list_price#60 >= 154.00) AND (ss_list_price#60 <= 164.00)) OR ((ss_coupon_amt#61 >= 7326.00) AND (ss_coupon_amt#61 <= 8326.00))) OR ((ss_wholesale_cost#59 >= 7.00) AND (ss_wholesale_cost#59 <= 27.00))))

(153) Project
Output [1]: [ss_list_price#60]
Input [4]: [ss_quantity#58, ss_wholesale_cost#59, ss_list_price#60, ss_coupon_amt#61]

(154) HashAggregate
Input [1]: [ss_list_price#60]
Keys [1]: [ss_list_price#60]
Functions [2]: [partial_avg(UnscaledValue(ss_list_price#60)), partial_count(ss_list_price#60)]
Aggregate Attributes [2]: [avg(UnscaledValue(ss_list_price#60))#63, count(ss_list_price#60)#64]
Results [4]: [ss_list_price#60, sum#89, count#90, count#91]

(155) Exchange
Input [4]: [ss_list_price#60, sum#89, count#90, count#91]
Arguments: hashpartitioning(ss_list_price#60, 100), ENSURE_REQUIREMENTS, [plan_id=23]

(156) HashAggregate
Input [4]: [ss_list_price#60, sum#89, count#90, count#91]
Keys [1]: [ss_list_price#60]
Functions [2]: [merge_avg(UnscaledValue(ss_list_price#60)), merge_count(ss_list_price#60)]
Aggregate Attributes [2]: [avg(UnscaledValue(ss_list_price#60))#63, count(ss_list_price#60)#64]
Results [4]: [ss_list_price#60, sum#89, count#90, count#91]

(157) HashAggregate
Input [4]: [ss_list_price#60, sum#89, count#90, count#91]
Keys: []
Functions [3]: [merge_avg(UnscaledValue(ss_list_price#60)), merge_count(ss_list_price#60), partial_count(distinct ss_list_price#60)]
Aggregate Attributes [3]: [avg(UnscaledValue(ss_list_price#60))#63, count(ss_list_price#60)#64, count(ss_list_price#60)#65]
Results [4]: [sum#89, count#90, count#91, count#92]

(158) Exchange
Input [4]: [sum#89, count#90, count#91, count#92]
Arguments: SinglePartition, ENSURE_REQUIREMENTS, [plan_id=24]

(159) HashAggregate
Input [4]: [sum#89, count#90, count#91, count#92]
Keys: []
Functions [3]: [avg(UnscaledValue(ss_list_price#60)), count(ss_list_price#60), count(distinct ss_list_price#60)]
Aggregate Attributes [3]: [avg(UnscaledValue(ss_list_price#60))#63, count(ss_list_price#60)#64, count(ss_list_price#60)#65]
Results [3]: [cast((avg(UnscaledValue(ss_list_price#60))#63 / 100.0) as decimal(11,6)) AS B6_LP#66, count(ss_list_price#60)#64 AS B6_CNT#67, count(ss_list_price#60)#65 AS B6_CNTD#68]

(160) CartesianProduct
Join type: Inner
Join condition: None

(161) AdaptiveSparkPlan
Output [18]: [B1_LP#11, B1_CNT#12, B1_CNTD#13, B2_LP#22, B2_CNT#23, B2_CNTD#24, B3_LP#33, B3_CNT#34, B3_CNTD#35, B4_LP#44, B4_CNT#45, B4_CNTD#46, B5_LP#55, B5_CNT#56, B5_CNTD#57, B6_LP#66, B6_CNT#67, B6_CNTD#68]
Arguments: isFinalPlan=true

