== Physical Plan ==
* Project (4)
+- * Filter (3)
   +- * ColumnarToRow (2)
      +- Scan parquet default.reason (1)


(1) Scan parquet default.reason
Output [1]: [r_reason_sk#1]
Batched: true
Location [not included in comparison]/{warehouse_dir}/reason]
PushedFilters: [IsNotNull(r_reason_sk), EqualTo(r_reason_sk,1)]
ReadSchema: struct<r_reason_sk:int>

(2) ColumnarToRow [codegen id : 1]
Input [1]: [r_reason_sk#1]

(3) Filter [codegen id : 1]
Input [1]: [r_reason_sk#1]
Condition : (isnotnull(r_reason_sk#1) AND (r_reason_sk#1 = 1))

(4) Project [codegen id : 1]
Output [5]: [CASE WHEN (Subquery scalar-subquery#2, [id=#3] > 62316685) THEN Subquery scalar-subquery#4, [id=#5] ELSE Subquery scalar-subquery#6, [id=#7] END AS bucket1#8, CASE WHEN (Subquery scalar-subquery#9, [id=#10] > 19045798) THEN Subquery scalar-subquery#11, [id=#12] ELSE Subquery scalar-subquery#13, [id=#14] END AS bucket2#15, CASE WHEN (Subquery scalar-subquery#16, [id=#17] > 365541424) THEN Subquery scalar-subquery#18, [id=#19] ELSE Subquery scalar-subquery#20, [id=#21] END AS bucket3#22, CASE WHEN (Subquery scalar-subquery#23, [id=#24] > 216357808) THEN Subquery scalar-subquery#25, [id=#26] ELSE Subquery scalar-subquery#27, [id=#28] END AS bucket4#29, CASE WHEN (Subquery scalar-subquery#30, [id=#31] > 184483884) THEN Subquery scalar-subquery#32, [id=#33] ELSE Subquery scalar-subquery#34, [id=#35] END AS bucket5#36]
Input [1]: [r_reason_sk#1]

===== Subqueries =====

Subquery:1 Hosting operator id = 4 Hosting Expression = Subquery scalar-subquery#2, [id=#3]
* HashAggregate (11)
+- Exchange (10)
   +- * HashAggregate (9)
      +- * Project (8)
         +- * Filter (7)
            +- * ColumnarToRow (6)
               +- Scan parquet default.store_sales (5)


(5) Scan parquet default.store_sales
Output [2]: [ss_quantity#37, ss_sold_date_sk#38]
Batched: true
Location [not included in comparison]/{warehouse_dir}/store_sales]
PushedFilters: [IsNotNull(ss_quantity), GreaterThanOrEqual(ss_quantity,1), LessThanOrEqual(ss_quantity,20)]
ReadSchema: struct<ss_quantity:int>

(6) ColumnarToRow [codegen id : 1]
Input [2]: [ss_quantity#37, ss_sold_date_sk#38]

(7) Filter [codegen id : 1]
Input [2]: [ss_quantity#37, ss_sold_date_sk#38]
Condition : ((isnotnull(ss_quantity#37) AND (ss_quantity#37 >= 1)) AND (ss_quantity#37 <= 20))

(8) Project [codegen id : 1]
Output: []
Input [2]: [ss_quantity#37, ss_sold_date_sk#38]

(9) HashAggregate [codegen id : 1]
Input: []
Keys: []
Functions [1]: [partial_count(1)]
Aggregate Attributes [1]: [count#39]
Results [1]: [count#40]

(10) Exchange
Input [1]: [count#40]
Arguments: SinglePartition, ENSURE_REQUIREMENTS, [plan_id=1]

(11) HashAggregate [codegen id : 2]
Input [1]: [count#40]
Keys: []
Functions [1]: [count(1)]
Aggregate Attributes [1]: [count(1)#41]
Results [1]: [count(1)#41 AS count(1)#42]

Subquery:2 Hosting operator id = 4 Hosting Expression = Subquery scalar-subquery#4, [id=#5]
* HashAggregate (18)
+- Exchange (17)
   +- * HashAggregate (16)
      +- * Project (15)
         +- * Filter (14)
            +- * ColumnarToRow (13)
               +- Scan parquet default.store_sales (12)


(12) Scan parquet default.store_sales
Output [3]: [ss_quantity#43, ss_ext_discount_amt#44, ss_sold_date_sk#45]
Batched: true
Location [not included in comparison]/{warehouse_dir}/store_sales]
PushedFilters: [IsNotNull(ss_quantity), GreaterThanOrEqual(ss_quantity,1), LessThanOrEqual(ss_quantity,20)]
ReadSchema: struct<ss_quantity:int,ss_ext_discount_amt:decimal(7,2)>

(13) ColumnarToRow [codegen id : 1]
Input [3]: [ss_quantity#43, ss_ext_discount_amt#44, ss_sold_date_sk#45]

(14) Filter [codegen id : 1]
Input [3]: [ss_quantity#43, ss_ext_discount_amt#44, ss_sold_date_sk#45]
Condition : ((isnotnull(ss_quantity#43) AND (ss_quantity#43 >= 1)) AND (ss_quantity#43 <= 20))

(15) Project [codegen id : 1]
Output [1]: [ss_ext_discount_amt#44]
Input [3]: [ss_quantity#43, ss_ext_discount_amt#44, ss_sold_date_sk#45]

(16) HashAggregate [codegen id : 1]
Input [1]: [ss_ext_discount_amt#44]
Keys: []
Functions [1]: [partial_avg(UnscaledValue(ss_ext_discount_amt#44))]
Aggregate Attributes [2]: [sum#46, count#47]
Results [2]: [sum#48, count#49]

(17) Exchange
Input [2]: [sum#48, count#49]
Arguments: SinglePartition, ENSURE_REQUIREMENTS, [plan_id=2]

(18) HashAggregate [codegen id : 2]
Input [2]: [sum#48, count#49]
Keys: []
Functions [1]: [avg(UnscaledValue(ss_ext_discount_amt#44))]
Aggregate Attributes [1]: [avg(UnscaledValue(ss_ext_discount_amt#44))#50]
Results [1]: [cast((avg(UnscaledValue(ss_ext_discount_amt#44))#50 / 100.0) as decimal(11,6)) AS avg(ss_ext_discount_amt)#51]

Subquery:3 Hosting operator id = 4 Hosting Expression = Subquery scalar-subquery#6, [id=#7]
* HashAggregate (25)
+- Exchange (24)
   +- * HashAggregate (23)
      +- * Project (22)
         +- * Filter (21)
            +- * ColumnarToRow (20)
               +- Scan parquet default.store_sales (19)


(19) Scan parquet default.store_sales
Output [3]: [ss_quantity#52, ss_net_paid#53, ss_sold_date_sk#54]
Batched: true
Location [not included in comparison]/{warehouse_dir}/store_sales]
PushedFilters: [IsNotNull(ss_quantity), GreaterThanOrEqual(ss_quantity,1), LessThanOrEqual(ss_quantity,20)]
ReadSchema: struct<ss_quantity:int,ss_net_paid:decimal(7,2)>

(20) ColumnarToRow [codegen id : 1]
Input [3]: [ss_quantity#52, ss_net_paid#53, ss_sold_date_sk#54]

(21) Filter [codegen id : 1]
Input [3]: [ss_quantity#52, ss_net_paid#53, ss_sold_date_sk#54]
Condition : ((isnotnull(ss_quantity#52) AND (ss_quantity#52 >= 1)) AND (ss_quantity#52 <= 20))

(22) Project [codegen id : 1]
Output [1]: [ss_net_paid#53]
Input [3]: [ss_quantity#52, ss_net_paid#53, ss_sold_date_sk#54]

(23) HashAggregate [codegen id : 1]
Input [1]: [ss_net_paid#53]
Keys: []
Functions [1]: [partial_avg(UnscaledValue(ss_net_paid#53))]
Aggregate Attributes [2]: [sum#55, count#56]
Results [2]: [sum#57, count#58]

(24) Exchange
Input [2]: [sum#57, count#58]
Arguments: SinglePartition, ENSURE_REQUIREMENTS, [plan_id=3]

(25) HashAggregate [codegen id : 2]
Input [2]: [sum#57, count#58]
Keys: []
Functions [1]: [avg(UnscaledValue(ss_net_paid#53))]
Aggregate Attributes [1]: [avg(UnscaledValue(ss_net_paid#53))#59]
Results [1]: [cast((avg(UnscaledValue(ss_net_paid#53))#59 / 100.0) as decimal(11,6)) AS avg(ss_net_paid)#60]

Subquery:4 Hosting operator id = 4 Hosting Expression = Subquery scalar-subquery#9, [id=#10]
* HashAggregate (32)
+- Exchange (31)
   +- * HashAggregate (30)
      +- * Project (29)
         +- * Filter (28)
            +- * ColumnarToRow (27)
               +- Scan parquet default.store_sales (26)


(26) Scan parquet default.store_sales
Output [2]: [ss_quantity#61, ss_sold_date_sk#62]
Batched: true
Location [not included in comparison]/{warehouse_dir}/store_sales]
PushedFilters: [IsNotNull(ss_quantity), GreaterThanOrEqual(ss_quantity,21), LessThanOrEqual(ss_quantity,40)]
ReadSchema: struct<ss_quantity:int>

(27) ColumnarToRow [codegen id : 1]
Input [2]: [ss_quantity#61, ss_sold_date_sk#62]

(28) Filter [codegen id : 1]
Input [2]: [ss_quantity#61, ss_sold_date_sk#62]
Condition : ((isnotnull(ss_quantity#61) AND (ss_quantity#61 >= 21)) AND (ss_quantity#61 <= 40))

(29) Project [codegen id : 1]
Output: []
Input [2]: [ss_quantity#61, ss_sold_date_sk#62]

(30) HashAggregate [codegen id : 1]
Input: []
Keys: []
Functions [1]: [partial_count(1)]
Aggregate Attributes [1]: [count#63]
Results [1]: [count#64]

(31) Exchange
Input [1]: [count#64]
Arguments: SinglePartition, ENSURE_REQUIREMENTS, [plan_id=4]

(32) HashAggregate [codegen id : 2]
Input [1]: [count#64]
Keys: []
Functions [1]: [count(1)]
Aggregate Attributes [1]: [count(1)#65]
Results [1]: [count(1)#65 AS count(1)#66]

Subquery:5 Hosting operator id = 4 Hosting Expression = Subquery scalar-subquery#11, [id=#12]
* HashAggregate (39)
+- Exchange (38)
   +- * HashAggregate (37)
      +- * Project (36)
         +- * Filter (35)
            +- * ColumnarToRow (34)
               +- Scan parquet default.store_sales (33)


(33) Scan parquet default.store_sales
Output [3]: [ss_quantity#67, ss_ext_discount_amt#68, ss_sold_date_sk#69]
Batched: true
Location [not included in comparison]/{warehouse_dir}/store_sales]
PushedFilters: [IsNotNull(ss_quantity), GreaterThanOrEqual(ss_quantity,21), LessThanOrEqual(ss_quantity,40)]
ReadSchema: struct<ss_quantity:int,ss_ext_discount_amt:decimal(7,2)>

(34) ColumnarToRow [codegen id : 1]
Input [3]: [ss_quantity#67, ss_ext_discount_amt#68, ss_sold_date_sk#69]

(35) Filter [codegen id : 1]
Input [3]: [ss_quantity#67, ss_ext_discount_amt#68, ss_sold_date_sk#69]
Condition : ((isnotnull(ss_quantity#67) AND (ss_quantity#67 >= 21)) AND (ss_quantity#67 <= 40))

(36) Project [codegen id : 1]
Output [1]: [ss_ext_discount_amt#68]
Input [3]: [ss_quantity#67, ss_ext_discount_amt#68, ss_sold_date_sk#69]

(37) HashAggregate [codegen id : 1]
Input [1]: [ss_ext_discount_amt#68]
Keys: []
Functions [1]: [partial_avg(UnscaledValue(ss_ext_discount_amt#68))]
Aggregate Attributes [2]: [sum#70, count#71]
Results [2]: [sum#72, count#73]

(38) Exchange
Input [2]: [sum#72, count#73]
Arguments: SinglePartition, ENSURE_REQUIREMENTS, [plan_id=5]

(39) HashAggregate [codegen id : 2]
Input [2]: [sum#72, count#73]
Keys: []
Functions [1]: [avg(UnscaledValue(ss_ext_discount_amt#68))]
Aggregate Attributes [1]: [avg(UnscaledValue(ss_ext_discount_amt#68))#74]
Results [1]: [cast((avg(UnscaledValue(ss_ext_discount_amt#68))#74 / 100.0) as decimal(11,6)) AS avg(ss_ext_discount_amt)#75]

Subquery:6 Hosting operator id = 4 Hosting Expression = Subquery scalar-subquery#13, [id=#14]
* HashAggregate (46)
+- Exchange (45)
   +- * HashAggregate (44)
      +- * Project (43)
         +- * Filter (42)
            +- * ColumnarToRow (41)
               +- Scan parquet default.store_sales (40)


(40) Scan parquet default.store_sales
Output [3]: [ss_quantity#76, ss_net_paid#77, ss_sold_date_sk#78]
Batched: true
Location [not included in comparison]/{warehouse_dir}/store_sales]
PushedFilters: [IsNotNull(ss_quantity), GreaterThanOrEqual(ss_quantity,21), LessThanOrEqual(ss_quantity,40)]
ReadSchema: struct<ss_quantity:int,ss_net_paid:decimal(7,2)>

(41) ColumnarToRow [codegen id : 1]
Input [3]: [ss_quantity#76, ss_net_paid#77, ss_sold_date_sk#78]

(42) Filter [codegen id : 1]
Input [3]: [ss_quantity#76, ss_net_paid#77, ss_sold_date_sk#78]
Condition : ((isnotnull(ss_quantity#76) AND (ss_quantity#76 >= 21)) AND (ss_quantity#76 <= 40))

(43) Project [codegen id : 1]
Output [1]: [ss_net_paid#77]
Input [3]: [ss_quantity#76, ss_net_paid#77, ss_sold_date_sk#78]

(44) HashAggregate [codegen id : 1]
Input [1]: [ss_net_paid#77]
Keys: []
Functions [1]: [partial_avg(UnscaledValue(ss_net_paid#77))]
Aggregate Attributes [2]: [sum#79, count#80]
Results [2]: [sum#81, count#82]

(45) Exchange
Input [2]: [sum#81, count#82]
Arguments: SinglePartition, ENSURE_REQUIREMENTS, [plan_id=6]

(46) HashAggregate [codegen id : 2]
Input [2]: [sum#81, count#82]
Keys: []
Functions [1]: [avg(UnscaledValue(ss_net_paid#77))]
Aggregate Attributes [1]: [avg(UnscaledValue(ss_net_paid#77))#83]
Results [1]: [cast((avg(UnscaledValue(ss_net_paid#77))#83 / 100.0) as decimal(11,6)) AS avg(ss_net_paid)#84]

Subquery:7 Hosting operator id = 4 Hosting Expression = Subquery scalar-subquery#16, [id=#17]
* HashAggregate (53)
+- Exchange (52)
   +- * HashAggregate (51)
      +- * Project (50)
         +- * Filter (49)
            +- * ColumnarToRow (48)
               +- Scan parquet default.store_sales (47)


(47) Scan parquet default.store_sales
Output [2]: [ss_quantity#85, ss_sold_date_sk#86]
Batched: true
Location [not included in comparison]/{warehouse_dir}/store_sales]
PushedFilters: [IsNotNull(ss_quantity), GreaterThanOrEqual(ss_quantity,41), LessThanOrEqual(ss_quantity,60)]
ReadSchema: struct<ss_quantity:int>

(48) ColumnarToRow [codegen id : 1]
Input [2]: [ss_quantity#85, ss_sold_date_sk#86]

(49) Filter [codegen id : 1]
Input [2]: [ss_quantity#85, ss_sold_date_sk#86]
Condition : ((isnotnull(ss_quantity#85) AND (ss_quantity#85 >= 41)) AND (ss_quantity#85 <= 60))

(50) Project [codegen id : 1]
Output: []
Input [2]: [ss_quantity#85, ss_sold_date_sk#86]

(51) HashAggregate [codegen id : 1]
Input: []
Keys: []
Functions [1]: [partial_count(1)]
Aggregate Attributes [1]: [count#87]
Results [1]: [count#88]

(52) Exchange
Input [1]: [count#88]
Arguments: SinglePartition, ENSURE_REQUIREMENTS, [plan_id=7]

(53) HashAggregate [codegen id : 2]
Input [1]: [count#88]
Keys: []
Functions [1]: [count(1)]
Aggregate Attributes [1]: [count(1)#89]
Results [1]: [count(1)#89 AS count(1)#90]

Subquery:8 Hosting operator id = 4 Hosting Expression = Subquery scalar-subquery#18, [id=#19]
* HashAggregate (60)
+- Exchange (59)
   +- * HashAggregate (58)
      +- * Project (57)
         +- * Filter (56)
            +- * ColumnarToRow (55)
               +- Scan parquet default.store_sales (54)


(54) Scan parquet default.store_sales
Output [3]: [ss_quantity#91, ss_ext_discount_amt#92, ss_sold_date_sk#93]
Batched: true
Location [not included in comparison]/{warehouse_dir}/store_sales]
PushedFilters: [IsNotNull(ss_quantity), GreaterThanOrEqual(ss_quantity,41), LessThanOrEqual(ss_quantity,60)]
ReadSchema: struct<ss_quantity:int,ss_ext_discount_amt:decimal(7,2)>

(55) ColumnarToRow [codegen id : 1]
Input [3]: [ss_quantity#91, ss_ext_discount_amt#92, ss_sold_date_sk#93]

(56) Filter [codegen id : 1]
Input [3]: [ss_quantity#91, ss_ext_discount_amt#92, ss_sold_date_sk#93]
Condition : ((isnotnull(ss_quantity#91) AND (ss_quantity#91 >= 41)) AND (ss_quantity#91 <= 60))

(57) Project [codegen id : 1]
Output [1]: [ss_ext_discount_amt#92]
Input [3]: [ss_quantity#91, ss_ext_discount_amt#92, ss_sold_date_sk#93]

(58) HashAggregate [codegen id : 1]
Input [1]: [ss_ext_discount_amt#92]
Keys: []
Functions [1]: [partial_avg(UnscaledValue(ss_ext_discount_amt#92))]
Aggregate Attributes [2]: [sum#94, count#95]
Results [2]: [sum#96, count#97]

(59) Exchange
Input [2]: [sum#96, count#97]
Arguments: SinglePartition, ENSURE_REQUIREMENTS, [plan_id=8]

(60) HashAggregate [codegen id : 2]
Input [2]: [sum#96, count#97]
Keys: []
Functions [1]: [avg(UnscaledValue(ss_ext_discount_amt#92))]
Aggregate Attributes [1]: [avg(UnscaledValue(ss_ext_discount_amt#92))#98]
Results [1]: [cast((avg(UnscaledValue(ss_ext_discount_amt#92))#98 / 100.0) as decimal(11,6)) AS avg(ss_ext_discount_amt)#99]

Subquery:9 Hosting operator id = 4 Hosting Expression = Subquery scalar-subquery#20, [id=#21]
* HashAggregate (67)
+- Exchange (66)
   +- * HashAggregate (65)
      +- * Project (64)
         +- * Filter (63)
            +- * ColumnarToRow (62)
               +- Scan parquet default.store_sales (61)


(61) Scan parquet default.store_sales
Output [3]: [ss_quantity#100, ss_net_paid#101, ss_sold_date_sk#102]
Batched: true
Location [not included in comparison]/{warehouse_dir}/store_sales]
PushedFilters: [IsNotNull(ss_quantity), GreaterThanOrEqual(ss_quantity,41), LessThanOrEqual(ss_quantity,60)]
ReadSchema: struct<ss_quantity:int,ss_net_paid:decimal(7,2)>

(62) ColumnarToRow [codegen id : 1]
Input [3]: [ss_quantity#100, ss_net_paid#101, ss_sold_date_sk#102]

(63) Filter [codegen id : 1]
Input [3]: [ss_quantity#100, ss_net_paid#101, ss_sold_date_sk#102]
Condition : ((isnotnull(ss_quantity#100) AND (ss_quantity#100 >= 41)) AND (ss_quantity#100 <= 60))

(64) Project [codegen id : 1]
Output [1]: [ss_net_paid#101]
Input [3]: [ss_quantity#100, ss_net_paid#101, ss_sold_date_sk#102]

(65) HashAggregate [codegen id : 1]
Input [1]: [ss_net_paid#101]
Keys: []
Functions [1]: [partial_avg(UnscaledValue(ss_net_paid#101))]
Aggregate Attributes [2]: [sum#103, count#104]
Results [2]: [sum#105, count#106]

(66) Exchange
Input [2]: [sum#105, count#106]
Arguments: SinglePartition, ENSURE_REQUIREMENTS, [plan_id=9]

(67) HashAggregate [codegen id : 2]
Input [2]: [sum#105, count#106]
Keys: []
Functions [1]: [avg(UnscaledValue(ss_net_paid#101))]
Aggregate Attributes [1]: [avg(UnscaledValue(ss_net_paid#101))#107]
Results [1]: [cast((avg(UnscaledValue(ss_net_paid#101))#107 / 100.0) as decimal(11,6)) AS avg(ss_net_paid)#108]

Subquery:10 Hosting operator id = 4 Hosting Expression = Subquery scalar-subquery#23, [id=#24]
* HashAggregate (74)
+- Exchange (73)
   +- * HashAggregate (72)
      +- * Project (71)
         +- * Filter (70)
            +- * ColumnarToRow (69)
               +- Scan parquet default.store_sales (68)


(68) Scan parquet default.store_sales
Output [2]: [ss_quantity#109, ss_sold_date_sk#110]
Batched: true
Location [not included in comparison]/{warehouse_dir}/store_sales]
PushedFilters: [IsNotNull(ss_quantity), GreaterThanOrEqual(ss_quantity,61), LessThanOrEqual(ss_quantity,80)]
ReadSchema: struct<ss_quantity:int>

(69) ColumnarToRow [codegen id : 1]
Input [2]: [ss_quantity#109, ss_sold_date_sk#110]

(70) Filter [codegen id : 1]
Input [2]: [ss_quantity#109, ss_sold_date_sk#110]
Condition : ((isnotnull(ss_quantity#109) AND (ss_quantity#109 >= 61)) AND (ss_quantity#109 <= 80))

(71) Project [codegen id : 1]
Output: []
Input [2]: [ss_quantity#109, ss_sold_date_sk#110]

(72) HashAggregate [codegen id : 1]
Input: []
Keys: []
Functions [1]: [partial_count(1)]
Aggregate Attributes [1]: [count#111]
Results [1]: [count#112]

(73) Exchange
Input [1]: [count#112]
Arguments: SinglePartition, ENSURE_REQUIREMENTS, [plan_id=10]

(74) HashAggregate [codegen id : 2]
Input [1]: [count#112]
Keys: []
Functions [1]: [count(1)]
Aggregate Attributes [1]: [count(1)#113]
Results [1]: [count(1)#113 AS count(1)#114]

Subquery:11 Hosting operator id = 4 Hosting Expression = Subquery scalar-subquery#25, [id=#26]
* HashAggregate (81)
+- Exchange (80)
   +- * HashAggregate (79)
      +- * Project (78)
         +- * Filter (77)
            +- * ColumnarToRow (76)
               +- Scan parquet default.store_sales (75)


(75) Scan parquet default.store_sales
Output [3]: [ss_quantity#115, ss_ext_discount_amt#116, ss_sold_date_sk#117]
Batched: true
Location [not included in comparison]/{warehouse_dir}/store_sales]
PushedFilters: [IsNotNull(ss_quantity), GreaterThanOrEqual(ss_quantity,61), LessThanOrEqual(ss_quantity,80)]
ReadSchema: struct<ss_quantity:int,ss_ext_discount_amt:decimal(7,2)>

(76) ColumnarToRow [codegen id : 1]
Input [3]: [ss_quantity#115, ss_ext_discount_amt#116, ss_sold_date_sk#117]

(77) Filter [codegen id : 1]
Input [3]: [ss_quantity#115, ss_ext_discount_amt#116, ss_sold_date_sk#117]
Condition : ((isnotnull(ss_quantity#115) AND (ss_quantity#115 >= 61)) AND (ss_quantity#115 <= 80))

(78) Project [codegen id : 1]
Output [1]: [ss_ext_discount_amt#116]
Input [3]: [ss_quantity#115, ss_ext_discount_amt#116, ss_sold_date_sk#117]

(79) HashAggregate [codegen id : 1]
Input [1]: [ss_ext_discount_amt#116]
Keys: []
Functions [1]: [partial_avg(UnscaledValue(ss_ext_discount_amt#116))]
Aggregate Attributes [2]: [sum#118, count#119]
Results [2]: [sum#120, count#121]

(80) Exchange
Input [2]: [sum#120, count#121]
Arguments: SinglePartition, ENSURE_REQUIREMENTS, [plan_id=11]

(81) HashAggregate [codegen id : 2]
Input [2]: [sum#120, count#121]
Keys: []
Functions [1]: [avg(UnscaledValue(ss_ext_discount_amt#116))]
Aggregate Attributes [1]: [avg(UnscaledValue(ss_ext_discount_amt#116))#122]
Results [1]: [cast((avg(UnscaledValue(ss_ext_discount_amt#116))#122 / 100.0) as decimal(11,6)) AS avg(ss_ext_discount_amt)#123]

Subquery:12 Hosting operator id = 4 Hosting Expression = Subquery scalar-subquery#27, [id=#28]
* HashAggregate (88)
+- Exchange (87)
   +- * HashAggregate (86)
      +- * Project (85)
         +- * Filter (84)
            +- * ColumnarToRow (83)
               +- Scan parquet default.store_sales (82)


(82) Scan parquet default.store_sales
Output [3]: [ss_quantity#124, ss_net_paid#125, ss_sold_date_sk#126]
Batched: true
Location [not included in comparison]/{warehouse_dir}/store_sales]
PushedFilters: [IsNotNull(ss_quantity), GreaterThanOrEqual(ss_quantity,61), LessThanOrEqual(ss_quantity,80)]
ReadSchema: struct<ss_quantity:int,ss_net_paid:decimal(7,2)>

(83) ColumnarToRow [codegen id : 1]
Input [3]: [ss_quantity#124, ss_net_paid#125, ss_sold_date_sk#126]

(84) Filter [codegen id : 1]
Input [3]: [ss_quantity#124, ss_net_paid#125, ss_sold_date_sk#126]
Condition : ((isnotnull(ss_quantity#124) AND (ss_quantity#124 >= 61)) AND (ss_quantity#124 <= 80))

(85) Project [codegen id : 1]
Output [1]: [ss_net_paid#125]
Input [3]: [ss_quantity#124, ss_net_paid#125, ss_sold_date_sk#126]

(86) HashAggregate [codegen id : 1]
Input [1]: [ss_net_paid#125]
Keys: []
Functions [1]: [partial_avg(UnscaledValue(ss_net_paid#125))]
Aggregate Attributes [2]: [sum#127, count#128]
Results [2]: [sum#129, count#130]

(87) Exchange
Input [2]: [sum#129, count#130]
Arguments: SinglePartition, ENSURE_REQUIREMENTS, [plan_id=12]

(88) HashAggregate [codegen id : 2]
Input [2]: [sum#129, count#130]
Keys: []
Functions [1]: [avg(UnscaledValue(ss_net_paid#125))]
Aggregate Attributes [1]: [avg(UnscaledValue(ss_net_paid#125))#131]
Results [1]: [cast((avg(UnscaledValue(ss_net_paid#125))#131 / 100.0) as decimal(11,6)) AS avg(ss_net_paid)#132]

Subquery:13 Hosting operator id = 4 Hosting Expression = Subquery scalar-subquery#30, [id=#31]
* HashAggregate (95)
+- Exchange (94)
   +- * HashAggregate (93)
      +- * Project (92)
         +- * Filter (91)
            +- * ColumnarToRow (90)
               +- Scan parquet default.store_sales (89)


(89) Scan parquet default.store_sales
Output [2]: [ss_quantity#133, ss_sold_date_sk#134]
Batched: true
Location [not included in comparison]/{warehouse_dir}/store_sales]
PushedFilters: [IsNotNull(ss_quantity), GreaterThanOrEqual(ss_quantity,81), LessThanOrEqual(ss_quantity,100)]
ReadSchema: struct<ss_quantity:int>

(90) ColumnarToRow [codegen id : 1]
Input [2]: [ss_quantity#133, ss_sold_date_sk#134]

(91) Filter [codegen id : 1]
Input [2]: [ss_quantity#133, ss_sold_date_sk#134]
Condition : ((isnotnull(ss_quantity#133) AND (ss_quantity#133 >= 81)) AND (ss_quantity#133 <= 100))

(92) Project [codegen id : 1]
Output: []
Input [2]: [ss_quantity#133, ss_sold_date_sk#134]

(93) HashAggregate [codegen id : 1]
Input: []
Keys: []
Functions [1]: [partial_count(1)]
Aggregate Attributes [1]: [count#135]
Results [1]: [count#136]

(94) Exchange
Input [1]: [count#136]
Arguments: SinglePartition, ENSURE_REQUIREMENTS, [plan_id=13]

(95) HashAggregate [codegen id : 2]
Input [1]: [count#136]
Keys: []
Functions [1]: [count(1)]
Aggregate Attributes [1]: [count(1)#137]
Results [1]: [count(1)#137 AS count(1)#138]

Subquery:14 Hosting operator id = 4 Hosting Expression = Subquery scalar-subquery#32, [id=#33]
* HashAggregate (102)
+- Exchange (101)
   +- * HashAggregate (100)
      +- * Project (99)
         +- * Filter (98)
            +- * ColumnarToRow (97)
               +- Scan parquet default.store_sales (96)


(96) Scan parquet default.store_sales
Output [3]: [ss_quantity#139, ss_ext_discount_amt#140, ss_sold_date_sk#141]
Batched: true
Location [not included in comparison]/{warehouse_dir}/store_sales]
PushedFilters: [IsNotNull(ss_quantity), GreaterThanOrEqual(ss_quantity,81), LessThanOrEqual(ss_quantity,100)]
ReadSchema: struct<ss_quantity:int,ss_ext_discount_amt:decimal(7,2)>

(97) ColumnarToRow [codegen id : 1]
Input [3]: [ss_quantity#139, ss_ext_discount_amt#140, ss_sold_date_sk#141]

(98) Filter [codegen id : 1]
Input [3]: [ss_quantity#139, ss_ext_discount_amt#140, ss_sold_date_sk#141]
Condition : ((isnotnull(ss_quantity#139) AND (ss_quantity#139 >= 81)) AND (ss_quantity#139 <= 100))

(99) Project [codegen id : 1]
Output [1]: [ss_ext_discount_amt#140]
Input [3]: [ss_quantity#139, ss_ext_discount_amt#140, ss_sold_date_sk#141]

(100) HashAggregate [codegen id : 1]
Input [1]: [ss_ext_discount_amt#140]
Keys: []
Functions [1]: [partial_avg(UnscaledValue(ss_ext_discount_amt#140))]
Aggregate Attributes [2]: [sum#142, count#143]
Results [2]: [sum#144, count#145]

(101) Exchange
Input [2]: [sum#144, count#145]
Arguments: SinglePartition, ENSURE_REQUIREMENTS, [plan_id=14]

(102) HashAggregate [codegen id : 2]
Input [2]: [sum#144, count#145]
Keys: []
Functions [1]: [avg(UnscaledValue(ss_ext_discount_amt#140))]
Aggregate Attributes [1]: [avg(UnscaledValue(ss_ext_discount_amt#140))#146]
Results [1]: [cast((avg(UnscaledValue(ss_ext_discount_amt#140))#146 / 100.0) as decimal(11,6)) AS avg(ss_ext_discount_amt)#147]

Subquery:15 Hosting operator id = 4 Hosting Expression = Subquery scalar-subquery#34, [id=#35]
* HashAggregate (109)
+- Exchange (108)
   +- * HashAggregate (107)
      +- * Project (106)
         +- * Filter (105)
            +- * ColumnarToRow (104)
               +- Scan parquet default.store_sales (103)


(103) Scan parquet default.store_sales
Output [3]: [ss_quantity#148, ss_net_paid#149, ss_sold_date_sk#150]
Batched: true
Location [not included in comparison]/{warehouse_dir}/store_sales]
PushedFilters: [IsNotNull(ss_quantity), GreaterThanOrEqual(ss_quantity,81), LessThanOrEqual(ss_quantity,100)]
ReadSchema: struct<ss_quantity:int,ss_net_paid:decimal(7,2)>

(104) ColumnarToRow [codegen id : 1]
Input [3]: [ss_quantity#148, ss_net_paid#149, ss_sold_date_sk#150]

(105) Filter [codegen id : 1]
Input [3]: [ss_quantity#148, ss_net_paid#149, ss_sold_date_sk#150]
Condition : ((isnotnull(ss_quantity#148) AND (ss_quantity#148 >= 81)) AND (ss_quantity#148 <= 100))

(106) Project [codegen id : 1]
Output [1]: [ss_net_paid#149]
Input [3]: [ss_quantity#148, ss_net_paid#149, ss_sold_date_sk#150]

(107) HashAggregate [codegen id : 1]
Input [1]: [ss_net_paid#149]
Keys: []
Functions [1]: [partial_avg(UnscaledValue(ss_net_paid#149))]
Aggregate Attributes [2]: [sum#151, count#152]
Results [2]: [sum#153, count#154]

(108) Exchange
Input [2]: [sum#153, count#154]
Arguments: SinglePartition, ENSURE_REQUIREMENTS, [plan_id=15]

(109) HashAggregate [codegen id : 2]
Input [2]: [sum#153, count#154]
Keys: []
Functions [1]: [avg(UnscaledValue(ss_net_paid#149))]
Aggregate Attributes [1]: [avg(UnscaledValue(ss_net_paid#149))#155]
Results [1]: [cast((avg(UnscaledValue(ss_net_paid#149))#155 / 100.0) as decimal(11,6)) AS avg(ss_net_paid)#156]


