== Physical Plan ==
VeloxColumnarToRow (249)
+- TakeOrderedAndProjectExecTransformer (248)
   +- ^ RegularHashAggregateExecTransformer (246)
      +- ^ InputIteratorTransformer (245)
         +- ColumnarExchange (243)
            +- VeloxResizeBatches (242)
               +- ^ ProjectExecTransformer (240)
                  +- ^ FlushableHashAggregateExecTransformer (239)
                     +- ^ InputIteratorTransformer (238)
                        +- ColumnarUnion (236)
                           :- ^ ProjectExecTransformer (145)
                           :  +- ^ RegularHashAggregateExecTransformer (144)
                           :     +- ^ InputIteratorTransformer (143)
                           :        +- ColumnarUnion (141)
                           :           :- ^ ProjectExecTransformer (51)
                           :           :  +- ^ BroadcastHashJoinExecTransformer LeftOuter BuildRight (50)
                           :           :     :- ^ ProjectExecTransformer (24)
                           :           :     :  +- ^ RegularHashAggregateExecTransformer (23)
                           :           :     :     +- ^ InputIteratorTransformer (22)
                           :           :     :        +- ColumnarExchange (20)
                           :           :     :           +- VeloxResizeBatches (19)
                           :           :     :              +- ^ ProjectExecTransformer (17)
                           :           :     :                 +- ^ FlushableHashAggregateExecTransformer (16)
                           :           :     :                    +- ^ ProjectExecTransformer (15)
                           :           :     :                       +- ^ BroadcastHashJoinExecTransformer Inner BuildRight (14)
                           :           :     :                          :- ^ ProjectExecTransformer (7)
                           :           :     :                          :  +- ^ BroadcastHashJoinExecTransformer Inner BuildRight (6)
                           :           :     :                          :     :- ^ FilterExecTransformer (2)
                           :           :     :                          :     :  +- ^ FileSourceScanExecTransformer parquet spark_catalog.default.store_sales (1)
                           :           :     :                          :     +- ^ InputIteratorTransformer (5)
                           :           :     :                          :        +- ReusedExchange (3)
                           :           :     :                          +- ^ InputIteratorTransformer (13)
                           :           :     :                             +- ColumnarBroadcastExchange (11)
                           :           :     :                                +- ^ FilterExecTransformer (9)
                           :           :     :                                   +- ^ FileSourceScanExecTransformer parquet spark_catalog.default.store (8)
                           :           :     +- ^ InputIteratorTransformer (49)
                           :           :        +- ColumnarBroadcastExchange (47)
                           :           :           +- ^ ProjectExecTransformer (45)
                           :           :              +- ^ RegularHashAggregateExecTransformer (44)
                           :           :                 +- ^ InputIteratorTransformer (43)
                           :           :                    +- ColumnarExchange (41)
                           :           :                       +- VeloxResizeBatches (40)
                           :           :                          +- ^ ProjectExecTransformer (38)
                           :           :                             +- ^ FlushableHashAggregateExecTransformer (37)
                           :           :                                +- ^ ProjectExecTransformer (36)
                           :           :                                   +- ^ BroadcastHashJoinExecTransformer Inner BuildRight (35)
                           :           :                                      :- ^ ProjectExecTransformer (31)
                           :           :                                      :  +- ^ BroadcastHashJoinExecTransformer Inner BuildRight (30)
                           :           :                                      :     :- ^ FilterExecTransformer (26)
                           :           :                                      :     :  +- ^ FileSourceScanExecTransformer parquet spark_catalog.default.store_returns (25)
                           :           :                                      :     +- ^ InputIteratorTransformer (29)
                           :           :                                      :        +- ReusedExchange (27)
                           :           :                                      +- ^ InputIteratorTransformer (34)
                           :           :                                         +- ReusedExchange (32)
                           :           :- ^ ProjectExecTransformer (87)
                           :           :  +- ^ VeloxBroadcastNestedLoopJoinExecTransformer Inner BuildRight (86)
                           :           :     :- ^ ProjectExecTransformer (67)
                           :           :     :  +- ^ RegularHashAggregateExecTransformer (66)
                           :           :     :     +- ^ InputIteratorTransformer (65)
                           :           :     :        +- ColumnarExchange (63)
                           :           :     :           +- VeloxResizeBatches (62)
                           :           :     :              +- ^ ProjectExecTransformer (60)
                           :           :     :                 +- ^ FlushableHashAggregateExecTransformer (59)
                           :           :     :                    +- ^ ProjectExecTransformer (58)
                           :           :     :                       +- ^ BroadcastHashJoinExecTransformer Inner BuildRight (57)
                           :           :     :                          :- ^ FileSourceScanExecTransformer parquet spark_catalog.default.catalog_sales (53)
                           :           :     :                          +- ^ InputIteratorTransformer (56)
                           :           :     :                             +- ReusedExchange (54)
                           :           :     +- ^ InputIteratorTransformer (85)
                           :           :        +- ColumnarBroadcastExchange (83)
                           :           :           +- ^ ProjectExecTransformer (81)
                           :           :              +- ^ RegularHashAggregateExecTransformer (80)
                           :           :                 +- ^ InputIteratorTransformer (79)
                           :           :                    +- ColumnarExchange (77)
                           :           :                       +- VeloxResizeBatches (76)
                           :           :                          +- ^ FlushableHashAggregateExecTransformer (74)
                           :           :                             +- ^ ProjectExecTransformer (73)
                           :           :                                +- ^ BroadcastHashJoinExecTransformer Inner BuildRight (72)
                           :           :                                   :- ^ FileSourceScanExecTransformer parquet spark_catalog.default.catalog_returns (68)
                           :           :                                   +- ^ InputIteratorTransformer (71)
                           :           :                                      +- ReusedExchange (69)
                           :           +- ^ ProjectExecTransformer (139)
                           :              +- ^ BroadcastHashJoinExecTransformer LeftOuter BuildRight (138)
                           :                 :- ^ ProjectExecTransformer (112)
                           :                 :  +- ^ RegularHashAggregateExecTransformer (111)
                           :                 :     +- ^ InputIteratorTransformer (110)
                           :                 :        +- ColumnarExchange (108)
                           :                 :           +- VeloxResizeBatches (107)
                           :                 :              +- ^ ProjectExecTransformer (105)
                           :                 :                 +- ^ FlushableHashAggregateExecTransformer (104)
                           :                 :                    +- ^ ProjectExecTransformer (103)
                           :                 :                       +- ^ BroadcastHashJoinExecTransformer Inner BuildRight (102)
                           :                 :                          :- ^ ProjectExecTransformer (95)
                           :                 :                          :  +- ^ BroadcastHashJoinExecTransformer Inner BuildRight (94)
                           :                 :                          :     :- ^ FilterExecTransformer (90)
                           :                 :                          :     :  +- ^ FileSourceScanExecTransformer parquet spark_catalog.default.web_sales (89)
                           :                 :                          :     +- ^ InputIteratorTransformer (93)
                           :                 :                          :        +- ReusedExchange (91)
                           :                 :                          +- ^ InputIteratorTransformer (101)
                           :                 :                             +- ColumnarBroadcastExchange (99)
                           :                 :                                +- ^ FilterExecTransformer (97)
                           :                 :                                   +- ^ FileSourceScanExecTransformer parquet spark_catalog.default.web_page (96)
                           :                 +- ^ InputIteratorTransformer (137)
                           :                    +- ColumnarBroadcastExchange (135)
                           :                       +- ^ ProjectExecTransformer (133)
                           :                          +- ^ RegularHashAggregateExecTransformer (132)
                           :                             +- ^ InputIteratorTransformer (131)
                           :                                +- ColumnarExchange (129)
                           :                                   +- VeloxResizeBatches (128)
                           :                                      +- ^ ProjectExecTransformer (126)
                           :                                         +- ^ FlushableHashAggregateExecTransformer (125)
                           :                                            +- ^ ProjectExecTransformer (124)
                           :                                               +- ^ BroadcastHashJoinExecTransformer Inner BuildRight (123)
                           :                                                  :- ^ ProjectExecTransformer (119)
                           :                                                  :  +- ^ BroadcastHashJoinExecTransformer Inner BuildRight (118)
                           :                                                  :     :- ^ FilterExecTransformer (114)
                           :                                                  :     :  +- ^ FileSourceScanExecTransformer parquet spark_catalog.default.web_returns (113)
                           :                                                  :     +- ^ InputIteratorTransformer (117)
                           :                                                  :        +- ReusedExchange (115)
                           :                                                  +- ^ InputIteratorTransformer (122)
                           :                                                     +- ReusedExchange (120)
                           :- ^ ProjectExecTransformer (193)
                           :  +- ^ RegularHashAggregateExecTransformer (192)
                           :     +- ^ InputIteratorTransformer (191)
                           :        +- ColumnarExchange (189)
                           :           +- VeloxResizeBatches (188)
                           :              +- ^ ProjectExecTransformer (186)
                           :                 +- ^ FlushableHashAggregateExecTransformer (185)
                           :                    +- ^ ProjectExecTransformer (184)
                           :                       +- ^ RegularHashAggregateExecTransformer (183)
                           :                          +- ^ InputIteratorTransformer (182)
                           :                             +- ColumnarUnion (180)
                           :                                :- ^ ProjectExecTransformer (156)
                           :                                :  +- ^ BroadcastHashJoinExecTransformer LeftOuter BuildRight (155)
                           :                                :     :- ^ ProjectExecTransformer (151)
                           :                                :     :  +- ^ RegularHashAggregateExecTransformer (150)
                           :                                :     :     +- ^ InputIteratorTransformer (149)
                           :                                :     :        +- ReusedExchange (147)
                           :                                :     +- ^ InputIteratorTransformer (154)
                           :                                :        +- ReusedExchange (152)
                           :                                :- ^ ProjectExecTransformer (167)
                           :                                :  +- ^ VeloxBroadcastNestedLoopJoinExecTransformer Inner BuildRight (166)
                           :                                :     :- ^ ProjectExecTransformer (162)
                           :                                :     :  +- ^ RegularHashAggregateExecTransformer (161)
                           :                                :     :     +- ^ InputIteratorTransformer (160)
                           :                                :     :        +- ReusedExchange (158)
                           :                                :     +- ^ InputIteratorTransformer (165)
                           :                                :        +- ReusedExchange (163)
                           :                                +- ^ ProjectExecTransformer (178)
                           :                                   +- ^ BroadcastHashJoinExecTransformer LeftOuter BuildRight (177)
                           :                                      :- ^ ProjectExecTransformer (173)
                           :                                      :  +- ^ RegularHashAggregateExecTransformer (172)
                           :                                      :     +- ^ InputIteratorTransformer (171)
                           :                                      :        +- ReusedExchange (169)
                           :                                      +- ^ InputIteratorTransformer (176)
                           :                                         +- ReusedExchange (174)
                           +- ^ ProjectExecTransformer (234)
                              +- ^ RegularHashAggregateExecTransformer (233)
                                 +- ^ ProjectExecTransformer (232)
                                    +- ^ RegularHashAggregateExecTransformer (231)
                                       +- ^ InputIteratorTransformer (230)
                                          +- ColumnarUnion (228)
                                             :- ^ ProjectExecTransformer (204)
                                             :  +- ^ BroadcastHashJoinExecTransformer LeftOuter BuildRight (203)
                                             :     :- ^ ProjectExecTransformer (199)
                                             :     :  +- ^ RegularHashAggregateExecTransformer (198)
                                             :     :     +- ^ InputIteratorTransformer (197)
                                             :     :        +- ReusedExchange (195)
                                             :     +- ^ InputIteratorTransformer (202)
                                             :        +- ReusedExchange (200)
                                             :- ^ ProjectExecTransformer (215)
                                             :  +- ^ VeloxBroadcastNestedLoopJoinExecTransformer Inner BuildRight (214)
                                             :     :- ^ ProjectExecTransformer (210)
                                             :     :  +- ^ RegularHashAggregateExecTransformer (209)
                                             :     :     +- ^ InputIteratorTransformer (208)
                                             :     :        +- ReusedExchange (206)
                                             :     +- ^ InputIteratorTransformer (213)
                                             :        +- ReusedExchange (211)
                                             +- ^ ProjectExecTransformer (226)
                                                +- ^ BroadcastHashJoinExecTransformer LeftOuter BuildRight (225)
                                                   :- ^ ProjectExecTransformer (221)
                                                   :  +- ^ RegularHashAggregateExecTransformer (220)
                                                   :     +- ^ InputIteratorTransformer (219)
                                                   :        +- ReusedExchange (217)
                                                   +- ^ InputIteratorTransformer (224)
                                                      +- ReusedExchange (222)


