== Physical Plan ==
TakeOrderedAndProject (91)
+- * HashAggregate (90)
   +- Exchange (89)
      +- * HashAggregate (88)
         +- * Expand (87)
            +- Union (86)
               :- * Project (34)
               :  +- * BroadcastHashJoin LeftOuter BuildRight (33)
               :     :- * HashAggregate (19)
               :     :  +- Exchange (18)
               :     :     +- * HashAggregate (17)
               :     :        +- * Project (16)
               :     :           +- * BroadcastHashJoin Inner BuildRight (15)
               :     :              :- * Project (10)
               :     :              :  +- * BroadcastHashJoin Inner BuildRight (9)
               :     :              :     :- * Filter (3)
               :     :              :     :  +- * ColumnarToRow (2)
               :     :              :     :     +- Scan parquet default.store_sales (1)
               :     :              :     +- BroadcastExchange (8)
               :     :              :        +- * Project (7)
               :     :              :           +- * Filter (6)
               :     :              :              +- * ColumnarToRow (5)
               :     :              :                 +- Scan parquet default.date_dim (4)
               :     :              +- BroadcastExchange (14)
               :     :                 +- * Filter (13)
               :     :                    +- * ColumnarToRow (12)
               :     :                       +- Scan parquet default.store (11)
               :     +- BroadcastExchange (32)
               :        +- * HashAggregate (31)
               :           +- Exchange (30)
               :              +- * HashAggregate (29)
               :                 +- * Project (28)
               :                    +- * BroadcastHashJoin Inner BuildRight (27)
               :                       :- * Project (25)
               :                       :  +- * BroadcastHashJoin Inner BuildRight (24)
               :                       :     :- * Filter (22)
               :                       :     :  +- * ColumnarToRow (21)
               :                       :     :     +- Scan parquet default.store_returns (20)
               :                       :     +- ReusedExchange (23)
               :                       +- ReusedExchange (26)
               :- * Project (55)
               :  +- BroadcastNestedLoopJoin Inner BuildLeft (54)
               :     :- BroadcastExchange (44)
               :     :  +- * HashAggregate (43)
               :     :     +- Exchange (42)
               :     :        +- * HashAggregate (41)
               :     :           +- * Project (40)
               :     :              +- * BroadcastHashJoin Inner BuildRight (39)
               :     :                 :- * Filter (37)
               :     :                 :  +- * ColumnarToRow (36)
               :     :                 :     +- Scan parquet default.catalog_sales (35)
               :     :                 +- ReusedExchange (38)
               :     +- * HashAggregate (53)
               :        +- Exchange (52)
               :           +- * HashAggregate (51)
               :              +- * Project (50)
               :                 +- * BroadcastHashJoin Inner BuildRight (49)
               :                    :- * Filter (47)
               :                    :  +- * ColumnarToRow (46)
               :                    :     +- Scan parquet default.catalog_returns (45)
               :                    +- ReusedExchange (48)
               +- * Project (85)
                  +- * BroadcastHashJoin LeftOuter BuildRight (84)
                     :- * HashAggregate (70)
                     :  +- Exchange (69)
                     :     +- * HashAggregate (68)
                     :        +- * Project (67)
                     :           +- * BroadcastHashJoin Inner BuildRight (66)
                     :              :- * Project (61)
                     :              :  +- * BroadcastHashJoin Inner BuildRight (60)
                     :              :     :- * Filter (58)
                     :              :     :  +- * ColumnarToRow (57)
                     :              :     :     +- Scan parquet default.web_sales (56)
                     :              :     +- ReusedExchange (59)
                     :              +- BroadcastExchange (65)
                     :                 +- * Filter (64)
                     :                    +- * ColumnarToRow (63)
                     :                       +- Scan parquet default.web_page (62)
                     +- BroadcastExchange (83)
                        +- * HashAggregate (82)
                           +- Exchange (81)
                              +- * HashAggregate (80)
                                 +- * Project (79)
                                    +- * BroadcastHashJoin Inner BuildRight (78)
                                       :- * Project (76)
                                       :  +- * BroadcastHashJoin Inner BuildRight (75)
                                       :     :- * Filter (73)
                                       :     :  +- * ColumnarToRow (72)
                                       :     :     +- Scan parquet default.web_returns (71)
                                       :     +- ReusedExchange (74)
                                       +- ReusedExchange (77)