(1) FileSourceScanExecTransformer parquet spark_catalog.default.store_sales
Output [4]: [ss_store_sk#1, ss_ext_sales_price#2, ss_net_profit#3, ss_sold_date_sk#4]
Batched: true
Location: InMemoryFileIndex []
PartitionFilters: [isnotnull(ss_sold_date_sk#4), dynamicpruningexpression(ss_sold_date_sk#4 IN dynamicpruning#5)]
PushedFilters: [IsNotNull(ss_store_sk)]
ReadSchema: struct<ss_store_sk:int,ss_ext_sales_price:decimal(7,2),ss_net_profit:decimal(7,2)>

(2) FilterExecTransformer
Input [4]: [ss_store_sk#1, ss_ext_sales_price#2, ss_net_profit#3, ss_sold_date_sk#4]
Arguments: isnotnull(ss_store_sk#1)

(3) ReusedExchange [Reuses operator id: 254]
Output [1]: [d_date_sk#6]

(4) InputAdapter
Input [1]: [d_date_sk#6]

(5) InputIteratorTransformer
Input [1]: [d_date_sk#6]

(6) BroadcastHashJoinExecTransformer
Left keys [1]: [ss_sold_date_sk#4]
Right keys [1]: [d_date_sk#6]
Join type: Inner
Join condition: None

(7) ProjectExecTransformer
Output [3]: [ss_store_sk#1, ss_ext_sales_price#2, ss_net_profit#3]
Input [5]: [ss_store_sk#1, ss_ext_sales_price#2, ss_net_profit#3, ss_sold_date_sk#4, d_date_sk#6]

(8) FileSourceScanExecTransformer parquet spark_catalog.default.store
Output [1]: [s_store_sk#7]
Batched: true
Location: InMemoryFileIndex [{warehouse_dir}/store]
PushedFilters: [IsNotNull(s_store_sk)]
ReadSchema: struct<s_store_sk:int>

(9) FilterExecTransformer
Input [1]: [s_store_sk#7]
Arguments: isnotnull(s_store_sk#7)

(10) WholeStageCodegenTransformer (3)
Input [1]: [s_store_sk#7]
Arguments: false

(11) ColumnarBroadcastExchange
Input [1]: [s_store_sk#7]
Arguments: HashedRelationBroadcastMode(List(cast(input[0, int, false] as bigint)),false), [plan_id=1]

(12) InputAdapter
Input [1]: [s_store_sk#7]

(13) InputIteratorTransformer
Input [1]: [s_store_sk#7]

(14) BroadcastHashJoinExecTransformer
Left keys [1]: [ss_store_sk#1]
Right keys [1]: [s_store_sk#7]
Join type: Inner
Join condition: None

(15) ProjectExecTransformer
Output [3]: [s_store_sk#7, UnscaledValue(ss_ext_sales_price#2) AS _pre_1#8, UnscaledValue(ss_net_profit#3) AS _pre_2#9]
Input [4]: [ss_store_sk#1, ss_ext_sales_price#2, ss_net_profit#3, s_store_sk#7]

(16) FlushableHashAggregateExecTransformer
Input [3]: [s_store_sk#7, _pre_1#8, _pre_2#9]
Keys [1]: [s_store_sk#7]
Functions [2]: [partial_sum(_pre_1#8), partial_sum(_pre_2#9)]
Aggregate Attributes [2]: [sum#10, sum#11]
Results [3]: [s_store_sk#7, sum#12, sum#13]

(17) ProjectExecTransformer
Output [4]: [hash(s_store_sk#7, 42) AS hash_partition_key#14, s_store_sk#7, sum#12, sum#13]
Input [3]: [s_store_sk#7, sum#12, sum#13]

(18) WholeStageCodegenTransformer (4)
Input [4]: [hash_partition_key#14, s_store_sk#7, sum#12, sum#13]
Arguments: false

(19) VeloxResizeBatches
Input [4]: [hash_partition_key#14, s_store_sk#7, sum#12, sum#13]
Arguments: 1024, 2147483647, 10485760

(20) ColumnarExchange
Input [4]: [hash_partition_key#14, s_store_sk#7, sum#12, sum#13]
Arguments: hashpartitioning(s_store_sk#7, 1), ENSURE_REQUIREMENTS, [s_store_sk#7, sum#12, sum#13], [plan_id=2], [shuffle_writer_type=hash]

(21) InputAdapter
Input [3]: [s_store_sk#7, sum#12, sum#13]

(22) InputIteratorTransformer
Input [3]: [s_store_sk#7, sum#12, sum#13]

(23) RegularHashAggregateExecTransformer
Input [3]: [s_store_sk#7, sum#12, sum#13]
Keys [1]: [s_store_sk#7]
Functions [2]: [sum(UnscaledValue(ss_ext_sales_price#2)), sum(UnscaledValue(ss_net_profit#3))]
Aggregate Attributes [2]: [sum(UnscaledValue(ss_ext_sales_price#2))#15, sum(UnscaledValue(ss_net_profit#3))#16]
Results [3]: [s_store_sk#7, sum(UnscaledValue(ss_ext_sales_price#2))#15, sum(UnscaledValue(ss_net_profit#3))#16]

(24) ProjectExecTransformer
Output [3]: [s_store_sk#7, MakeDecimal(sum(UnscaledValue(ss_ext_sales_price#2))#15,17,2) AS sales#17, MakeDecimal(sum(UnscaledValue(ss_net_profit#3))#16,17,2) AS profit#18]
Input [3]: [s_store_sk#7, sum(UnscaledValue(ss_ext_sales_price#2))#15, sum(UnscaledValue(ss_net_profit#3))#16]

(25) FileSourceScanExecTransformer parquet spark_catalog.default.store_returns
Output [4]: [sr_store_sk#19, sr_return_amt#20, sr_net_loss#21, sr_returned_date_sk#22]
Batched: true
Location: InMemoryFileIndex []
PartitionFilters: [isnotnull(sr_returned_date_sk#22), dynamicpruningexpression(sr_returned_date_sk#22 IN dynamicpruning#5)]
PushedFilters: [IsNotNull(sr_store_sk)]
ReadSchema: struct<sr_store_sk:int,sr_return_amt:decimal(7,2),sr_net_loss:decimal(7,2)>

(26) FilterExecTransformer
Input [4]: [sr_store_sk#19, sr_return_amt#20, sr_net_loss#21, sr_returned_date_sk#22]
Arguments: isnotnull(sr_store_sk#19)

(27) ReusedExchange [Reuses operator id: 254]
Output [1]: [d_date_sk#23]

(28) InputAdapter
Input [1]: [d_date_sk#23]

(29) InputIteratorTransformer
Input [1]: [d_date_sk#23]

(30) BroadcastHashJoinExecTransformer
Left keys [1]: [sr_returned_date_sk#22]
Right keys [1]: [d_date_sk#23]
Join type: Inner
Join condition: None

(31) ProjectExecTransformer
Output [3]: [sr_store_sk#19, sr_return_amt#20, sr_net_loss#21]
Input [5]: [sr_store_sk#19, sr_return_amt#20, sr_net_loss#21, sr_returned_date_sk#22, d_date_sk#23]

(32) ReusedExchange [Reuses operator id: 11]
Output [1]: [s_store_sk#24]

(33) InputAdapter
Input [1]: [s_store_sk#24]

(34) InputIteratorTransformer
Input [1]: [s_store_sk#24]

(35) BroadcastHashJoinExecTransformer
Left keys [1]: [sr_store_sk#19]
Right keys [1]: [s_store_sk#24]
Join type: Inner
Join condition: None

(36) ProjectExecTransformer
Output [3]: [s_store_sk#24, UnscaledValue(sr_return_amt#20) AS _pre_3#25, UnscaledValue(sr_net_loss#21) AS _pre_4#26]
Input [4]: [sr_store_sk#19, sr_return_amt#20, sr_net_loss#21, s_store_sk#24]

(37) FlushableHashAggregateExecTransformer
Input [3]: [s_store_sk#24, _pre_3#25, _pre_4#26]
Keys [1]: [s_store_sk#24]
Functions [2]: [partial_sum(_pre_3#25), partial_sum(_pre_4#26)]
Aggregate Attributes [2]: [sum#27, sum#28]
Results [3]: [s_store_sk#24, sum#29, sum#30]

(38) ProjectExecTransformer
Output [4]: [hash(s_store_sk#24, 42) AS hash_partition_key#31, s_store_sk#24, sum#29, sum#30]
Input [3]: [s_store_sk#24, sum#29, sum#30]

(39) WholeStageCodegenTransformer (8)
Input [4]: [hash_partition_key#31, s_store_sk#24, sum#29, sum#30]
Arguments: false

(40) VeloxResizeBatches
Input [4]: [hash_partition_key#31, s_store_sk#24, sum#29, sum#30]
Arguments: 1024, 2147483647, 10485760

(41) ColumnarExchange
Input [4]: [hash_partition_key#31, s_store_sk#24, sum#29, sum#30]
Arguments: hashpartitioning(s_store_sk#24, 1), ENSURE_REQUIREMENTS, [s_store_sk#24, sum#29, sum#30], [plan_id=3], [shuffle_writer_type=hash]

(42) InputAdapter
Input [3]: [s_store_sk#24, sum#29, sum#30]

(43) InputIteratorTransformer
Input [3]: [s_store_sk#24, sum#29, sum#30]

(44) RegularHashAggregateExecTransformer
Input [3]: [s_store_sk#24, sum#29, sum#30]
Keys [1]: [s_store_sk#24]
Functions [2]: [sum(UnscaledValue(sr_return_amt#20)), sum(UnscaledValue(sr_net_loss#21))]
Aggregate Attributes [2]: [sum(UnscaledValue(sr_return_amt#20))#32, sum(UnscaledValue(sr_net_loss#21))#33]
Results [3]: [s_store_sk#24, sum(UnscaledValue(sr_return_amt#20))#32, sum(UnscaledValue(sr_net_loss#21))#33]

(45) ProjectExecTransformer
Output [3]: [s_store_sk#24, MakeDecimal(sum(UnscaledValue(sr_return_amt#20))#32,17,2) AS returns#34, MakeDecimal(sum(UnscaledValue(sr_net_loss#21))#33,17,2) AS profit_loss#35]
Input [3]: [s_store_sk#24, sum(UnscaledValue(sr_return_amt#20))#32, sum(UnscaledValue(sr_net_loss#21))#33]

(46) WholeStageCodegenTransformer (9)
Input [3]: [s_store_sk#24, returns#34, profit_loss#35]
Arguments: false

(47) ColumnarBroadcastExchange
Input [3]: [s_store_sk#24, returns#34, profit_loss#35]
Arguments: HashedRelationBroadcastMode(List(cast(input[0, int, true] as bigint)),false), [plan_id=4]

(48) InputAdapter
Input [3]: [s_store_sk#24, returns#34, profit_loss#35]

(49) InputIteratorTransformer
Input [3]: [s_store_sk#24, returns#34, profit_loss#35]

(50) BroadcastHashJoinExecTransformer
Left keys [1]: [s_store_sk#7]
Right keys [1]: [s_store_sk#24]
Join type: LeftOuter
Join condition: None

(51) ProjectExecTransformer
Output [5]: [store channel AS channel#36, s_store_sk#7 AS id#37, sales#17, coalesce(returns#34, 0.00) AS returns#38, (profit#18 - coalesce(profit_loss#35, 0.00)) AS profit#39]
Input [6]: [s_store_sk#7, sales#17, profit#18, s_store_sk#24, returns#34, profit_loss#35]

(52) WholeStageCodegenTransformer (10)
Input [5]: [channel#36, id#37, sales#17, returns#38, profit#39]
Arguments: false

(53) FileSourceScanExecTransformer parquet spark_catalog.default.catalog_sales
Output [4]: [cs_call_center_sk#40, cs_ext_sales_price#41, cs_net_profit#42, cs_sold_date_sk#43]
Batched: true
Location: InMemoryFileIndex []
PartitionFilters: [isnotnull(cs_sold_date_sk#43), dynamicpruningexpression(cs_sold_date_sk#43 IN dynamicpruning#5)]
ReadSchema: struct<cs_call_center_sk:int,cs_ext_sales_price:decimal(7,2),cs_net_profit:decimal(7,2)>

(54) ReusedExchange [Reuses operator id: 254]
Output [1]: [d_date_sk#44]

(55) InputAdapter
Input [1]: [d_date_sk#44]

(56) InputIteratorTransformer
Input [1]: [d_date_sk#44]

(57) BroadcastHashJoinExecTransformer
Left keys [1]: [cs_sold_date_sk#43]
Right keys [1]: [d_date_sk#44]
Join type: Inner
Join condition: None

(58) ProjectExecTransformer
Output [3]: [cs_call_center_sk#40, UnscaledValue(cs_ext_sales_price#41) AS _pre_5#45, UnscaledValue(cs_net_profit#42) AS _pre_6#46]
Input [5]: [cs_call_center_sk#40, cs_ext_sales_price#41, cs_net_profit#42, cs_sold_date_sk#43, d_date_sk#44]

(59) FlushableHashAggregateExecTransformer
Input [3]: [cs_call_center_sk#40, _pre_5#45, _pre_6#46]
Keys [1]: [cs_call_center_sk#40]
Functions [2]: [partial_sum(_pre_5#45), partial_sum(_pre_6#46)]
Aggregate Attributes [2]: [sum#47, sum#48]
Results [3]: [cs_call_center_sk#40, sum#49, sum#50]

(60) ProjectExecTransformer
Output [4]: [hash(cs_call_center_sk#40, 42) AS hash_partition_key#51, cs_call_center_sk#40, sum#49, sum#50]
Input [3]: [cs_call_center_sk#40, sum#49, sum#50]

(61) WholeStageCodegenTransformer (13)
Input [4]: [hash_partition_key#51, cs_call_center_sk#40, sum#49, sum#50]
Arguments: false

(62) VeloxResizeBatches
Input [4]: [hash_partition_key#51, cs_call_center_sk#40, sum#49, sum#50]
Arguments: 1024, 2147483647, 10485760

(63) ColumnarExchange
Input [4]: [hash_partition_key#51, cs_call_center_sk#40, sum#49, sum#50]
Arguments: hashpartitioning(cs_call_center_sk#40, 1), ENSURE_REQUIREMENTS, [cs_call_center_sk#40, sum#49, sum#50], [plan_id=5], [shuffle_writer_type=hash]

(64) InputAdapter
Input [3]: [cs_call_center_sk#40, sum#49, sum#50]

(65) InputIteratorTransformer
Input [3]: [cs_call_center_sk#40, sum#49, sum#50]

(66) RegularHashAggregateExecTransformer
Input [3]: [cs_call_center_sk#40, sum#49, sum#50]
Keys [1]: [cs_call_center_sk#40]
Functions [2]: [sum(UnscaledValue(cs_ext_sales_price#41)), sum(UnscaledValue(cs_net_profit#42))]
Aggregate Attributes [2]: [sum(UnscaledValue(cs_ext_sales_price#41))#52, sum(UnscaledValue(cs_net_profit#42))#53]
Results [3]: [cs_call_center_sk#40, sum(UnscaledValue(cs_ext_sales_price#41))#52, sum(UnscaledValue(cs_net_profit#42))#53]

(67) ProjectExecTransformer
Output [3]: [cs_call_center_sk#40, MakeDecimal(sum(UnscaledValue(cs_ext_sales_price#41))#52,17,2) AS sales#54, MakeDecimal(sum(UnscaledValue(cs_net_profit#42))#53,17,2) AS profit#55]
Input [3]: [cs_call_center_sk#40, sum(UnscaledValue(cs_ext_sales_price#41))#52, sum(UnscaledValue(cs_net_profit#42))#53]

(68) FileSourceScanExecTransformer parquet spark_catalog.default.catalog_returns
Output [3]: [cr_return_amount#56, cr_net_loss#57, cr_returned_date_sk#58]
Batched: true
Location: InMemoryFileIndex []
PartitionFilters: [isnotnull(cr_returned_date_sk#58), dynamicpruningexpression(cr_returned_date_sk#58 IN dynamicpruning#5)]
ReadSchema: struct<cr_return_amount:decimal(7,2),cr_net_loss:decimal(7,2)>

(69) ReusedExchange [Reuses operator id: 254]
Output [1]: [d_date_sk#59]

(70) InputAdapter
Input [1]: [d_date_sk#59]

(71) InputIteratorTransformer
Input [1]: [d_date_sk#59]

(72) BroadcastHashJoinExecTransformer
Left keys [1]: [cr_returned_date_sk#58]
Right keys [1]: [d_date_sk#59]
Join type: Inner
Join condition: None

(73) ProjectExecTransformer
Output [2]: [UnscaledValue(cr_return_amount#56) AS _pre_7#60, UnscaledValue(cr_net_loss#57) AS _pre_8#61]
Input [4]: [cr_return_amount#56, cr_net_loss#57, cr_returned_date_sk#58, d_date_sk#59]

(74) FlushableHashAggregateExecTransformer
Input [2]: [_pre_7#60, _pre_8#61]
Keys: []
Functions [2]: [partial_sum(_pre_7#60), partial_sum(_pre_8#61)]
Aggregate Attributes [2]: [sum#62, sum#63]
Results [2]: [sum#64, sum#65]

(75) WholeStageCodegenTransformer (16)
Input [2]: [sum#64, sum#65]
Arguments: false

(76) VeloxResizeBatches
Input [2]: [sum#64, sum#65]
Arguments: 1024, 2147483647, 10485760

(77) ColumnarExchange
Input [2]: [sum#64, sum#65]
Arguments: SinglePartition, ENSURE_REQUIREMENTS, [plan_id=6], [shuffle_writer_type=hash]

(78) InputAdapter
Input [2]: [sum#64, sum#65]

(79) InputIteratorTransformer
Input [2]: [sum#64, sum#65]

(80) RegularHashAggregateExecTransformer
Input [2]: [sum#64, sum#65]
Keys: []
Functions [2]: [sum(UnscaledValue(cr_return_amount#56)), sum(UnscaledValue(cr_net_loss#57))]
Aggregate Attributes [2]: [sum(UnscaledValue(cr_return_amount#56))#66, sum(UnscaledValue(cr_net_loss#57))#67]
Results [2]: [sum(UnscaledValue(cr_return_amount#56))#66, sum(UnscaledValue(cr_net_loss#57))#67]

(81) ProjectExecTransformer
Output [2]: [MakeDecimal(sum(UnscaledValue(cr_return_amount#56))#66,17,2) AS returns#68, MakeDecimal(sum(UnscaledValue(cr_net_loss#57))#67,17,2) AS profit_loss#69]
Input [2]: [sum(UnscaledValue(cr_return_amount#56))#66, sum(UnscaledValue(cr_net_loss#57))#67]

(82) WholeStageCodegenTransformer (17)
Input [2]: [returns#68, profit_loss#69]
Arguments: false

(83) ColumnarBroadcastExchange
Input [2]: [returns#68, profit_loss#69]
Arguments: IdentityBroadcastMode, [plan_id=7]

(84) InputAdapter
Input [2]: [returns#68, profit_loss#69]

(85) InputIteratorTransformer
Input [2]: [returns#68, profit_loss#69]

(86) VeloxBroadcastNestedLoopJoinExecTransformer
Join type: Inner
Join condition: None

(87) ProjectExecTransformer
Output [5]: [catalog channel AS channel#70, cs_call_center_sk#40 AS id#71, sales#54, returns#68, (profit#55 - profit_loss#69) AS profit#72]
Input [5]: [cs_call_center_sk#40, sales#54, profit#55, returns#68, profit_loss#69]

(88) WholeStageCodegenTransformer (18)
Input [5]: [channel#70, id#71, sales#54, returns#68, profit#72]
Arguments: false

(89) FileSourceScanExecTransformer parquet spark_catalog.default.web_sales
Output [4]: [ws_web_page_sk#73, ws_ext_sales_price#74, ws_net_profit#75, ws_sold_date_sk#76]
Batched: true
Location: InMemoryFileIndex []
PartitionFilters: [isnotnull(ws_sold_date_sk#76), dynamicpruningexpression(ws_sold_date_sk#76 IN dynamicpruning#5)]
PushedFilters: [IsNotNull(ws_web_page_sk)]
ReadSchema: struct<ws_web_page_sk:int,ws_ext_sales_price:decimal(7,2),ws_net_profit:decimal(7,2)>

(90) FilterExecTransformer
Input [4]: [ws_web_page_sk#73, ws_ext_sales_price#74, ws_net_profit#75, ws_sold_date_sk#76]
Arguments: isnotnull(ws_web_page_sk#73)

(91) ReusedExchange [Reuses operator id: 254]
Output [1]: [d_date_sk#77]

(92) InputAdapter
Input [1]: [d_date_sk#77]

(93) InputIteratorTransformer
Input [1]: [d_date_sk#77]

(94) BroadcastHashJoinExecTransformer
Left keys [1]: [ws_sold_date_sk#76]
Right keys [1]: [d_date_sk#77]
Join type: Inner
Join condition: None

(95) ProjectExecTransformer
Output [3]: [ws_web_page_sk#73, ws_ext_sales_price#74, ws_net_profit#75]
Input [5]: [ws_web_page_sk#73, ws_ext_sales_price#74, ws_net_profit#75, ws_sold_date_sk#76, d_date_sk#77]

(96) FileSourceScanExecTransformer parquet spark_catalog.default.web_page
Output [1]: [wp_web_page_sk#78]
Batched: true
Location: InMemoryFileIndex [{warehouse_dir}/web_page]
PushedFilters: [IsNotNull(wp_web_page_sk)]
ReadSchema: struct<wp_web_page_sk:int>

(97) FilterExecTransformer
Input [1]: [wp_web_page_sk#78]
Arguments: isnotnull(wp_web_page_sk#78)

(98) WholeStageCodegenTransformer (21)
Input [1]: [wp_web_page_sk#78]
Arguments: false

(99) ColumnarBroadcastExchange
Input [1]: [wp_web_page_sk#78]
Arguments: HashedRelationBroadcastMode(List(cast(input[0, int, false] as bigint)),false), [plan_id=8]

(100) InputAdapter
Input [1]: [wp_web_page_sk#78]

(101) InputIteratorTransformer
Input [1]: [wp_web_page_sk#78]

(102) BroadcastHashJoinExecTransformer
Left keys [1]: [ws_web_page_sk#73]
Right keys [1]: [wp_web_page_sk#78]
Join type: Inner
Join condition: None

(103) ProjectExecTransformer
Output [3]: [wp_web_page_sk#78, UnscaledValue(ws_ext_sales_price#74) AS _pre_9#79, UnscaledValue(ws_net_profit#75) AS _pre_10#80]
Input [4]: [ws_web_page_sk#73, ws_ext_sales_price#74, ws_net_profit#75, wp_web_page_sk#78]

(104) FlushableHashAggregateExecTransformer
Input [3]: [wp_web_page_sk#78, _pre_9#79, _pre_10#80]
Keys [1]: [wp_web_page_sk#78]
Functions [2]: [partial_sum(_pre_9#79), partial_sum(_pre_10#80)]
Aggregate Attributes [2]: [sum#81, sum#82]
Results [3]: [wp_web_page_sk#78, sum#83, sum#84]

(105) ProjectExecTransformer
Output [4]: [hash(wp_web_page_sk#78, 42) AS hash_partition_key#85, wp_web_page_sk#78, sum#83, sum#84]
Input [3]: [wp_web_page_sk#78, sum#83, sum#84]

(106) WholeStageCodegenTransformer (22)
Input [4]: [hash_partition_key#85, wp_web_page_sk#78, sum#83, sum#84]
Arguments: false

(107) VeloxResizeBatches
Input [4]: [hash_partition_key#85, wp_web_page_sk#78, sum#83, sum#84]
Arguments: 1024, 2147483647, 10485760

(108) ColumnarExchange
Input [4]: [hash_partition_key#85, wp_web_page_sk#78, sum#83, sum#84]
Arguments: hashpartitioning(wp_web_page_sk#78, 1), ENSURE_REQUIREMENTS, [wp_web_page_sk#78, sum#83, sum#84], [plan_id=9], [shuffle_writer_type=hash]

(109) InputAdapter
Input [3]: [wp_web_page_sk#78, sum#83, sum#84]

(110) InputIteratorTransformer
Input [3]: [wp_web_page_sk#78, sum#83, sum#84]

(111) RegularHashAggregateExecTransformer
Input [3]: [wp_web_page_sk#78, sum#83, sum#84]
Keys [1]: [wp_web_page_sk#78]
Functions [2]: [sum(UnscaledValue(ws_ext_sales_price#74)), sum(UnscaledValue(ws_net_profit#75))]
Aggregate Attributes [2]: [sum(UnscaledValue(ws_ext_sales_price#74))#86, sum(UnscaledValue(ws_net_profit#75))#87]
Results [3]: [wp_web_page_sk#78, sum(UnscaledValue(ws_ext_sales_price#74))#86, sum(UnscaledValue(ws_net_profit#75))#87]

(112) ProjectExecTransformer
Output [3]: [wp_web_page_sk#78, MakeDecimal(sum(UnscaledValue(ws_ext_sales_price#74))#86,17,2) AS sales#88, MakeDecimal(sum(UnscaledValue(ws_net_profit#75))#87,17,2) AS profit#89]
Input [3]: [wp_web_page_sk#78, sum(UnscaledValue(ws_ext_sales_price#74))#86, sum(UnscaledValue(ws_net_profit#75))#87]

(113) FileSourceScanExecTransformer parquet spark_catalog.default.web_returns
Output [4]: [wr_web_page_sk#90, wr_return_amt#91, wr_net_loss#92, wr_returned_date_sk#93]
Batched: true
Location: InMemoryFileIndex []
PartitionFilters: [isnotnull(wr_returned_date_sk#93), dynamicpruningexpression(wr_returned_date_sk#93 IN dynamicpruning#5)]
PushedFilters: [IsNotNull(wr_web_page_sk)]
ReadSchema: struct<wr_web_page_sk:int,wr_return_amt:decimal(7,2),wr_net_loss:decimal(7,2)>

(114) FilterExecTransformer
Input [4]: [wr_web_page_sk#90, wr_return_amt#91, wr_net_loss#92, wr_returned_date_sk#93]
Arguments: isnotnull(wr_web_page_sk#90)

(115) ReusedExchange [Reuses operator id: 254]
Output [1]: [d_date_sk#94]

(116) InputAdapter
Input [1]: [d_date_sk#94]

(117) InputIteratorTransformer
Input [1]: [d_date_sk#94]

(118) BroadcastHashJoinExecTransformer
Left keys [1]: [wr_returned_date_sk#93]
Right keys [1]: [d_date_sk#94]
Join type: Inner
Join condition: None

(119) ProjectExecTransformer
Output [3]: [wr_web_page_sk#90, wr_return_amt#91, wr_net_loss#92]
Input [5]: [wr_web_page_sk#90, wr_return_amt#91, wr_net_loss#92, wr_returned_date_sk#93, d_date_sk#94]

(120) ReusedExchange [Reuses operator id: 99]
Output [1]: [wp_web_page_sk#95]

(121) InputAdapter
Input [1]: [wp_web_page_sk#95]

(122) InputIteratorTransformer
Input [1]: [wp_web_page_sk#95]

(123) BroadcastHashJoinExecTransformer
Left keys [1]: [wr_web_page_sk#90]
Right keys [1]: [wp_web_page_sk#95]
Join type: Inner
Join condition: None

(124) ProjectExecTransformer
Output [3]: [wp_web_page_sk#95, UnscaledValue(wr_return_amt#91) AS _pre_11#96, UnscaledValue(wr_net_loss#92) AS _pre_12#97]
Input [4]: [wr_web_page_sk#90, wr_return_amt#91, wr_net_loss#92, wp_web_page_sk#95]

(125) FlushableHashAggregateExecTransformer
Input [3]: [wp_web_page_sk#95, _pre_11#96, _pre_12#97]
Keys [1]: [wp_web_page_sk#95]
Functions [2]: [partial_sum(_pre_11#96), partial_sum(_pre_12#97)]
Aggregate Attributes [2]: [sum#98, sum#99]
Results [3]: [wp_web_page_sk#95, sum#100, sum#101]

(126) ProjectExecTransformer
Output [4]: [hash(wp_web_page_sk#95, 42) AS hash_partition_key#102, wp_web_page_sk#95, sum#100, sum#101]
Input [3]: [wp_web_page_sk#95, sum#100, sum#101]

(127) WholeStageCodegenTransformer (26)
Input [4]: [hash_partition_key#102, wp_web_page_sk#95, sum#100, sum#101]
Arguments: false

(128) VeloxResizeBatches
Input [4]: [hash_partition_key#102, wp_web_page_sk#95, sum#100, sum#101]
Arguments: 1024, 2147483647, 10485760

(129) ColumnarExchange
Input [4]: [hash_partition_key#102, wp_web_page_sk#95, sum#100, sum#101]
Arguments: hashpartitioning(wp_web_page_sk#95, 1), ENSURE_REQUIREMENTS, [wp_web_page_sk#95, sum#100, sum#101], [plan_id=10], [shuffle_writer_type=hash]

(130) InputAdapter
Input [3]: [wp_web_page_sk#95, sum#100, sum#101]

(131) InputIteratorTransformer
Input [3]: [wp_web_page_sk#95, sum#100, sum#101]

(132) RegularHashAggregateExecTransformer
Input [3]: [wp_web_page_sk#95, sum#100, sum#101]
Keys [1]: [wp_web_page_sk#95]
Functions [2]: [sum(UnscaledValue(wr_return_amt#91)), sum(UnscaledValue(wr_net_loss#92))]
Aggregate Attributes [2]: [sum(UnscaledValue(wr_return_amt#91))#103, sum(UnscaledValue(wr_net_loss#92))#104]
Results [3]: [wp_web_page_sk#95, sum(UnscaledValue(wr_return_amt#91))#103, sum(UnscaledValue(wr_net_loss#92))#104]

(133) ProjectExecTransformer
Output [3]: [wp_web_page_sk#95, MakeDecimal(sum(UnscaledValue(wr_return_amt#91))#103,17,2) AS returns#105, MakeDecimal(sum(UnscaledValue(wr_net_loss#92))#104,17,2) AS profit_loss#106]
Input [3]: [wp_web_page_sk#95, sum(UnscaledValue(wr_return_amt#91))#103, sum(UnscaledValue(wr_net_loss#92))#104]

(134) WholeStageCodegenTransformer (27)
Input [3]: [wp_web_page_sk#95, returns#105, profit_loss#106]
Arguments: false

(135) ColumnarBroadcastExchange
Input [3]: [wp_web_page_sk#95, returns#105, profit_loss#106]
Arguments: HashedRelationBroadcastMode(List(cast(input[0, int, true] as bigint)),false), [plan_id=11]

(136) InputAdapter
Input [3]: [wp_web_page_sk#95, returns#105, profit_loss#106]

(137) InputIteratorTransformer
Input [3]: [wp_web_page_sk#95, returns#105, profit_loss#106]

(138) BroadcastHashJoinExecTransformer
Left keys [1]: [wp_web_page_sk#78]
Right keys [1]: [wp_web_page_sk#95]
Join type: LeftOuter
Join condition: None

(139) ProjectExecTransformer
Output [5]: [web channel AS channel#107, wp_web_page_sk#78 AS id#108, sales#88, coalesce(returns#105, 0.00) AS returns#109, (profit#89 - coalesce(profit_loss#106, 0.00)) AS profit#110]
Input [6]: [wp_web_page_sk#78, sales#88, profit#89, wp_web_page_sk#95, returns#105, profit_loss#106]

(140) WholeStageCodegenTransformer (28)
Input [5]: [channel#107, id#108, sales#88, returns#109, profit#110]
Arguments: false

(141) ColumnarUnion
Arguments: hashpartitioning(id#37, 1)

(142) InputAdapter
Input [5]: [channel#36, id#37, sales#17, returns#38, profit#39]

(143) InputIteratorTransformer
Input [5]: [channel#36, id#37, sales#17, returns#38, profit#39]

(144) RegularHashAggregateExecTransformer
Input [5]: [channel#36, id#37, sales#17, returns#38, profit#39]
Keys [2]: [channel#36, id#37]
Functions [3]: [sum(sales#17), sum(returns#38), sum(profit#39)]
Aggregate Attributes [3]: [sum(sales#17)#111, sum(returns#38)#112, sum(profit#39)#113]
Results [5]: [channel#36, id#37, sum(sales#17)#111, sum(returns#38)#112, sum(profit#39)#113]

(145) ProjectExecTransformer
Output [5]: [channel#36, id#37, cast(sum(sales#17)#111 as decimal(37,2)) AS sales#114, cast(sum(returns#38)#112 as decimal(37,2)) AS returns#115, cast(sum(profit#39)#113 as decimal(38,2)) AS profit#116]
Input [5]: [channel#36, id#37, sum(sales#17)#111, sum(returns#38)#112, sum(profit#39)#113]

(146) WholeStageCodegenTransformer (29)
Input [5]: [channel#36, id#37, sales#114, returns#115, profit#116]
Arguments: false

(147) ReusedExchange [Reuses operator id: 20]
Output [3]: [s_store_sk#117, sum#118, sum#119]

(148) InputAdapter
Input [3]: [s_store_sk#117, sum#118, sum#119]

(149) InputIteratorTransformer
Input [3]: [s_store_sk#117, sum#118, sum#119]

(150) RegularHashAggregateExecTransformer
Input [3]: [s_store_sk#117, sum#118, sum#119]
Keys [1]: [s_store_sk#117]
Functions [2]: [sum(UnscaledValue(ss_ext_sales_price#120)), sum(UnscaledValue(ss_net_profit#121))]
Aggregate Attributes [2]: [sum(UnscaledValue(ss_ext_sales_price#120))#15, sum(UnscaledValue(ss_net_profit#121))#16]
Results [3]: [s_store_sk#117, sum(UnscaledValue(ss_ext_sales_price#120))#15, sum(UnscaledValue(ss_net_profit#121))#16]

(151) ProjectExecTransformer
Output [3]: [s_store_sk#117, MakeDecimal(sum(UnscaledValue(ss_ext_sales_price#120))#15,17,2) AS sales#122, MakeDecimal(sum(UnscaledValue(ss_net_profit#121))#16,17,2) AS profit#123]
Input [3]: [s_store_sk#117, sum(UnscaledValue(ss_ext_sales_price#120))#15, sum(UnscaledValue(ss_net_profit#121))#16]

(152) ReusedExchange [Reuses operator id: 47]
Output [3]: [s_store_sk#124, returns#125, profit_loss#126]

(153) InputAdapter
Input [3]: [s_store_sk#124, returns#125, profit_loss#126]

(154) InputIteratorTransformer
Input [3]: [s_store_sk#124, returns#125, profit_loss#126]

(155) BroadcastHashJoinExecTransformer
Left keys [1]: [s_store_sk#117]
Right keys [1]: [s_store_sk#124]
Join type: LeftOuter
Join condition: None

(156) ProjectExecTransformer
Output [5]: [store channel AS channel#127, s_store_sk#117 AS id#128, sales#122, coalesce(returns#125, 0.00) AS returns#129, (profit#123 - coalesce(profit_loss#126, 0.00)) AS profit#130]
Input [6]: [s_store_sk#117, sales#122, profit#123, s_store_sk#124, returns#125, profit_loss#126]

(157) WholeStageCodegenTransformer (39)
Input [5]: [channel#127, id#128, sales#122, returns#129, profit#130]
Arguments: false

(158) ReusedExchange [Reuses operator id: 63]
Output [3]: [cs_call_center_sk#131, sum#132, sum#133]

(159) InputAdapter
Input [3]: [cs_call_center_sk#131, sum#132, sum#133]

(160) InputIteratorTransformer
Input [3]: [cs_call_center_sk#131, sum#132, sum#133]

(161) RegularHashAggregateExecTransformer
Input [3]: [cs_call_center_sk#131, sum#132, sum#133]
Keys [1]: [cs_call_center_sk#131]
Functions [2]: [sum(UnscaledValue(cs_ext_sales_price#134)), sum(UnscaledValue(cs_net_profit#135))]
Aggregate Attributes [2]: [sum(UnscaledValue(cs_ext_sales_price#134))#52, sum(UnscaledValue(cs_net_profit#135))#53]
Results [3]: [cs_call_center_sk#131, sum(UnscaledValue(cs_ext_sales_price#134))#52, sum(UnscaledValue(cs_net_profit#135))#53]

(162) ProjectExecTransformer
Output [3]: [cs_call_center_sk#131, MakeDecimal(sum(UnscaledValue(cs_ext_sales_price#134))#52,17,2) AS sales#136, MakeDecimal(sum(UnscaledValue(cs_net_profit#135))#53,17,2) AS profit#137]
Input [3]: [cs_call_center_sk#131, sum(UnscaledValue(cs_ext_sales_price#134))#52, sum(UnscaledValue(cs_net_profit#135))#53]

(163) ReusedExchange [Reuses operator id: 83]
Output [2]: [returns#138, profit_loss#139]

(164) InputAdapter
Input [2]: [returns#138, profit_loss#139]

(165) InputIteratorTransformer
Input [2]: [returns#138, profit_loss#139]

(166) VeloxBroadcastNestedLoopJoinExecTransformer
Join type: Inner
Join condition: None

(167) ProjectExecTransformer
Output [5]: [catalog channel AS channel#140, cs_call_center_sk#131 AS id#141, sales#136, returns#138, (profit#137 - profit_loss#139) AS profit#142]
Input [5]: [cs_call_center_sk#131, sales#136, profit#137, returns#138, profit_loss#139]

(168) WholeStageCodegenTransformer (47)
Input [5]: [channel#140, id#141, sales#136, returns#138, profit#142]
Arguments: false

(169) ReusedExchange [Reuses operator id: 108]
Output [3]: [wp_web_page_sk#143, sum#144, sum#145]

(170) InputAdapter
Input [3]: [wp_web_page_sk#143, sum#144, sum#145]

(171) InputIteratorTransformer
Input [3]: [wp_web_page_sk#143, sum#144, sum#145]

(172) RegularHashAggregateExecTransformer
Input [3]: [wp_web_page_sk#143, sum#144, sum#145]
Keys [1]: [wp_web_page_sk#143]
Functions [2]: [sum(UnscaledValue(ws_ext_sales_price#146)), sum(UnscaledValue(ws_net_profit#147))]
Aggregate Attributes [2]: [sum(UnscaledValue(ws_ext_sales_price#146))#86, sum(UnscaledValue(ws_net_profit#147))#87]
Results [3]: [wp_web_page_sk#143, sum(UnscaledValue(ws_ext_sales_price#146))#86, sum(UnscaledValue(ws_net_profit#147))#87]

(173) ProjectExecTransformer
Output [3]: [wp_web_page_sk#143, MakeDecimal(sum(UnscaledValue(ws_ext_sales_price#146))#86,17,2) AS sales#148, MakeDecimal(sum(UnscaledValue(ws_net_profit#147))#87,17,2) AS profit#149]
Input [3]: [wp_web_page_sk#143, sum(UnscaledValue(ws_ext_sales_price#146))#86, sum(UnscaledValue(ws_net_profit#147))#87]

(174) ReusedExchange [Reuses operator id: 135]
Output [3]: [wp_web_page_sk#150, returns#151, profit_loss#152]

(175) InputAdapter
Input [3]: [wp_web_page_sk#150, returns#151, profit_loss#152]

(176) InputIteratorTransformer
Input [3]: [wp_web_page_sk#150, returns#151, profit_loss#152]

(177) BroadcastHashJoinExecTransformer
Left keys [1]: [wp_web_page_sk#143]
Right keys [1]: [wp_web_page_sk#150]
Join type: LeftOuter
Join condition: None

(178) ProjectExecTransformer
Output [5]: [web channel AS channel#153, wp_web_page_sk#143 AS id#154, sales#148, coalesce(returns#151, 0.00) AS returns#155, (profit#149 - coalesce(profit_loss#152, 0.00)) AS profit#156]
Input [6]: [wp_web_page_sk#143, sales#148, profit#149, wp_web_page_sk#150, returns#151, profit_loss#152]

(179) WholeStageCodegenTransformer (57)
Input [5]: [channel#153, id#154, sales#148, returns#155, profit#156]
Arguments: false

(180) ColumnarUnion
Arguments: hashpartitioning(id#128, 1)

(181) InputAdapter
Input [5]: [channel#127, id#128, sales#122, returns#129, profit#130]

(182) InputIteratorTransformer
Input [5]: [channel#127, id#128, sales#122, returns#129, profit#130]

(183) RegularHashAggregateExecTransformer
Input [5]: [channel#127, id#128, sales#122, returns#129, profit#130]
Keys [2]: [channel#127, id#128]
Functions [3]: [sum(sales#122), sum(returns#129), sum(profit#130)]
Aggregate Attributes [3]: [sum(sales#122)#111, sum(returns#129)#112, sum(profit#130)#113]
Results [5]: [channel#127, id#128, sum(sales#122)#111, sum(returns#129)#112, sum(profit#130)#113]

(184) ProjectExecTransformer
Output [4]: [channel#127, sum(sales#122)#111 AS sales#157, sum(returns#129)#112 AS returns#158, sum(profit#130)#113 AS profit#159]
Input [5]: [channel#127, id#128, sum(sales#122)#111, sum(returns#129)#112, sum(profit#130)#113]

(185) FlushableHashAggregateExecTransformer
Input [4]: [channel#127, sales#157, returns#158, profit#159]
Keys [1]: [channel#127]
Functions [3]: [partial_sum(sales#157), partial_sum(returns#158), partial_sum(profit#159)]
Aggregate Attributes [6]: [sum#160, isEmpty#161, sum#162, isEmpty#163, sum#164, isEmpty#165]
Results [7]: [channel#127, sum#166, isEmpty#167, sum#168, isEmpty#169, sum#170, isEmpty#171]

(186) ProjectExecTransformer
Output [8]: [hash(channel#127, 42) AS hash_partition_key#172, channel#127, sum#166, isEmpty#167, sum#168, isEmpty#169, sum#170, isEmpty#171]
Input [7]: [channel#127, sum#166, isEmpty#167, sum#168, isEmpty#169, sum#170, isEmpty#171]

(187) WholeStageCodegenTransformer (58)
Input [8]: [hash_partition_key#172, channel#127, sum#166, isEmpty#167, sum#168, isEmpty#169, sum#170, isEmpty#171]
Arguments: false

(188) VeloxResizeBatches
Input [8]: [hash_partition_key#172, channel#127, sum#166, isEmpty#167, sum#168, isEmpty#169, sum#170, isEmpty#171]
Arguments: 1024, 2147483647, 10485760

(189) ColumnarExchange
Input [8]: [hash_partition_key#172, channel#127, sum#166, isEmpty#167, sum#168, isEmpty#169, sum#170, isEmpty#171]
Arguments: hashpartitioning(channel#127, 1), ENSURE_REQUIREMENTS, [channel#127, sum#166, isEmpty#167, sum#168, isEmpty#169, sum#170, isEmpty#171], [plan_id=12], [shuffle_writer_type=hash]

(190) InputAdapter
Input [7]: [channel#127, sum#166, isEmpty#167, sum#168, isEmpty#169, sum#170, isEmpty#171]

(191) InputIteratorTransformer
Input [7]: [channel#127, sum#166, isEmpty#167, sum#168, isEmpty#169, sum#170, isEmpty#171]

(192) RegularHashAggregateExecTransformer
Input [7]: [channel#127, sum#166, isEmpty#167, sum#168, isEmpty#169, sum#170, isEmpty#171]
Keys [1]: [channel#127]
Functions [3]: [sum(sales#157), sum(returns#158), sum(profit#159)]
Aggregate Attributes [3]: [sum(sales#157)#173, sum(returns#158)#174, sum(profit#159)#175]
Results [4]: [channel#127, sum(sales#157)#173, sum(returns#158)#174, sum(profit#159)#175]

(193) ProjectExecTransformer
Output [5]: [channel#127, null AS id#176, sum(sales#157)#173 AS sales#177, sum(returns#158)#174 AS returns#178, sum(profit#159)#175 AS profit#179]
Input [4]: [channel#127, sum(sales#157)#173, sum(returns#158)#174, sum(profit#159)#175]

(194) WholeStageCodegenTransformer (59)
Input [5]: [channel#127, id#176, sales#177, returns#178, profit#179]
Arguments: false

(195) ReusedExchange [Reuses operator id: 20]
Output [3]: [s_store_sk#180, sum#181, sum#182]

(196) InputAdapter
Input [3]: [s_store_sk#180, sum#181, sum#182]

(197) InputIteratorTransformer
Input [3]: [s_store_sk#180, sum#181, sum#182]

(198) RegularHashAggregateExecTransformer
Input [3]: [s_store_sk#180, sum#181, sum#182]
Keys [1]: [s_store_sk#180]
Functions [2]: [sum(UnscaledValue(ss_ext_sales_price#183)), sum(UnscaledValue(ss_net_profit#184))]
Aggregate Attributes [2]: [sum(UnscaledValue(ss_ext_sales_price#183))#15, sum(UnscaledValue(ss_net_profit#184))#16]
Results [3]: [s_store_sk#180, sum(UnscaledValue(ss_ext_sales_price#183))#15, sum(UnscaledValue(ss_net_profit#184))#16]

(199) ProjectExecTransformer
Output [3]: [s_store_sk#180, MakeDecimal(sum(UnscaledValue(ss_ext_sales_price#183))#15,17,2) AS sales#185, MakeDecimal(sum(UnscaledValue(ss_net_profit#184))#16,17,2) AS profit#186]
Input [3]: [s_store_sk#180, sum(UnscaledValue(ss_ext_sales_price#183))#15, sum(UnscaledValue(ss_net_profit#184))#16]

(200) ReusedExchange [Reuses operator id: 47]
Output [3]: [s_store_sk#187, returns#188, profit_loss#189]

(201) InputAdapter
Input [3]: [s_store_sk#187, returns#188, profit_loss#189]

(202) InputIteratorTransformer
Input [3]: [s_store_sk#187, returns#188, profit_loss#189]

(203) BroadcastHashJoinExecTransformer
Left keys [1]: [s_store_sk#180]
Right keys [1]: [s_store_sk#187]
Join type: LeftOuter
Join condition: None

(204) ProjectExecTransformer
Output [5]: [store channel AS channel#190, s_store_sk#180 AS id#191, sales#185, coalesce(returns#188, 0.00) AS returns#192, (profit#186 - coalesce(profit_loss#189, 0.00)) AS profit#193]
Input [6]: [s_store_sk#180, sales#185, profit#186, s_store_sk#187, returns#188, profit_loss#189]

(205) WholeStageCodegenTransformer (69)
Input [5]: [channel#190, id#191, sales#185, returns#192, profit#193]
Arguments: false

(206) ReusedExchange [Reuses operator id: 63]
Output [3]: [cs_call_center_sk#194, sum#195, sum#196]

(207) InputAdapter
Input [3]: [cs_call_center_sk#194, sum#195, sum#196]

(208) InputIteratorTransformer
Input [3]: [cs_call_center_sk#194, sum#195, sum#196]

(209) RegularHashAggregateExecTransformer
Input [3]: [cs_call_center_sk#194, sum#195, sum#196]
Keys [1]: [cs_call_center_sk#194]
Functions [2]: [sum(UnscaledValue(cs_ext_sales_price#197)), sum(UnscaledValue(cs_net_profit#198))]
Aggregate Attributes [2]: [sum(UnscaledValue(cs_ext_sales_price#197))#52, sum(UnscaledValue(cs_net_profit#198))#53]
Results [3]: [cs_call_center_sk#194, sum(UnscaledValue(cs_ext_sales_price#197))#52, sum(UnscaledValue(cs_net_profit#198))#53]

(210) ProjectExecTransformer
Output [3]: [cs_call_center_sk#194, MakeDecimal(sum(UnscaledValue(cs_ext_sales_price#197))#52,17,2) AS sales#199, MakeDecimal(sum(UnscaledValue(cs_net_profit#198))#53,17,2) AS profit#200]
Input [3]: [cs_call_center_sk#194, sum(UnscaledValue(cs_ext_sales_price#197))#52, sum(UnscaledValue(cs_net_profit#198))#53]

(211) ReusedExchange [Reuses operator id: 83]
Output [2]: [returns#201, profit_loss#202]

(212) InputAdapter
Input [2]: [returns#201, profit_loss#202]

(213) InputIteratorTransformer
Input [2]: [returns#201, profit_loss#202]

(214) VeloxBroadcastNestedLoopJoinExecTransformer
Join type: Inner
Join condition: None

(215) ProjectExecTransformer
Output [5]: [catalog channel AS channel#203, cs_call_center_sk#194 AS id#204, sales#199, returns#201, (profit#200 - profit_loss#202) AS profit#205]
Input [5]: [cs_call_center_sk#194, sales#199, profit#200, returns#201, profit_loss#202]

(216) WholeStageCodegenTransformer (77)
Input [5]: [channel#203, id#204, sales#199, returns#201, profit#205]
Arguments: false

(217) ReusedExchange [Reuses operator id: 108]
Output [3]: [wp_web_page_sk#206, sum#207, sum#208]

(218) InputAdapter
Input [3]: [wp_web_page_sk#206, sum#207, sum#208]

(219) InputIteratorTransformer
Input [3]: [wp_web_page_sk#206, sum#207, sum#208]

(220) RegularHashAggregateExecTransformer
Input [3]: [wp_web_page_sk#206, sum#207, sum#208]
Keys [1]: [wp_web_page_sk#206]
Functions [2]: [sum(UnscaledValue(ws_ext_sales_price#209)), sum(UnscaledValue(ws_net_profit#210))]
Aggregate Attributes [2]: [sum(UnscaledValue(ws_ext_sales_price#209))#86, sum(UnscaledValue(ws_net_profit#210))#87]
Results [3]: [wp_web_page_sk#206, sum(UnscaledValue(ws_ext_sales_price#209))#86, sum(UnscaledValue(ws_net_profit#210))#87]

(221) ProjectExecTransformer
Output [3]: [wp_web_page_sk#206, MakeDecimal(sum(UnscaledValue(ws_ext_sales_price#209))#86,17,2) AS sales#211, MakeDecimal(sum(UnscaledValue(ws_net_profit#210))#87,17,2) AS profit#212]
Input [3]: [wp_web_page_sk#206, sum(UnscaledValue(ws_ext_sales_price#209))#86, sum(UnscaledValue(ws_net_profit#210))#87]

(222) ReusedExchange [Reuses operator id: 135]
Output [3]: [wp_web_page_sk#213, returns#214, profit_loss#215]

(223) InputAdapter
Input [3]: [wp_web_page_sk#213, returns#214, profit_loss#215]

(224) InputIteratorTransformer
Input [3]: [wp_web_page_sk#213, returns#214, profit_loss#215]

(225) BroadcastHashJoinExecTransformer
Left keys [1]: [wp_web_page_sk#206]
Right keys [1]: [wp_web_page_sk#213]
Join type: LeftOuter
Join condition: None

(226) ProjectExecTransformer
Output [5]: [web channel AS channel#216, wp_web_page_sk#206 AS id#217, sales#211, coalesce(returns#214, 0.00) AS returns#218, (profit#212 - coalesce(profit_loss#215, 0.00)) AS profit#219]
Input [6]: [wp_web_page_sk#206, sales#211, profit#212, wp_web_page_sk#213, returns#214, profit_loss#215]

(227) WholeStageCodegenTransformer (87)
Input [5]: [channel#216, id#217, sales#211, returns#218, profit#219]
Arguments: false

(228) ColumnarUnion
Arguments: hashpartitioning(id#191, 1)

(229) InputAdapter
Input [5]: [channel#190, id#191, sales#185, returns#192, profit#193]

(230) InputIteratorTransformer
Input [5]: [channel#190, id#191, sales#185, returns#192, profit#193]

(231) RegularHashAggregateExecTransformer
Input [5]: [channel#190, id#191, sales#185, returns#192, profit#193]
Keys [2]: [channel#190, id#191]
Functions [3]: [sum(sales#185), sum(returns#192), sum(profit#193)]
Aggregate Attributes [3]: [sum(sales#185)#111, sum(returns#192)#112, sum(profit#193)#113]
Results [5]: [channel#190, id#191, sum(sales#185)#111, sum(returns#192)#112, sum(profit#193)#113]

(232) ProjectExecTransformer
Output [3]: [sum(sales#185)#111 AS sales#220, sum(returns#192)#112 AS returns#221, sum(profit#193)#113 AS profit#222]
Input [5]: [channel#190, id#191, sum(sales#185)#111, sum(returns#192)#112, sum(profit#193)#113]

(233) RegularHashAggregateExecTransformer
Input [3]: [sales#220, returns#221, profit#222]
Keys: []
Functions [3]: [sum(sales#220), sum(returns#221), sum(profit#222)]
Aggregate Attributes [3]: [sum(sales#220)#223, sum(returns#221)#224, sum(profit#222)#225]
Results [3]: [sum(sales#220)#223, sum(returns#221)#224, sum(profit#222)#225]

(234) ProjectExecTransformer
Output [5]: [null AS channel#226, null AS id#227, sum(sales#220)#223 AS sales#228, sum(returns#221)#224 AS returns#229, sum(profit#222)#225 AS profit#230]
Input [3]: [sum(sales#220)#223, sum(returns#221)#224, sum(profit#222)#225]

(235) WholeStageCodegenTransformer (88)
Input [5]: [channel#226, id#227, sales#228, returns#229, profit#230]
Arguments: false

(236) ColumnarUnion
Arguments: UnknownPartitioning(0)

(237) InputAdapter
Input [5]: [channel#36, id#37, sales#114, returns#115, profit#116]

(238) InputIteratorTransformer
Input [5]: [channel#36, id#37, sales#114, returns#115, profit#116]

(239) FlushableHashAggregateExecTransformer
Input [5]: [channel#36, id#37, sales#114, returns#115, profit#116]
Keys [5]: [channel#36, id#37, sales#114, returns#115, profit#116]
Functions: []
Aggregate Attributes: []
Results [5]: [channel#36, id#37, sales#114, returns#115, profit#116]

(240) ProjectExecTransformer
Output [6]: [hash(channel#36, id#37, sales#114, returns#115, profit#116, 42) AS hash_partition_key#231, channel#36, id#37, sales#114, returns#115, profit#116]
Input [5]: [channel#36, id#37, sales#114, returns#115, profit#116]

(241) WholeStageCodegenTransformer (89)
Input [6]: [hash_partition_key#231, channel#36, id#37, sales#114, returns#115, profit#116]
Arguments: false

(242) VeloxResizeBatches
Input [6]: [hash_partition_key#231, channel#36, id#37, sales#114, returns#115, profit#116]
Arguments: 1024, 2147483647, 10485760

(243) ColumnarExchange
Input [6]: [hash_partition_key#231, channel#36, id#37, sales#114, returns#115, profit#116]
Arguments: hashpartitioning(channel#36, id#37, sales#114, returns#115, profit#116, 1), ENSURE_REQUIREMENTS, [channel#36, id#37, sales#114, returns#115, profit#116], [plan_id=13], [shuffle_writer_type=hash]

(244) InputAdapter
Input [5]: [channel#36, id#37, sales#114, returns#115, profit#116]

(245) InputIteratorTransformer
Input [5]: [channel#36, id#37, sales#114, returns#115, profit#116]

(246) RegularHashAggregateExecTransformer
Input [5]: [channel#36, id#37, sales#114, returns#115, profit#116]
Keys [5]: [channel#36, id#37, sales#114, returns#115, profit#116]
Functions: []
Aggregate Attributes: []
Results [5]: [channel#36, id#37, sales#114, returns#115, profit#116]

(247) WholeStageCodegenTransformer (90)
Input [5]: [channel#36, id#37, sales#114, returns#115, profit#116]
Arguments: false

(248) TakeOrderedAndProjectExecTransformer
Input [5]: [channel#36, id#37, sales#114, returns#115, profit#116]
Arguments: 100, [channel#36 ASC NULLS FIRST, id#37 ASC NULLS FIRST], [channel#36, id#37, sales#114, returns#115, profit#116], 0

(249) VeloxColumnarToRow
Input [5]: [channel#36, id#37, sales#114, returns#115, profit#116]

===== Subqueries =====

Subquery:1 Hosting operator id = 1 Hosting Expression = ss_sold_date_sk#4 IN dynamicpruning#5
ColumnarBroadcastExchange (254)
+- ^ ProjectExecTransformer (252)
   +- ^ FilterExecTransformer (251)
      +- ^ FileSourceScanExecTransformer parquet spark_catalog.default.date_dim (250)


(250) FileSourceScanExecTransformer parquet spark_catalog.default.date_dim
Output [2]: [d_date_sk#6, d_date#232]
Batched: true
Location: InMemoryFileIndex [{warehouse_dir}/date_dim]
PushedFilters: [IsNotNull(d_date), GreaterThanOrEqual(d_date,1998-08-04), LessThanOrEqual(d_date,1998-09-03), IsNotNull(d_date_sk)]
ReadSchema: struct<d_date_sk:int,d_date:date>

(251) FilterExecTransformer
Input [2]: [d_date_sk#6, d_date#232]
Arguments: (((isnotnull(d_date#232) AND (d_date#232 >= 1998-08-04)) AND (d_date#232 <= 1998-09-03)) AND isnotnull(d_date_sk#6))

(252) ProjectExecTransformer
Output [1]: [d_date_sk#6]
Input [2]: [d_date_sk#6, d_date#232]

(253) WholeStageCodegenTransformer (1)
Input [1]: [d_date_sk#6]
Arguments: false

(254) ColumnarBroadcastExchange
Input [1]: [d_date_sk#6]
Arguments: HashedRelationBroadcastMode(List(cast(input[0, int, true] as bigint)),false), [plan_id=14]

Subquery:2 Hosting operator id = 25 Hosting Expression = sr_returned_date_sk#22 IN dynamicpruning#5

Subquery:3 Hosting operator id = 53 Hosting Expression = cs_sold_date_sk#43 IN dynamicpruning#5

Subquery:4 Hosting operator id = 68 Hosting Expression = cr_returned_date_sk#58 IN dynamicpruning#5

Subquery:5 Hosting operator id = 89 Hosting Expression = ws_sold_date_sk#76 IN dynamicpruning#5

Subquery:6 Hosting operator id = 113 Hosting Expression = wr_returned_date_sk#93 IN dynamicpruning#5