(1) Scan parquet default.store_sales
Output [4]: [ss_sold_date_sk#1, ss_store_sk#2, ss_ext_sales_price#3, ss_net_profit#4]
Batched: true
Location [not included in comparison]/{warehouse_dir}/store_sales]
PushedFilters: [IsNotNull(ss_sold_date_sk), IsNotNull(ss_store_sk)]
ReadSchema: struct<ss_sold_date_sk:int,ss_store_sk:int,ss_ext_sales_price:decimal(7,2),ss_net_profit:decimal(7,2)>

(2) ColumnarToRow [codegen id : 3]
Input [4]: [ss_sold_date_sk#1, ss_store_sk#2, ss_ext_sales_price#3, ss_net_profit#4]

(3) Filter [codegen id : 3]
Input [4]: [ss_sold_date_sk#1, ss_store_sk#2, ss_ext_sales_price#3, ss_net_profit#4]
Condition : (isnotnull(ss_sold_date_sk#1) AND isnotnull(ss_store_sk#2))

(4) Scan parquet default.date_dim
Output [2]: [d_date_sk#5, d_date#6]
Batched: true
Location [not included in comparison]/{warehouse_dir}/date_dim]
PushedFilters: [IsNotNull(d_date), GreaterThanOrEqual(d_date,2000-08-03), LessThanOrEqual(d_date,2000-09-02), IsNotNull(d_date_sk)]
ReadSchema: struct<d_date_sk:int,d_date:date>

(5) ColumnarToRow [codegen id : 1]
Input [2]: [d_date_sk#5, d_date#6]

(6) Filter [codegen id : 1]
Input [2]: [d_date_sk#5, d_date#6]
Condition : (((isnotnull(d_date#6) AND (d_date#6 >= 11172)) AND (d_date#6 <= 11202)) AND isnotnull(d_date_sk#5))

(7) Project [codegen id : 1]
Output [1]: [d_date_sk#5]
Input [2]: [d_date_sk#5, d_date#6]

(8) BroadcastExchange
Input [1]: [d_date_sk#5]
Arguments: HashedRelationBroadcastMode(List(cast(input[0, int, true] as bigint)),false), [id=#7]

(9) BroadcastHashJoin [codegen id : 3]
Left keys [1]: [ss_sold_date_sk#1]
Right keys [1]: [d_date_sk#5]
Join condition: None

(10) Project [codegen id : 3]
Output [3]: [ss_store_sk#2, ss_ext_sales_price#3, ss_net_profit#4]
Input [5]: [ss_sold_date_sk#1, ss_store_sk#2, ss_ext_sales_price#3, ss_net_profit#4, d_date_sk#5]

(11) Scan parquet default.store
Output [1]: [s_store_sk#8]
Batched: true
Location [not included in comparison]/{warehouse_dir}/store]
PushedFilters: [IsNotNull(s_store_sk)]
ReadSchema: struct<s_store_sk:int>

(12) ColumnarToRow [codegen id : 2]
Input [1]: [s_store_sk#8]

(13) Filter [codegen id : 2]
Input [1]: [s_store_sk#8]
Condition : isnotnull(s_store_sk#8)

(14) BroadcastExchange
Input [1]: [s_store_sk#8]
Arguments: HashedRelationBroadcastMode(List(cast(input[0, int, false] as bigint)),false), [id=#9]

(15) BroadcastHashJoin [codegen id : 3]
Left keys [1]: [ss_store_sk#2]
Right keys [1]: [s_store_sk#8]
Join condition: None

(16) Project [codegen id : 3]
Output [3]: [ss_ext_sales_price#3, ss_net_profit#4, s_store_sk#8]
Input [4]: [ss_store_sk#2, ss_ext_sales_price#3, ss_net_profit#4, s_store_sk#8]

(17) HashAggregate [codegen id : 3]
Input [3]: [ss_ext_sales_price#3, ss_net_profit#4, s_store_sk#8]
Keys [1]: [s_store_sk#8]
Functions [2]: [partial_sum(UnscaledValue(ss_ext_sales_price#3)), partial_sum(UnscaledValue(ss_net_profit#4))]
Aggregate Attributes [2]: [sum#10, sum#11]
Results [3]: [s_store_sk#8, sum#12, sum#13]

(18) Exchange
Input [3]: [s_store_sk#8, sum#12, sum#13]
Arguments: hashpartitioning(s_store_sk#8, 5), true, [id=#14]

(19) HashAggregate [codegen id : 8]
Input [3]: [s_store_sk#8, sum#12, sum#13]
Keys [1]: [s_store_sk#8]
Functions [2]: [sum(UnscaledValue(ss_ext_sales_price#3)), sum(UnscaledValue(ss_net_profit#4))]
Aggregate Attributes [2]: [sum(UnscaledValue(ss_ext_sales_price#3))#15, sum(UnscaledValue(ss_net_profit#4))#16]
Results [3]: [s_store_sk#8, MakeDecimal(sum(UnscaledValue(ss_ext_sales_price#3))#15,17,2) AS sales#17, MakeDecimal(sum(UnscaledValue(ss_net_profit#4))#16,17,2) AS profit#18]

(20) Scan parquet default.store_returns
Output [4]: [sr_returned_date_sk#19, sr_store_sk#20, sr_return_amt#21, sr_net_loss#22]
Batched: true
Location [not included in comparison]/{warehouse_dir}/store_returns]
PushedFilters: [IsNotNull(sr_returned_date_sk), IsNotNull(sr_store_sk)]
ReadSchema: struct<sr_returned_date_sk:bigint,sr_store_sk:bigint,sr_return_amt:decimal(7,2),sr_net_loss:decimal(7,2)>

(21) ColumnarToRow [codegen id : 6]
Input [4]: [sr_returned_date_sk#19, sr_store_sk#20, sr_return_amt#21, sr_net_loss#22]

(22) Filter [codegen id : 6]
Input [4]: [sr_returned_date_sk#19, sr_store_sk#20, sr_return_amt#21, sr_net_loss#22]
Condition : (isnotnull(sr_returned_date_sk#19) AND isnotnull(sr_store_sk#20))

(23) ReusedExchange [Reuses operator id: 8]
Output [1]: [d_date_sk#5]

(24) BroadcastHashJoin [codegen id : 6]
Left keys [1]: [sr_returned_date_sk#19]
Right keys [1]: [cast(d_date_sk#5 as bigint)]
Join condition: None

(25) Project [codegen id : 6]
Output [3]: [sr_store_sk#20, sr_return_amt#21, sr_net_loss#22]
Input [5]: [sr_returned_date_sk#19, sr_store_sk#20, sr_return_amt#21, sr_net_loss#22, d_date_sk#5]

(26) ReusedExchange [Reuses operator id: 14]
Output [1]: [s_store_sk#23]

(27) BroadcastHashJoin [codegen id : 6]
Left keys [1]: [sr_store_sk#20]
Right keys [1]: [cast(s_store_sk#23 as bigint)]
Join condition: None

(28) Project [codegen id : 6]
Output [3]: [sr_return_amt#21, sr_net_loss#22, s_store_sk#23]
Input [4]: [sr_store_sk#20, sr_return_amt#21, sr_net_loss#22, s_store_sk#23]

(29) HashAggregate [codegen id : 6]
Input [3]: [sr_return_amt#21, sr_net_loss#22, s_store_sk#23]
Keys [1]: [s_store_sk#23]
Functions [2]: [partial_sum(UnscaledValue(sr_return_amt#21)), partial_sum(UnscaledValue(sr_net_loss#22))]
Aggregate Attributes [2]: [sum#24, sum#25]
Results [3]: [s_store_sk#23, sum#26, sum#27]

(30) Exchange
Input [3]: [s_store_sk#23, sum#26, sum#27]
Arguments: hashpartitioning(s_store_sk#23, 5), true, [id=#28]

(31) HashAggregate [codegen id : 7]
Input [3]: [s_store_sk#23, sum#26, sum#27]
Keys [1]: [s_store_sk#23]
Functions [2]: [sum(UnscaledValue(sr_return_amt#21)), sum(UnscaledValue(sr_net_loss#22))]
Aggregate Attributes [2]: [sum(UnscaledValue(sr_return_amt#21))#29, sum(UnscaledValue(sr_net_loss#22))#30]
Results [3]: [s_store_sk#23, MakeDecimal(sum(UnscaledValue(sr_return_amt#21))#29,17,2) AS returns#31, MakeDecimal(sum(UnscaledValue(sr_net_loss#22))#30,17,2) AS profit_loss#32]

(32) BroadcastExchange
Input [3]: [s_store_sk#23, returns#31, profit_loss#32]
Arguments: HashedRelationBroadcastMode(List(cast(input[0, int, true] as bigint)),false), [id=#33]

(33) BroadcastHashJoin [codegen id : 8]
Left keys [1]: [s_store_sk#8]
Right keys [1]: [s_store_sk#23]
Join condition: None

(34) Project [codegen id : 8]
Output [5]: [sales#17, coalesce(returns#31, 0.00) AS returns#34, CheckOverflow((promote_precision(cast(profit#18 as decimal(18,2))) - promote_precision(cast(coalesce(profit_loss#32, 0.00) as decimal(18,2)))), DecimalType(18,2), true) AS profit#35, store channel AS channel#36, s_store_sk#8 AS id#37]
Input [6]: [s_store_sk#8, sales#17, profit#18, s_store_sk#23, returns#31, profit_loss#32]

(35) Scan parquet default.catalog_sales
Output [4]: [cs_sold_date_sk#38, cs_call_center_sk#39, cs_ext_sales_price#40, cs_net_profit#41]
Batched: true
Location [not included in comparison]/{warehouse_dir}/catalog_sales]
PushedFilters: [IsNotNull(cs_sold_date_sk)]
ReadSchema: struct<cs_sold_date_sk:int,cs_call_center_sk:int,cs_ext_sales_price:decimal(7,2),cs_net_profit:decimal(7,2)>

(36) ColumnarToRow [codegen id : 10]
Input [4]: [cs_sold_date_sk#38, cs_call_center_sk#39, cs_ext_sales_price#40, cs_net_profit#41]

(37) Filter [codegen id : 10]
Input [4]: [cs_sold_date_sk#38, cs_call_center_sk#39, cs_ext_sales_price#40, cs_net_profit#41]
Condition : isnotnull(cs_sold_date_sk#38)

(38) ReusedExchange [Reuses operator id: 8]
Output [1]: [d_date_sk#5]

(39) BroadcastHashJoin [codegen id : 10]
Left keys [1]: [cs_sold_date_sk#38]
Right keys [1]: [d_date_sk#5]
Join condition: None

(40) Project [codegen id : 10]
Output [3]: [cs_call_center_sk#39, cs_ext_sales_price#40, cs_net_profit#41]
Input [5]: [cs_sold_date_sk#38, cs_call_center_sk#39, cs_ext_sales_price#40, cs_net_profit#41, d_date_sk#5]

(41) HashAggregate [codegen id : 10]
Input [3]: [cs_call_center_sk#39, cs_ext_sales_price#40, cs_net_profit#41]
Keys [1]: [cs_call_center_sk#39]
Functions [2]: [partial_sum(UnscaledValue(cs_ext_sales_price#40)), partial_sum(UnscaledValue(cs_net_profit#41))]
Aggregate Attributes [2]: [sum#42, sum#43]
Results [3]: [cs_call_center_sk#39, sum#44, sum#45]

(42) Exchange
Input [3]: [cs_call_center_sk#39, sum#44, sum#45]
Arguments: hashpartitioning(cs_call_center_sk#39, 5), true, [id=#46]

(43) HashAggregate [codegen id : 11]
Input [3]: [cs_call_center_sk#39, sum#44, sum#45]
Keys [1]: [cs_call_center_sk#39]
Functions [2]: [sum(UnscaledValue(cs_ext_sales_price#40)), sum(UnscaledValue(cs_net_profit#41))]
Aggregate Attributes [2]: [sum(UnscaledValue(cs_ext_sales_price#40))#47, sum(UnscaledValue(cs_net_profit#41))#48]
Results [3]: [cs_call_center_sk#39, MakeDecimal(sum(UnscaledValue(cs_ext_sales_price#40))#47,17,2) AS sales#49, MakeDecimal(sum(UnscaledValue(cs_net_profit#41))#48,17,2) AS profit#50]

(44) BroadcastExchange
Input [3]: [cs_call_center_sk#39, sales#49, profit#50]
Arguments: IdentityBroadcastMode, [id=#51]

(45) Scan parquet default.catalog_returns
Output [3]: [cr_returned_date_sk#52, cr_return_amount#53, cr_net_loss#54]
Batched: true
Location [not included in comparison]/{warehouse_dir}/catalog_returns]
PushedFilters: [IsNotNull(cr_returned_date_sk)]
ReadSchema: struct<cr_returned_date_sk:int,cr_return_amount:decimal(7,2),cr_net_loss:decimal(7,2)>

(46) ColumnarToRow [codegen id : 13]
Input [3]: [cr_returned_date_sk#52, cr_return_amount#53, cr_net_loss#54]

(47) Filter [codegen id : 13]
Input [3]: [cr_returned_date_sk#52, cr_return_amount#53, cr_net_loss#54]
Condition : isnotnull(cr_returned_date_sk#52)

(48) ReusedExchange [Reuses operator id: 8]
Output [1]: [d_date_sk#5]

(49) BroadcastHashJoin [codegen id : 13]
Left keys [1]: [cr_returned_date_sk#52]
Right keys [1]: [d_date_sk#5]
Join condition: None

(50) Project [codegen id : 13]
Output [2]: [cr_return_amount#53, cr_net_loss#54]
Input [4]: [cr_returned_date_sk#52, cr_return_amount#53, cr_net_loss#54, d_date_sk#5]

(51) HashAggregate [codegen id : 13]
Input [2]: [cr_return_amount#53, cr_net_loss#54]
Keys: []
Functions [2]: [partial_sum(UnscaledValue(cr_return_amount#53)), partial_sum(UnscaledValue(cr_net_loss#54))]
Aggregate Attributes [2]: [sum#55, sum#56]
Results [2]: [sum#57, sum#58]

(52) Exchange
Input [2]: [sum#57, sum#58]
Arguments: SinglePartition, true, [id=#59]

(53) HashAggregate [codegen id : 14]
Input [2]: [sum#57, sum#58]
Keys: []
Functions [2]: [sum(UnscaledValue(cr_return_amount#53)), sum(UnscaledValue(cr_net_loss#54))]
Aggregate Attributes [2]: [sum(UnscaledValue(cr_return_amount#53))#60, sum(UnscaledValue(cr_net_loss#54))#61]
Results [2]: [MakeDecimal(sum(UnscaledValue(cr_return_amount#53))#60,17,2) AS returns#62, MakeDecimal(sum(UnscaledValue(cr_net_loss#54))#61,17,2) AS profit_loss#63]

(54) BroadcastNestedLoopJoin
Join condition: None

(55) Project [codegen id : 15]
Output [5]: [sales#49, returns#62, CheckOverflow((promote_precision(cast(profit#50 as decimal(18,2))) - promote_precision(cast(profit_loss#63 as decimal(18,2)))), DecimalType(18,2), true) AS profit#64, catalog channel AS channel#65, cs_call_center_sk#39 AS id#66]
Input [5]: [cs_call_center_sk#39, sales#49, profit#50, returns#62, profit_loss#63]

(56) Scan parquet default.web_sales
Output [4]: [ws_sold_date_sk#67, ws_web_page_sk#68, ws_ext_sales_price#69, ws_net_profit#70]
Batched: true
Location [not included in comparison]/{warehouse_dir}/web_sales]
PushedFilters: [IsNotNull(ws_sold_date_sk), IsNotNull(ws_web_page_sk)]
ReadSchema: struct<ws_sold_date_sk:int,ws_web_page_sk:int,ws_ext_sales_price:decimal(7,2),ws_net_profit:decimal(7,2)>

(57) ColumnarToRow [codegen id : 18]
Input [4]: [ws_sold_date_sk#67, ws_web_page_sk#68, ws_ext_sales_price#69, ws_net_profit#70]

(58) Filter [codegen id : 18]
Input [4]: [ws_sold_date_sk#67, ws_web_page_sk#68, ws_ext_sales_price#69, ws_net_profit#70]
Condition : (isnotnull(ws_sold_date_sk#67) AND isnotnull(ws_web_page_sk#68))

(59) ReusedExchange [Reuses operator id: 8]
Output [1]: [d_date_sk#5]

(60) BroadcastHashJoin [codegen id : 18]
Left keys [1]: [ws_sold_date_sk#67]
Right keys [1]: [d_date_sk#5]
Join condition: None

(61) Project [codegen id : 18]
Output [3]: [ws_web_page_sk#68, ws_ext_sales_price#69, ws_net_profit#70]
Input [5]: [ws_sold_date_sk#67, ws_web_page_sk#68, ws_ext_sales_price#69, ws_net_profit#70, d_date_sk#5]

(62) Scan parquet default.web_page
Output [1]: [wp_web_page_sk#71]
Batched: true
Location [not included in comparison]/{warehouse_dir}/web_page]
PushedFilters: [IsNotNull(wp_web_page_sk)]
ReadSchema: struct<wp_web_page_sk:int>

(63) ColumnarToRow [codegen id : 17]
Input [1]: [wp_web_page_sk#71]

(64) Filter [codegen id : 17]
Input [1]: [wp_web_page_sk#71]
Condition : isnotnull(wp_web_page_sk#71)

(65) BroadcastExchange
Input [1]: [wp_web_page_sk#71]
Arguments: HashedRelationBroadcastMode(List(cast(input[0, int, false] as bigint)),false), [id=#72]

(66) BroadcastHashJoin [codegen id : 18]
Left keys [1]: [ws_web_page_sk#68]
Right keys [1]: [wp_web_page_sk#71]
Join condition: None

(67) Project [codegen id : 18]
Output [3]: [ws_ext_sales_price#69, ws_net_profit#70, wp_web_page_sk#71]
Input [4]: [ws_web_page_sk#68, ws_ext_sales_price#69, ws_net_profit#70, wp_web_page_sk#71]

(68) HashAggregate [codegen id : 18]
Input [3]: [ws_ext_sales_price#69, ws_net_profit#70, wp_web_page_sk#71]
Keys [1]: [wp_web_page_sk#71]
Functions [2]: [partial_sum(UnscaledValue(ws_ext_sales_price#69)), partial_sum(UnscaledValue(ws_net_profit#70))]
Aggregate Attributes [2]: [sum#73, sum#74]
Results [3]: [wp_web_page_sk#71, sum#75, sum#76]

(69) Exchange
Input [3]: [wp_web_page_sk#71, sum#75, sum#76]
Arguments: hashpartitioning(wp_web_page_sk#71, 5), true, [id=#77]

(70) HashAggregate [codegen id : 23]
Input [3]: [wp_web_page_sk#71, sum#75, sum#76]
Keys [1]: [wp_web_page_sk#71]
Functions [2]: [sum(UnscaledValue(ws_ext_sales_price#69)), sum(UnscaledValue(ws_net_profit#70))]
Aggregate Attributes [2]: [sum(UnscaledValue(ws_ext_sales_price#69))#78, sum(UnscaledValue(ws_net_profit#70))#79]
Results [3]: [wp_web_page_sk#71, MakeDecimal(sum(UnscaledValue(ws_ext_sales_price#69))#78,17,2) AS sales#80, MakeDecimal(sum(UnscaledValue(ws_net_profit#70))#79,17,2) AS profit#81]

(71) Scan parquet default.web_returns
Output [4]: [wr_returned_date_sk#82, wr_web_page_sk#83, wr_return_amt#84, wr_net_loss#85]
Batched: true
Location [not included in comparison]/{warehouse_dir}/web_returns]
PushedFilters: [IsNotNull(wr_returned_date_sk), IsNotNull(wr_web_page_sk)]
ReadSchema: struct<wr_returned_date_sk:bigint,wr_web_page_sk:bigint,wr_return_amt:decimal(7,2),wr_net_loss:decimal(7,2)>

(72) ColumnarToRow [codegen id : 21]
Input [4]: [wr_returned_date_sk#82, wr_web_page_sk#83, wr_return_amt#84, wr_net_loss#85]

(73) Filter [codegen id : 21]
Input [4]: [wr_returned_date_sk#82, wr_web_page_sk#83, wr_return_amt#84, wr_net_loss#85]
Condition : (isnotnull(wr_returned_date_sk#82) AND isnotnull(wr_web_page_sk#83))

(74) ReusedExchange [Reuses operator id: 8]
Output [1]: [d_date_sk#5]

(75) BroadcastHashJoin [codegen id : 21]
Left keys [1]: [wr_returned_date_sk#82]
Right keys [1]: [cast(d_date_sk#5 as bigint)]
Join condition: None

(76) Project [codegen id : 21]
Output [3]: [wr_web_page_sk#83, wr_return_amt#84, wr_net_loss#85]
Input [5]: [wr_returned_date_sk#82, wr_web_page_sk#83, wr_return_amt#84, wr_net_loss#85, d_date_sk#5]

(77) ReusedExchange [Reuses operator id: 65]
Output [1]: [wp_web_page_sk#86]

(78) BroadcastHashJoin [codegen id : 21]
Left keys [1]: [wr_web_page_sk#83]
Right keys [1]: [cast(wp_web_page_sk#86 as bigint)]
Join condition: None

(79) Project [codegen id : 21]
Output [3]: [wr_return_amt#84, wr_net_loss#85, wp_web_page_sk#86]
Input [4]: [wr_web_page_sk#83, wr_return_amt#84, wr_net_loss#85, wp_web_page_sk#86]

(80) HashAggregate [codegen id : 21]
Input [3]: [wr_return_amt#84, wr_net_loss#85, wp_web_page_sk#86]
Keys [1]: [wp_web_page_sk#86]
Functions [2]: [partial_sum(UnscaledValue(wr_return_amt#84)), partial_sum(UnscaledValue(wr_net_loss#85))]
Aggregate Attributes [2]: [sum#87, sum#88]
Results [3]: [wp_web_page_sk#86, sum#89, sum#90]

(81) Exchange
Input [3]: [wp_web_page_sk#86, sum#89, sum#90]
Arguments: hashpartitioning(wp_web_page_sk#86, 5), true, [id=#91]

(82) HashAggregate [codegen id : 22]
Input [3]: [wp_web_page_sk#86, sum#89, sum#90]
Keys [1]: [wp_web_page_sk#86]
Functions [2]: [sum(UnscaledValue(wr_return_amt#84)), sum(UnscaledValue(wr_net_loss#85))]
Aggregate Attributes [2]: [sum(UnscaledValue(wr_return_amt#84))#92, sum(UnscaledValue(wr_net_loss#85))#93]
Results [3]: [wp_web_page_sk#86, MakeDecimal(sum(UnscaledValue(wr_return_amt#84))#92,17,2) AS returns#94, MakeDecimal(sum(UnscaledValue(wr_net_loss#85))#93,17,2) AS profit_loss#95]

(83) BroadcastExchange
Input [3]: [wp_web_page_sk#86, returns#94, profit_loss#95]
Arguments: HashedRelationBroadcastMode(List(cast(input[0, int, true] as bigint)),false), [id=#96]

(84) BroadcastHashJoin [codegen id : 23]
Left keys [1]: [wp_web_page_sk#71]
Right keys [1]: [wp_web_page_sk#86]
Join condition: None

(85) Project [codegen id : 23]
Output [5]: [sales#80, coalesce(returns#94, 0.00) AS returns#97, CheckOverflow((promote_precision(cast(profit#81 as decimal(18,2))) - promote_precision(cast(coalesce(profit_loss#95, 0.00) as decimal(18,2)))), DecimalType(18,2), true) AS profit#98, web channel AS channel#99, wp_web_page_sk#71 AS id#100]
Input [6]: [wp_web_page_sk#71, sales#80, profit#81, wp_web_page_sk#86, returns#94, profit_loss#95]

(86) Union

(87) Expand [codegen id : 24]
Input [5]: [sales#17, returns#34, profit#35, channel#36, id#37]
Arguments: [List(sales#17, returns#34, profit#35, channel#36, id#37, 0), List(sales#17, returns#34, profit#35, channel#36, null, 1), List(sales#17, returns#34, profit#35, null, null, 3)], [sales#17, returns#34, profit#35, channel#101, id#102, spark_grouping_id#103]

(88) HashAggregate [codegen id : 24]
Input [6]: [sales#17, returns#34, profit#35, channel#101, id#102, spark_grouping_id#103]
Keys [3]: [channel#101, id#102, spark_grouping_id#103]
Functions [3]: [partial_sum(sales#17), partial_sum(returns#34), partial_sum(profit#35)]
Aggregate Attributes [6]: [sum#104, isEmpty#105, sum#106, isEmpty#107, sum#108, isEmpty#109]
Results [9]: [channel#101, id#102, spark_grouping_id#103, sum#110, isEmpty#111, sum#112, isEmpty#113, sum#114, isEmpty#115]

(89) Exchange
Input [9]: [channel#101, id#102, spark_grouping_id#103, sum#110, isEmpty#111, sum#112, isEmpty#113, sum#114, isEmpty#115]
Arguments: hashpartitioning(channel#101, id#102, spark_grouping_id#103, 5), true, [id=#116]

(90) HashAggregate [codegen id : 25]
Input [9]: [channel#101, id#102, spark_grouping_id#103, sum#110, isEmpty#111, sum#112, isEmpty#113, sum#114, isEmpty#115]
Keys [3]: [channel#101, id#102, spark_grouping_id#103]
Functions [3]: [sum(sales#17), sum(returns#34), sum(profit#35)]
Aggregate Attributes [3]: [sum(sales#17)#117, sum(returns#34)#118, sum(profit#35)#119]
Results [5]: [channel#101, id#102, sum(sales#17)#117 AS sales#120, sum(returns#34)#118 AS returns#121, sum(profit#35)#119 AS profit#122]

(91) TakeOrderedAndProject
Input [5]: [channel#101, id#102, sales#120, returns#121, profit#122]
Arguments: 100, [channel#101 ASC NULLS FIRST, id#102 ASC NULLS FIRST], [channel#101, id#102, sales#120, returns#121, profit#122]

