== Physical Plan ==
VeloxColumnarToRow (177)
+- TakeOrderedAndProjectExecTransformer (176)
   +- ^ ProjectExecTransformer (174)
      +- ^ RegularHashAggregateExecTransformer (173)
         +- ^ InputIteratorTransformer (172)
            +- ColumnarExchange (170)
               +- VeloxResizeBatches (169)
                  +- ^ ProjectExecTransformer (167)
                     +- ^ FlushableHashAggregateExecTransformer (166)
                        +- ^ ExpandExecTransformer (165)
                           +- ^ InputIteratorTransformer (164)
                              +- ColumnarUnion (162)
                                 :- ^ ProjectExecTransformer (58)
                                 :  +- ^ RegularHashAggregateExecTransformer (57)
                                 :     +- ^ InputIteratorTransformer (56)
                                 :        +- ColumnarExchange (54)
                                 :           +- VeloxResizeBatches (53)
                                 :              +- ^ ProjectExecTransformer (51)
                                 :                 +- ^ FlushableHashAggregateExecTransformer (50)
                                 :                    +- ^ ProjectExecTransformer (49)
                                 :                       +- ^ BroadcastHashJoinExecTransformer Inner BuildRight (48)
                                 :                          :- ^ ProjectExecTransformer (41)
                                 :                          :  +- ^ BroadcastHashJoinExecTransformer Inner BuildRight (40)
                                 :                          :     :- ^ ProjectExecTransformer (36)
                                 :                          :     :  +- ^ BroadcastHashJoinExecTransformer Inner BuildRight (35)
                                 :                          :     :     :- ^ ProjectExecTransformer (27)
                                 :                          :     :     :  +- ^ BroadcastHashJoinExecTransformer Inner BuildRight (26)
                                 :                          :     :     :     :- ^ ProjectExecTransformer (18)
                                 :                          :     :     :     :  +- ^ ShuffledHashJoinExecTransformer LeftOuter BuildRight (17)
                                 :                          :     :     :     :     :- ^ InputIteratorTransformer (8)
                                 :                          :     :     :     :     :  +- ColumnarExchange (6)
                                 :                          :     :     :     :     :     +- VeloxResizeBatches (5)
                                 :                          :     :     :     :     :        +- ^ ProjectExecTransformer (3)
                                 :                          :     :     :     :     :           +- ^ FilterExecTransformer (2)
                                 :                          :     :     :     :     :              +- ^ FileSourceScanExecTransformer parquet spark_catalog.default.store_sales (1)
                                 :                          :     :     :     :     +- ^ InputIteratorTransformer (16)
                                 :                          :     :     :     :        +- ColumnarExchange (14)
                                 :                          :     :     :     :           +- VeloxResizeBatches (13)
                                 :                          :     :     :     :              +- ^ ProjectExecTransformer (11)
                                 :                          :     :     :     :                 +- ^ FilterExecTransformer (10)
                                 :                          :     :     :     :                    +- ^ FileSourceScanExecTransformer parquet spark_catalog.default.store_returns (9)
                                 :                          :     :     :     +- ^ InputIteratorTransformer (25)
                                 :                          :     :     :        +- ColumnarBroadcastExchange (23)
                                 :                          :     :     :           +- ^ ProjectExecTransformer (21)
                                 :                          :     :     :              +- ^ FilterExecTransformer (20)
                                 :                          :     :     :                 +- ^ FileSourceScanExecTransformer parquet spark_catalog.default.item (19)
                                 :                          :     :     +- ^ InputIteratorTransformer (34)
                                 :                          :     :        +- ColumnarBroadcastExchange (32)
                                 :                          :     :           +- ^ ProjectExecTransformer (30)
                                 :                          :     :              +- ^ FilterExecTransformer (29)
                                 :                          :     :                 +- ^ FileSourceScanExecTransformer parquet spark_catalog.default.promotion (28)
                                 :                          :     +- ^ InputIteratorTransformer (39)
                                 :                          :        +- ReusedExchange (37)
                                 :                          +- ^ InputIteratorTransformer (47)
                                 :                             +- ColumnarBroadcastExchange (45)
                                 :                                +- ^ FilterExecTransformer (43)
                                 :                                   +- ^ FileSourceScanExecTransformer parquet spark_catalog.default.store (42)
                                 :- ^ ProjectExecTransformer (109)
                                 :  +- ^ RegularHashAggregateExecTransformer (108)
                                 :     +- ^ InputIteratorTransformer (107)
                                 :        +- ColumnarExchange (105)
                                 :           +- VeloxResizeBatches (104)
                                 :              +- ^ ProjectExecTransformer (102)
                                 :                 +- ^ FlushableHashAggregateExecTransformer (101)
                                 :                    +- ^ ProjectExecTransformer (100)
                                 :                       +- ^ BroadcastHashJoinExecTransformer Inner BuildRight (99)
                                 :                          :- ^ ProjectExecTransformer (92)
                                 :                          :  +- ^ BroadcastHashJoinExecTransformer Inner BuildRight (91)
                                 :                          :     :- ^ ProjectExecTransformer (87)
                                 :                          :     :  +- ^ BroadcastHashJoinExecTransformer Inner BuildRight (86)
                                 :                          :     :     :- ^ ProjectExecTransformer (82)
                                 :                          :     :     :  +- ^ BroadcastHashJoinExecTransformer Inner BuildRight (81)
                                 :                          :     :     :     :- ^ ProjectExecTransformer (77)
                                 :                          :     :     :     :  +- ^ ShuffledHashJoinExecTransformer LeftOuter BuildRight (76)
                                 :                          :     :     :     :     :- ^ InputIteratorTransformer (67)
                                 :                          :     :     :     :     :  +- ColumnarExchange (65)
                                 :                          :     :     :     :     :     +- VeloxResizeBatches (64)
                                 :                          :     :     :     :     :        +- ^ ProjectExecTransformer (62)
                                 :                          :     :     :     :     :           +- ^ FilterExecTransformer (61)
                                 :                          :     :     :     :     :              +- ^ FileSourceScanExecTransformer parquet spark_catalog.default.catalog_sales (60)
                                 :                          :     :     :     :     +- ^ InputIteratorTransformer (75)
                                 :                          :     :     :     :        +- ColumnarExchange (73)
                                 :                          :     :     :     :           +- VeloxResizeBatches (72)
                                 :                          :     :     :     :              +- ^ ProjectExecTransformer (70)
                                 :                          :     :     :     :                 +- ^ FilterExecTransformer (69)
                                 :                          :     :     :     :                    +- ^ FileSourceScanExecTransformer parquet spark_catalog.default.catalog_returns (68)
                                 :                          :     :     :     +- ^ InputIteratorTransformer (80)
                                 :                          :     :     :        +- ReusedExchange (78)
                                 :                          :     :     +- ^ InputIteratorTransformer (85)
                                 :                          :     :        +- ReusedExchange (83)
                                 :                          :     +- ^ InputIteratorTransformer (90)
                                 :                          :        +- ReusedExchange (88)
                                 :                          +- ^ InputIteratorTransformer (98)
                                 :                             +- ColumnarBroadcastExchange (96)
                                 :                                +- ^ FilterExecTransformer (94)
                                 :                                   +- ^ FileSourceScanExecTransformer parquet spark_catalog.default.catalog_page (93)
                                 +- ^ ProjectExecTransformer (160)
                                    +- ^ RegularHashAggregateExecTransformer (159)
                                       +- ^ InputIteratorTransformer (158)
                                          +- ColumnarExchange (156)
                                             +- VeloxResizeBatches (155)
                                                +- ^ ProjectExecTransformer (153)
                                                   +- ^ FlushableHashAggregateExecTransformer (152)
                                                      +- ^ ProjectExecTransformer (151)
                                                         +- ^ BroadcastHashJoinExecTransformer Inner BuildRight (150)
                                                            :- ^ ProjectExecTransformer (143)
                                                            :  +- ^ BroadcastHashJoinExecTransformer Inner BuildRight (142)
                                                            :     :- ^ ProjectExecTransformer (138)
                                                            :     :  +- ^ BroadcastHashJoinExecTransformer Inner BuildRight (137)
                                                            :     :     :- ^ ProjectExecTransformer (133)
                                                            :     :     :  +- ^ BroadcastHashJoinExecTransformer Inner BuildRight (132)
                                                            :     :     :     :- ^ ProjectExecTransformer (128)
                                                            :     :     :     :  +- ^ ShuffledHashJoinExecTransformer LeftOuter BuildRight (127)
                                                            :     :     :     :     :- ^ InputIteratorTransformer (118)
                                                            :     :     :     :     :  +- ColumnarExchange (116)
                                                            :     :     :     :     :     +- VeloxResizeBatches (115)
                                                            :     :     :     :     :        +- ^ ProjectExecTransformer (113)
                                                            :     :     :     :     :           +- ^ FilterExecTransformer (112)
                                                            :     :     :     :     :              +- ^ FileSourceScanExecTransformer parquet spark_catalog.default.web_sales (111)
                                                            :     :     :     :     +- ^ InputIteratorTransformer (126)
                                                            :     :     :     :        +- ColumnarExchange (124)
                                                            :     :     :     :           +- VeloxResizeBatches (123)
                                                            :     :     :     :              +- ^ ProjectExecTransformer (121)
                                                            :     :     :     :                 +- ^ FilterExecTransformer (120)
                                                            :     :     :     :                    +- ^ FileSourceScanExecTransformer parquet spark_catalog.default.web_returns (119)
                                                            :     :     :     +- ^ InputIteratorTransformer (131)
                                                            :     :     :        +- ReusedExchange (129)
                                                            :     :     +- ^ InputIteratorTransformer (136)
                                                            :     :        +- ReusedExchange (134)
                                                            :     +- ^ InputIteratorTransformer (141)
                                                            :        +- ReusedExchange (139)
                                                            +- ^ InputIteratorTransformer (149)
                                                               +- ColumnarBroadcastExchange (147)
                                                                  +- ^ FilterExecTransformer (145)
                                                                     +- ^ FileSourceScanExecTransformer parquet spark_catalog.default.web_site (144)


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

(2) FilterExecTransformer
Input [7]: [ss_item_sk#1, ss_store_sk#2, ss_promo_sk#3, ss_ticket_number#4, ss_ext_sales_price#5, ss_net_profit#6, ss_sold_date_sk#7]
Arguments: ((((isnotnull(ss_store_sk#2) AND isnotnull(ss_item_sk#1)) AND isnotnull(ss_promo_sk#3)) AND velox_might_contain(Subquery scalar-subquery#9, [id=#1], xxhash64(ss_item_sk#1, 42))) AND velox_might_contain(Subquery scalar-subquery#10, [id=#2], xxhash64(ss_promo_sk#3, 42)))

(3) ProjectExecTransformer
Output [8]: [hash(ss_item_sk#1, ss_ticket_number#4, 42) AS hash_partition_key#11, ss_item_sk#1, ss_store_sk#2, ss_promo_sk#3, ss_ticket_number#4, ss_ext_sales_price#5, ss_net_profit#6, ss_sold_date_sk#7]
Input [7]: [ss_item_sk#1, ss_store_sk#2, ss_promo_sk#3, ss_ticket_number#4, ss_ext_sales_price#5, ss_net_profit#6, ss_sold_date_sk#7]

(4) WholeStageCodegenTransformer (6)
Input [8]: [hash_partition_key#11, ss_item_sk#1, ss_store_sk#2, ss_promo_sk#3, ss_ticket_number#4, ss_ext_sales_price#5, ss_net_profit#6, ss_sold_date_sk#7]
Arguments: false

(5) VeloxResizeBatches
Input [8]: [hash_partition_key#11, ss_item_sk#1, ss_store_sk#2, ss_promo_sk#3, ss_ticket_number#4, ss_ext_sales_price#5, ss_net_profit#6, ss_sold_date_sk#7]
Arguments: 1024, 2147483647, 10485760

(6) ColumnarExchange
Input [8]: [hash_partition_key#11, ss_item_sk#1, ss_store_sk#2, ss_promo_sk#3, ss_ticket_number#4, ss_ext_sales_price#5, ss_net_profit#6, ss_sold_date_sk#7]
Arguments: hashpartitioning(ss_item_sk#1, ss_ticket_number#4, 1), ENSURE_REQUIREMENTS, [ss_item_sk#1, ss_store_sk#2, ss_promo_sk#3, ss_ticket_number#4, ss_ext_sales_price#5, ss_net_profit#6, ss_sold_date_sk#7], [plan_id=3], [shuffle_writer_type=hash]

(7) InputAdapter
Input [7]: [ss_item_sk#1, ss_store_sk#2, ss_promo_sk#3, ss_ticket_number#4, ss_ext_sales_price#5, ss_net_profit#6, ss_sold_date_sk#7]

(8) InputIteratorTransformer
Input [7]: [ss_item_sk#1, ss_store_sk#2, ss_promo_sk#3, ss_ticket_number#4, ss_ext_sales_price#5, ss_net_profit#6, ss_sold_date_sk#7]

(9) FileSourceScanExecTransformer parquet spark_catalog.default.store_returns
Output [5]: [sr_item_sk#12, sr_ticket_number#13, sr_return_amt#14, sr_net_loss#15, sr_returned_date_sk#16]
Batched: true
Location: CatalogFileIndex [{warehouse_dir}/store_returns]
PushedFilters: [IsNotNull(sr_item_sk), IsNotNull(sr_ticket_number)]
ReadSchema: struct<sr_item_sk:int,sr_ticket_number:int,sr_return_amt:decimal(7,2),sr_net_loss:decimal(7,2)>

(10) FilterExecTransformer
Input [5]: [sr_item_sk#12, sr_ticket_number#13, sr_return_amt#14, sr_net_loss#15, sr_returned_date_sk#16]
Arguments: (isnotnull(sr_item_sk#12) AND isnotnull(sr_ticket_number#13))

(11) ProjectExecTransformer
Output [5]: [hash(sr_item_sk#12, sr_ticket_number#13, 42) AS hash_partition_key#17, sr_item_sk#12, sr_ticket_number#13, sr_return_amt#14, sr_net_loss#15]
Input [5]: [sr_item_sk#12, sr_ticket_number#13, sr_return_amt#14, sr_net_loss#15, sr_returned_date_sk#16]

(12) WholeStageCodegenTransformer (7)
Input [5]: [hash_partition_key#17, sr_item_sk#12, sr_ticket_number#13, sr_return_amt#14, sr_net_loss#15]
Arguments: false

(13) VeloxResizeBatches
Input [5]: [hash_partition_key#17, sr_item_sk#12, sr_ticket_number#13, sr_return_amt#14, sr_net_loss#15]
Arguments: 1024, 2147483647, 10485760

(14) ColumnarExchange
Input [5]: [hash_partition_key#17, sr_item_sk#12, sr_ticket_number#13, sr_return_amt#14, sr_net_loss#15]
Arguments: hashpartitioning(sr_item_sk#12, sr_ticket_number#13, 1), ENSURE_REQUIREMENTS, [sr_item_sk#12, sr_ticket_number#13, sr_return_amt#14, sr_net_loss#15], [plan_id=4], [shuffle_writer_type=hash]

(15) InputAdapter
Input [4]: [sr_item_sk#12, sr_ticket_number#13, sr_return_amt#14, sr_net_loss#15]

(16) InputIteratorTransformer
Input [4]: [sr_item_sk#12, sr_ticket_number#13, sr_return_amt#14, sr_net_loss#15]

(17) ShuffledHashJoinExecTransformer
Left keys [2]: [ss_item_sk#1, ss_ticket_number#4]
Right keys [2]: [sr_item_sk#12, sr_ticket_number#13]
Join type: LeftOuter
Join condition: None

(18) ProjectExecTransformer
Output [8]: [ss_item_sk#1, ss_store_sk#2, ss_promo_sk#3, ss_ext_sales_price#5, ss_net_profit#6, ss_sold_date_sk#7, sr_return_amt#14, sr_net_loss#15]
Input [11]: [ss_item_sk#1, ss_store_sk#2, ss_promo_sk#3, ss_ticket_number#4, ss_ext_sales_price#5, ss_net_profit#6, ss_sold_date_sk#7, sr_item_sk#12, sr_ticket_number#13, sr_return_amt#14, sr_net_loss#15]

(19) FileSourceScanExecTransformer parquet spark_catalog.default.item
Output [2]: [i_item_sk#18, i_current_price#19]
Batched: true
Location: InMemoryFileIndex [{warehouse_dir}/item]
PushedFilters: [IsNotNull(i_current_price), GreaterThan(i_current_price,50.00), IsNotNull(i_item_sk)]
ReadSchema: struct<i_item_sk:int,i_current_price:decimal(7,2)>

(20) FilterExecTransformer
Input [2]: [i_item_sk#18, i_current_price#19]
Arguments: ((isnotnull(i_current_price#19) AND (i_current_price#19 > 50.00)) AND isnotnull(i_item_sk#18))

(21) ProjectExecTransformer
Output [1]: [i_item_sk#18]
Input [2]: [i_item_sk#18, i_current_price#19]

(22) WholeStageCodegenTransformer (8)
Input [1]: [i_item_sk#18]
Arguments: false

(23) ColumnarBroadcastExchange
Input [1]: [i_item_sk#18]
Arguments: HashedRelationBroadcastMode(List(cast(input[0, int, true] as bigint)),false), [plan_id=5]

(24) InputAdapter
Input [1]: [i_item_sk#18]

(25) InputIteratorTransformer
Input [1]: [i_item_sk#18]

(26) BroadcastHashJoinExecTransformer
Left keys [1]: [ss_item_sk#1]
Right keys [1]: [i_item_sk#18]
Join type: Inner
Join condition: None

(27) ProjectExecTransformer
Output [7]: [ss_store_sk#2, ss_promo_sk#3, ss_ext_sales_price#5, ss_net_profit#6, ss_sold_date_sk#7, sr_return_amt#14, sr_net_loss#15]
Input [9]: [ss_item_sk#1, ss_store_sk#2, ss_promo_sk#3, ss_ext_sales_price#5, ss_net_profit#6, ss_sold_date_sk#7, sr_return_amt#14, sr_net_loss#15, i_item_sk#18]

(28) FileSourceScanExecTransformer parquet spark_catalog.default.promotion
Output [2]: [p_promo_sk#20, p_channel_tv#21]
Batched: true
Location: InMemoryFileIndex [{warehouse_dir}/promotion]
PushedFilters: [IsNotNull(p_channel_tv), EqualTo(p_channel_tv,N), IsNotNull(p_promo_sk)]
ReadSchema: struct<p_promo_sk:int,p_channel_tv:string>

(29) FilterExecTransformer
Input [2]: [p_promo_sk#20, p_channel_tv#21]
Arguments: ((isnotnull(p_channel_tv#21) AND (p_channel_tv#21 = N)) AND isnotnull(p_promo_sk#20))

(30) ProjectExecTransformer
Output [1]: [p_promo_sk#20]
Input [2]: [p_promo_sk#20, p_channel_tv#21]

(31) WholeStageCodegenTransformer (9)
Input [1]: [p_promo_sk#20]
Arguments: false

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

(33) InputAdapter
Input [1]: [p_promo_sk#20]

(34) InputIteratorTransformer
Input [1]: [p_promo_sk#20]

(35) BroadcastHashJoinExecTransformer
Left keys [1]: [ss_promo_sk#3]
Right keys [1]: [p_promo_sk#20]
Join type: Inner
Join condition: None

(36) ProjectExecTransformer
Output [6]: [ss_store_sk#2, ss_ext_sales_price#5, ss_net_profit#6, ss_sold_date_sk#7, sr_return_amt#14, sr_net_loss#15]
Input [8]: [ss_store_sk#2, ss_promo_sk#3, ss_ext_sales_price#5, ss_net_profit#6, ss_sold_date_sk#7, sr_return_amt#14, sr_net_loss#15, p_promo_sk#20]

(37) ReusedExchange [Reuses operator id: 206]
Output [1]: [d_date_sk#22]

(38) InputAdapter
Input [1]: [d_date_sk#22]

(39) InputIteratorTransformer
Input [1]: [d_date_sk#22]

(40) BroadcastHashJoinExecTransformer
Left keys [1]: [ss_sold_date_sk#7]
Right keys [1]: [d_date_sk#22]
Join type: Inner
Join condition: None

(41) ProjectExecTransformer
Output [5]: [ss_store_sk#2, ss_ext_sales_price#5, ss_net_profit#6, sr_return_amt#14, sr_net_loss#15]
Input [7]: [ss_store_sk#2, ss_ext_sales_price#5, ss_net_profit#6, ss_sold_date_sk#7, sr_return_amt#14, sr_net_loss#15, d_date_sk#22]

(42) FileSourceScanExecTransformer parquet spark_catalog.default.store
Output [2]: [s_store_sk#23, s_store_id#24]
Batched: true
Location: InMemoryFileIndex [{warehouse_dir}/store]
PushedFilters: [IsNotNull(s_store_sk)]
ReadSchema: struct<s_store_sk:int,s_store_id:string>

(43) FilterExecTransformer
Input [2]: [s_store_sk#23, s_store_id#24]
Arguments: isnotnull(s_store_sk#23)

(44) WholeStageCodegenTransformer (11)
Input [2]: [s_store_sk#23, s_store_id#24]
Arguments: false

(45) ColumnarBroadcastExchange
Input [2]: [s_store_sk#23, s_store_id#24]
Arguments: HashedRelationBroadcastMode(List(cast(input[0, int, false] as bigint)),false), [plan_id=7]

(46) InputAdapter
Input [2]: [s_store_sk#23, s_store_id#24]

(47) InputIteratorTransformer
Input [2]: [s_store_sk#23, s_store_id#24]

(48) BroadcastHashJoinExecTransformer
Left keys [1]: [ss_store_sk#2]
Right keys [1]: [s_store_sk#23]
Join type: Inner
Join condition: None

(49) ProjectExecTransformer
Output [4]: [s_store_id#24, UnscaledValue(ss_ext_sales_price#5) AS _pre_1#25, coalesce(cast(sr_return_amt#14 as decimal(12,2)), 0.00) AS _pre_2#26, (ss_net_profit#6 - coalesce(cast(sr_net_loss#15 as decimal(12,2)), 0.00)) AS _pre_3#27]
Input [7]: [ss_store_sk#2, ss_ext_sales_price#5, ss_net_profit#6, sr_return_amt#14, sr_net_loss#15, s_store_sk#23, s_store_id#24]

(50) FlushableHashAggregateExecTransformer
Input [4]: [s_store_id#24, _pre_1#25, _pre_2#26, _pre_3#27]
Keys [1]: [s_store_id#24]
Functions [3]: [partial_sum(_pre_1#25), partial_sum(_pre_2#26), partial_sum(_pre_3#27)]
Aggregate Attributes [5]: [sum#28, sum#29, isEmpty#30, sum#31, isEmpty#32]
Results [6]: [s_store_id#24, sum#33, sum#34, isEmpty#35, sum#36, isEmpty#37]

(51) ProjectExecTransformer
Output [7]: [hash(s_store_id#24, 42) AS hash_partition_key#38, s_store_id#24, sum#33, sum#34, isEmpty#35, sum#36, isEmpty#37]
Input [6]: [s_store_id#24, sum#33, sum#34, isEmpty#35, sum#36, isEmpty#37]

(52) WholeStageCodegenTransformer (12)
Input [7]: [hash_partition_key#38, s_store_id#24, sum#33, sum#34, isEmpty#35, sum#36, isEmpty#37]
Arguments: false

(53) VeloxResizeBatches
Input [7]: [hash_partition_key#38, s_store_id#24, sum#33, sum#34, isEmpty#35, sum#36, isEmpty#37]
Arguments: 1024, 2147483647, 10485760

(54) ColumnarExchange
Input [7]: [hash_partition_key#38, s_store_id#24, sum#33, sum#34, isEmpty#35, sum#36, isEmpty#37]
Arguments: hashpartitioning(s_store_id#24, 1), ENSURE_REQUIREMENTS, [s_store_id#24, sum#33, sum#34, isEmpty#35, sum#36, isEmpty#37], [plan_id=8], [shuffle_writer_type=hash]

(55) InputAdapter
Input [6]: [s_store_id#24, sum#33, sum#34, isEmpty#35, sum#36, isEmpty#37]

(56) InputIteratorTransformer
Input [6]: [s_store_id#24, sum#33, sum#34, isEmpty#35, sum#36, isEmpty#37]

(57) RegularHashAggregateExecTransformer
Input [6]: [s_store_id#24, sum#33, sum#34, isEmpty#35, sum#36, isEmpty#37]
Keys [1]: [s_store_id#24]
Functions [3]: [sum(UnscaledValue(ss_ext_sales_price#5)), sum(coalesce(cast(sr_return_amt#14 as decimal(12,2)), 0.00)), sum((ss_net_profit#6 - coalesce(cast(sr_net_loss#15 as decimal(12,2)), 0.00)))]
Aggregate Attributes [3]: [sum(UnscaledValue(ss_ext_sales_price#5))#39, sum(coalesce(cast(sr_return_amt#14 as decimal(12,2)), 0.00))#40, sum((ss_net_profit#6 - coalesce(cast(sr_net_loss#15 as decimal(12,2)), 0.00)))#41]
Results [4]: [s_store_id#24, sum(UnscaledValue(ss_ext_sales_price#5))#39, sum(coalesce(cast(sr_return_amt#14 as decimal(12,2)), 0.00))#40, sum((ss_net_profit#6 - coalesce(cast(sr_net_loss#15 as decimal(12,2)), 0.00)))#41]

(58) ProjectExecTransformer
Output [5]: [MakeDecimal(sum(UnscaledValue(ss_ext_sales_price#5))#39,17,2) AS sales#42, sum(coalesce(cast(sr_return_amt#14 as decimal(12,2)), 0.00))#40 AS returns#43, sum((ss_net_profit#6 - coalesce(cast(sr_net_loss#15 as decimal(12,2)), 0.00)))#41 AS profit#44, store channel AS channel#45, concat(store, s_store_id#24) AS id#46]
Input [4]: [s_store_id#24, sum(UnscaledValue(ss_ext_sales_price#5))#39, sum(coalesce(cast(sr_return_amt#14 as decimal(12,2)), 0.00))#40, sum((ss_net_profit#6 - coalesce(cast(sr_net_loss#15 as decimal(12,2)), 0.00)))#41]

(59) WholeStageCodegenTransformer (13)
Input [5]: [sales#42, returns#43, profit#44, channel#45, id#46]
Arguments: false

(60) FileSourceScanExecTransformer parquet spark_catalog.default.catalog_sales
Output [7]: [cs_catalog_page_sk#47, cs_item_sk#48, cs_promo_sk#49, cs_order_number#50, cs_ext_sales_price#51, cs_net_profit#52, cs_sold_date_sk#53]
Batched: true
Location: InMemoryFileIndex []
PartitionFilters: [isnotnull(cs_sold_date_sk#53), dynamicpruningexpression(cs_sold_date_sk#53 IN dynamicpruning#8)]
PushedFilters: [IsNotNull(cs_catalog_page_sk), IsNotNull(cs_item_sk), IsNotNull(cs_promo_sk)]
ReadSchema: struct<cs_catalog_page_sk:int,cs_item_sk:int,cs_promo_sk:int,cs_order_number:int,cs_ext_sales_price:decimal(7,2),cs_net_profit:decimal(7,2)>

(61) FilterExecTransformer
Input [7]: [cs_catalog_page_sk#47, cs_item_sk#48, cs_promo_sk#49, cs_order_number#50, cs_ext_sales_price#51, cs_net_profit#52, cs_sold_date_sk#53]
Arguments: ((((isnotnull(cs_catalog_page_sk#47) AND isnotnull(cs_item_sk#48)) AND isnotnull(cs_promo_sk#49)) AND velox_might_contain(ReusedSubquery Subquery scalar-subquery#9, [id=#1], xxhash64(cs_item_sk#48, 42))) AND velox_might_contain(ReusedSubquery Subquery scalar-subquery#10, [id=#2], xxhash64(cs_promo_sk#49, 42)))

(62) ProjectExecTransformer
Output [8]: [hash(cs_item_sk#48, cs_order_number#50, 42) AS hash_partition_key#54, cs_catalog_page_sk#47, cs_item_sk#48, cs_promo_sk#49, cs_order_number#50, cs_ext_sales_price#51, cs_net_profit#52, cs_sold_date_sk#53]
Input [7]: [cs_catalog_page_sk#47, cs_item_sk#48, cs_promo_sk#49, cs_order_number#50, cs_ext_sales_price#51, cs_net_profit#52, cs_sold_date_sk#53]

(63) WholeStageCodegenTransformer (19)
Input [8]: [hash_partition_key#54, cs_catalog_page_sk#47, cs_item_sk#48, cs_promo_sk#49, cs_order_number#50, cs_ext_sales_price#51, cs_net_profit#52, cs_sold_date_sk#53]
Arguments: false

(64) VeloxResizeBatches
Input [8]: [hash_partition_key#54, cs_catalog_page_sk#47, cs_item_sk#48, cs_promo_sk#49, cs_order_number#50, cs_ext_sales_price#51, cs_net_profit#52, cs_sold_date_sk#53]
Arguments: 1024, 2147483647, 10485760

(65) ColumnarExchange
Input [8]: [hash_partition_key#54, cs_catalog_page_sk#47, cs_item_sk#48, cs_promo_sk#49, cs_order_number#50, cs_ext_sales_price#51, cs_net_profit#52, cs_sold_date_sk#53]
Arguments: hashpartitioning(cs_item_sk#48, cs_order_number#50, 1), ENSURE_REQUIREMENTS, [cs_catalog_page_sk#47, cs_item_sk#48, cs_promo_sk#49, cs_order_number#50, cs_ext_sales_price#51, cs_net_profit#52, cs_sold_date_sk#53], [plan_id=9], [shuffle_writer_type=hash]

(66) InputAdapter
Input [7]: [cs_catalog_page_sk#47, cs_item_sk#48, cs_promo_sk#49, cs_order_number#50, cs_ext_sales_price#51, cs_net_profit#52, cs_sold_date_sk#53]

(67) InputIteratorTransformer
Input [7]: [cs_catalog_page_sk#47, cs_item_sk#48, cs_promo_sk#49, cs_order_number#50, cs_ext_sales_price#51, cs_net_profit#52, cs_sold_date_sk#53]

(68) FileSourceScanExecTransformer parquet spark_catalog.default.catalog_returns
Output [5]: [cr_item_sk#55, cr_order_number#56, cr_return_amount#57, cr_net_loss#58, cr_returned_date_sk#59]
Batched: true
Location: CatalogFileIndex [{warehouse_dir}/catalog_returns]
PushedFilters: [IsNotNull(cr_item_sk), IsNotNull(cr_order_number)]
ReadSchema: struct<cr_item_sk:int,cr_order_number:int,cr_return_amount:decimal(7,2),cr_net_loss:decimal(7,2)>

(69) FilterExecTransformer
Input [5]: [cr_item_sk#55, cr_order_number#56, cr_return_amount#57, cr_net_loss#58, cr_returned_date_sk#59]
Arguments: (isnotnull(cr_item_sk#55) AND isnotnull(cr_order_number#56))

(70) ProjectExecTransformer
Output [5]: [hash(cr_item_sk#55, cr_order_number#56, 42) AS hash_partition_key#60, cr_item_sk#55, cr_order_number#56, cr_return_amount#57, cr_net_loss#58]
Input [5]: [cr_item_sk#55, cr_order_number#56, cr_return_amount#57, cr_net_loss#58, cr_returned_date_sk#59]

(71) WholeStageCodegenTransformer (20)
Input [5]: [hash_partition_key#60, cr_item_sk#55, cr_order_number#56, cr_return_amount#57, cr_net_loss#58]
Arguments: false

(72) VeloxResizeBatches
Input [5]: [hash_partition_key#60, cr_item_sk#55, cr_order_number#56, cr_return_amount#57, cr_net_loss#58]
Arguments: 1024, 2147483647, 10485760

(73) ColumnarExchange
Input [5]: [hash_partition_key#60, cr_item_sk#55, cr_order_number#56, cr_return_amount#57, cr_net_loss#58]
Arguments: hashpartitioning(cr_item_sk#55, cr_order_number#56, 1), ENSURE_REQUIREMENTS, [cr_item_sk#55, cr_order_number#56, cr_return_amount#57, cr_net_loss#58], [plan_id=10], [shuffle_writer_type=hash]

(74) InputAdapter
Input [4]: [cr_item_sk#55, cr_order_number#56, cr_return_amount#57, cr_net_loss#58]

(75) InputIteratorTransformer
Input [4]: [cr_item_sk#55, cr_order_number#56, cr_return_amount#57, cr_net_loss#58]

(76) ShuffledHashJoinExecTransformer
Left keys [2]: [cs_item_sk#48, cs_order_number#50]
Right keys [2]: [cr_item_sk#55, cr_order_number#56]
Join type: LeftOuter
Join condition: None

(77) ProjectExecTransformer
Output [8]: [cs_catalog_page_sk#47, cs_item_sk#48, cs_promo_sk#49, cs_ext_sales_price#51, cs_net_profit#52, cs_sold_date_sk#53, cr_return_amount#57, cr_net_loss#58]
Input [11]: [cs_catalog_page_sk#47, cs_item_sk#48, cs_promo_sk#49, cs_order_number#50, cs_ext_sales_price#51, cs_net_profit#52, cs_sold_date_sk#53, cr_item_sk#55, cr_order_number#56, cr_return_amount#57, cr_net_loss#58]

(78) ReusedExchange [Reuses operator id: 23]
Output [1]: [i_item_sk#61]

(79) InputAdapter
Input [1]: [i_item_sk#61]

(80) InputIteratorTransformer
Input [1]: [i_item_sk#61]

(81) BroadcastHashJoinExecTransformer
Left keys [1]: [cs_item_sk#48]
Right keys [1]: [i_item_sk#61]
Join type: Inner
Join condition: None

(82) ProjectExecTransformer
Output [7]: [cs_catalog_page_sk#47, cs_promo_sk#49, cs_ext_sales_price#51, cs_net_profit#52, cs_sold_date_sk#53, cr_return_amount#57, cr_net_loss#58]
Input [9]: [cs_catalog_page_sk#47, cs_item_sk#48, cs_promo_sk#49, cs_ext_sales_price#51, cs_net_profit#52, cs_sold_date_sk#53, cr_return_amount#57, cr_net_loss#58, i_item_sk#61]

(83) ReusedExchange [Reuses operator id: 32]
Output [1]: [p_promo_sk#62]

(84) InputAdapter
Input [1]: [p_promo_sk#62]

(85) InputIteratorTransformer
Input [1]: [p_promo_sk#62]

(86) BroadcastHashJoinExecTransformer
Left keys [1]: [cs_promo_sk#49]
Right keys [1]: [p_promo_sk#62]
Join type: Inner
Join condition: None

(87) ProjectExecTransformer
Output [6]: [cs_catalog_page_sk#47, cs_ext_sales_price#51, cs_net_profit#52, cs_sold_date_sk#53, cr_return_amount#57, cr_net_loss#58]
Input [8]: [cs_catalog_page_sk#47, cs_promo_sk#49, cs_ext_sales_price#51, cs_net_profit#52, cs_sold_date_sk#53, cr_return_amount#57, cr_net_loss#58, p_promo_sk#62]

(88) ReusedExchange [Reuses operator id: 206]
Output [1]: [d_date_sk#63]

(89) InputAdapter
Input [1]: [d_date_sk#63]

(90) InputIteratorTransformer
Input [1]: [d_date_sk#63]

(91) BroadcastHashJoinExecTransformer
Left keys [1]: [cs_sold_date_sk#53]
Right keys [1]: [d_date_sk#63]
Join type: Inner
Join condition: None

(92) ProjectExecTransformer
Output [5]: [cs_catalog_page_sk#47, cs_ext_sales_price#51, cs_net_profit#52, cr_return_amount#57, cr_net_loss#58]
Input [7]: [cs_catalog_page_sk#47, cs_ext_sales_price#51, cs_net_profit#52, cs_sold_date_sk#53, cr_return_amount#57, cr_net_loss#58, d_date_sk#63]

(93) FileSourceScanExecTransformer parquet spark_catalog.default.catalog_page
Output [2]: [cp_catalog_page_sk#64, cp_catalog_page_id#65]
Batched: true
Location: InMemoryFileIndex [{warehouse_dir}/catalog_page]
PushedFilters: [IsNotNull(cp_catalog_page_sk)]
ReadSchema: struct<cp_catalog_page_sk:int,cp_catalog_page_id:string>

(94) FilterExecTransformer
Input [2]: [cp_catalog_page_sk#64, cp_catalog_page_id#65]
Arguments: isnotnull(cp_catalog_page_sk#64)

(95) WholeStageCodegenTransformer (24)
Input [2]: [cp_catalog_page_sk#64, cp_catalog_page_id#65]
Arguments: false

(96) ColumnarBroadcastExchange
Input [2]: [cp_catalog_page_sk#64, cp_catalog_page_id#65]
Arguments: HashedRelationBroadcastMode(List(cast(input[0, int, false] as bigint)),false), [plan_id=11]

(97) InputAdapter
Input [2]: [cp_catalog_page_sk#64, cp_catalog_page_id#65]

(98) InputIteratorTransformer
Input [2]: [cp_catalog_page_sk#64, cp_catalog_page_id#65]

(99) BroadcastHashJoinExecTransformer
Left keys [1]: [cs_catalog_page_sk#47]
Right keys [1]: [cp_catalog_page_sk#64]
Join type: Inner
Join condition: None

(100) ProjectExecTransformer
Output [4]: [cp_catalog_page_id#65, UnscaledValue(cs_ext_sales_price#51) AS _pre_4#66, coalesce(cast(cr_return_amount#57 as decimal(12,2)), 0.00) AS _pre_5#67, (cs_net_profit#52 - coalesce(cast(cr_net_loss#58 as decimal(12,2)), 0.00)) AS _pre_6#68]
Input [7]: [cs_catalog_page_sk#47, cs_ext_sales_price#51, cs_net_profit#52, cr_return_amount#57, cr_net_loss#58, cp_catalog_page_sk#64, cp_catalog_page_id#65]

(101) FlushableHashAggregateExecTransformer
Input [4]: [cp_catalog_page_id#65, _pre_4#66, _pre_5#67, _pre_6#68]
Keys [1]: [cp_catalog_page_id#65]
Functions [3]: [partial_sum(_pre_4#66), partial_sum(_pre_5#67), partial_sum(_pre_6#68)]
Aggregate Attributes [5]: [sum#69, sum#70, isEmpty#71, sum#72, isEmpty#73]
Results [6]: [cp_catalog_page_id#65, sum#74, sum#75, isEmpty#76, sum#77, isEmpty#78]

(102) ProjectExecTransformer
Output [7]: [hash(cp_catalog_page_id#65, 42) AS hash_partition_key#79, cp_catalog_page_id#65, sum#74, sum#75, isEmpty#76, sum#77, isEmpty#78]
Input [6]: [cp_catalog_page_id#65, sum#74, sum#75, isEmpty#76, sum#77, isEmpty#78]

(103) WholeStageCodegenTransformer (25)
Input [7]: [hash_partition_key#79, cp_catalog_page_id#65, sum#74, sum#75, isEmpty#76, sum#77, isEmpty#78]
Arguments: false

(104) VeloxResizeBatches
Input [7]: [hash_partition_key#79, cp_catalog_page_id#65, sum#74, sum#75, isEmpty#76, sum#77, isEmpty#78]
Arguments: 1024, 2147483647, 10485760

(105) ColumnarExchange
Input [7]: [hash_partition_key#79, cp_catalog_page_id#65, sum#74, sum#75, isEmpty#76, sum#77, isEmpty#78]
Arguments: hashpartitioning(cp_catalog_page_id#65, 1), ENSURE_REQUIREMENTS, [cp_catalog_page_id#65, sum#74, sum#75, isEmpty#76, sum#77, isEmpty#78], [plan_id=12], [shuffle_writer_type=hash]

(106) InputAdapter
Input [6]: [cp_catalog_page_id#65, sum#74, sum#75, isEmpty#76, sum#77, isEmpty#78]

(107) InputIteratorTransformer
Input [6]: [cp_catalog_page_id#65, sum#74, sum#75, isEmpty#76, sum#77, isEmpty#78]

(108) RegularHashAggregateExecTransformer
Input [6]: [cp_catalog_page_id#65, sum#74, sum#75, isEmpty#76, sum#77, isEmpty#78]
Keys [1]: [cp_catalog_page_id#65]
Functions [3]: [sum(UnscaledValue(cs_ext_sales_price#51)), sum(coalesce(cast(cr_return_amount#57 as decimal(12,2)), 0.00)), sum((cs_net_profit#52 - coalesce(cast(cr_net_loss#58 as decimal(12,2)), 0.00)))]
Aggregate Attributes [3]: [sum(UnscaledValue(cs_ext_sales_price#51))#80, sum(coalesce(cast(cr_return_amount#57 as decimal(12,2)), 0.00))#81, sum((cs_net_profit#52 - coalesce(cast(cr_net_loss#58 as decimal(12,2)), 0.00)))#82]
Results [4]: [cp_catalog_page_id#65, sum(UnscaledValue(cs_ext_sales_price#51))#80, sum(coalesce(cast(cr_return_amount#57 as decimal(12,2)), 0.00))#81, sum((cs_net_profit#52 - coalesce(cast(cr_net_loss#58 as decimal(12,2)), 0.00)))#82]

(109) ProjectExecTransformer
Output [5]: [MakeDecimal(sum(UnscaledValue(cs_ext_sales_price#51))#80,17,2) AS sales#83, sum(coalesce(cast(cr_return_amount#57 as decimal(12,2)), 0.00))#81 AS returns#84, sum((cs_net_profit#52 - coalesce(cast(cr_net_loss#58 as decimal(12,2)), 0.00)))#82 AS profit#85, catalog channel AS channel#86, concat(catalog_page, cp_catalog_page_id#65) AS id#87]
Input [4]: [cp_catalog_page_id#65, sum(UnscaledValue(cs_ext_sales_price#51))#80, sum(coalesce(cast(cr_return_amount#57 as decimal(12,2)), 0.00))#81, sum((cs_net_profit#52 - coalesce(cast(cr_net_loss#58 as decimal(12,2)), 0.00)))#82]

(110) WholeStageCodegenTransformer (26)
Input [5]: [sales#83, returns#84, profit#85, channel#86, id#87]
Arguments: false

(111) FileSourceScanExecTransformer parquet spark_catalog.default.web_sales
Output [7]: [ws_item_sk#88, ws_web_site_sk#89, ws_promo_sk#90, ws_order_number#91, ws_ext_sales_price#92, ws_net_profit#93, ws_sold_date_sk#94]
Batched: true
Location: InMemoryFileIndex []
PartitionFilters: [isnotnull(ws_sold_date_sk#94), dynamicpruningexpression(ws_sold_date_sk#94 IN dynamicpruning#8)]
PushedFilters: [IsNotNull(ws_web_site_sk), IsNotNull(ws_item_sk), IsNotNull(ws_promo_sk)]
ReadSchema: struct<ws_item_sk:int,ws_web_site_sk:int,ws_promo_sk:int,ws_order_number:int,ws_ext_sales_price:decimal(7,2),ws_net_profit:decimal(7,2)>

(112) FilterExecTransformer
Input [7]: [ws_item_sk#88, ws_web_site_sk#89, ws_promo_sk#90, ws_order_number#91, ws_ext_sales_price#92, ws_net_profit#93, ws_sold_date_sk#94]
Arguments: ((((isnotnull(ws_web_site_sk#89) AND isnotnull(ws_item_sk#88)) AND isnotnull(ws_promo_sk#90)) AND velox_might_contain(ReusedSubquery Subquery scalar-subquery#9, [id=#1], xxhash64(ws_item_sk#88, 42))) AND velox_might_contain(ReusedSubquery Subquery scalar-subquery#10, [id=#2], xxhash64(ws_promo_sk#90, 42)))

(113) ProjectExecTransformer
Output [8]: [hash(ws_item_sk#88, ws_order_number#91, 42) AS hash_partition_key#95, ws_item_sk#88, ws_web_site_sk#89, ws_promo_sk#90, ws_order_number#91, ws_ext_sales_price#92, ws_net_profit#93, ws_sold_date_sk#94]
Input [7]: [ws_item_sk#88, ws_web_site_sk#89, ws_promo_sk#90, ws_order_number#91, ws_ext_sales_price#92, ws_net_profit#93, ws_sold_date_sk#94]

(114) WholeStageCodegenTransformer (32)
Input [8]: [hash_partition_key#95, ws_item_sk#88, ws_web_site_sk#89, ws_promo_sk#90, ws_order_number#91, ws_ext_sales_price#92, ws_net_profit#93, ws_sold_date_sk#94]
Arguments: false

(115) VeloxResizeBatches
Input [8]: [hash_partition_key#95, ws_item_sk#88, ws_web_site_sk#89, ws_promo_sk#90, ws_order_number#91, ws_ext_sales_price#92, ws_net_profit#93, ws_sold_date_sk#94]
Arguments: 1024, 2147483647, 10485760

(116) ColumnarExchange
Input [8]: [hash_partition_key#95, ws_item_sk#88, ws_web_site_sk#89, ws_promo_sk#90, ws_order_number#91, ws_ext_sales_price#92, ws_net_profit#93, ws_sold_date_sk#94]
Arguments: hashpartitioning(ws_item_sk#88, ws_order_number#91, 1), ENSURE_REQUIREMENTS, [ws_item_sk#88, ws_web_site_sk#89, ws_promo_sk#90, ws_order_number#91, ws_ext_sales_price#92, ws_net_profit#93, ws_sold_date_sk#94], [plan_id=13], [shuffle_writer_type=hash]

(117) InputAdapter
Input [7]: [ws_item_sk#88, ws_web_site_sk#89, ws_promo_sk#90, ws_order_number#91, ws_ext_sales_price#92, ws_net_profit#93, ws_sold_date_sk#94]

(118) InputIteratorTransformer
Input [7]: [ws_item_sk#88, ws_web_site_sk#89, ws_promo_sk#90, ws_order_number#91, ws_ext_sales_price#92, ws_net_profit#93, ws_sold_date_sk#94]

(119) FileSourceScanExecTransformer parquet spark_catalog.default.web_returns
Output [5]: [wr_item_sk#96, wr_order_number#97, wr_return_amt#98, wr_net_loss#99, wr_returned_date_sk#100]
Batched: true
Location: CatalogFileIndex [{warehouse_dir}/web_returns]
PushedFilters: [IsNotNull(wr_item_sk), IsNotNull(wr_order_number)]
ReadSchema: struct<wr_item_sk:int,wr_order_number:int,wr_return_amt:decimal(7,2),wr_net_loss:decimal(7,2)>

(120) FilterExecTransformer
Input [5]: [wr_item_sk#96, wr_order_number#97, wr_return_amt#98, wr_net_loss#99, wr_returned_date_sk#100]
Arguments: (isnotnull(wr_item_sk#96) AND isnotnull(wr_order_number#97))

(121) ProjectExecTransformer
Output [5]: [hash(wr_item_sk#96, wr_order_number#97, 42) AS hash_partition_key#101, wr_item_sk#96, wr_order_number#97, wr_return_amt#98, wr_net_loss#99]
Input [5]: [wr_item_sk#96, wr_order_number#97, wr_return_amt#98, wr_net_loss#99, wr_returned_date_sk#100]

(122) WholeStageCodegenTransformer (33)
Input [5]: [hash_partition_key#101, wr_item_sk#96, wr_order_number#97, wr_return_amt#98, wr_net_loss#99]
Arguments: false

(123) VeloxResizeBatches
Input [5]: [hash_partition_key#101, wr_item_sk#96, wr_order_number#97, wr_return_amt#98, wr_net_loss#99]
Arguments: 1024, 2147483647, 10485760

(124) ColumnarExchange
Input [5]: [hash_partition_key#101, wr_item_sk#96, wr_order_number#97, wr_return_amt#98, wr_net_loss#99]
Arguments: hashpartitioning(wr_item_sk#96, wr_order_number#97, 1), ENSURE_REQUIREMENTS, [wr_item_sk#96, wr_order_number#97, wr_return_amt#98, wr_net_loss#99], [plan_id=14], [shuffle_writer_type=hash]

(125) InputAdapter
Input [4]: [wr_item_sk#96, wr_order_number#97, wr_return_amt#98, wr_net_loss#99]

(126) InputIteratorTransformer
Input [4]: [wr_item_sk#96, wr_order_number#97, wr_return_amt#98, wr_net_loss#99]

(127) ShuffledHashJoinExecTransformer
Left keys [2]: [ws_item_sk#88, ws_order_number#91]
Right keys [2]: [wr_item_sk#96, wr_order_number#97]
Join type: LeftOuter
Join condition: None

(128) ProjectExecTransformer
Output [8]: [ws_item_sk#88, ws_web_site_sk#89, ws_promo_sk#90, ws_ext_sales_price#92, ws_net_profit#93, ws_sold_date_sk#94, wr_return_amt#98, wr_net_loss#99]
Input [11]: [ws_item_sk#88, ws_web_site_sk#89, ws_promo_sk#90, ws_order_number#91, ws_ext_sales_price#92, ws_net_profit#93, ws_sold_date_sk#94, wr_item_sk#96, wr_order_number#97, wr_return_amt#98, wr_net_loss#99]

(129) ReusedExchange [Reuses operator id: 23]
Output [1]: [i_item_sk#102]

(130) InputAdapter
Input [1]: [i_item_sk#102]

(131) InputIteratorTransformer
Input [1]: [i_item_sk#102]

(132) BroadcastHashJoinExecTransformer
Left keys [1]: [ws_item_sk#88]
Right keys [1]: [i_item_sk#102]
Join type: Inner
Join condition: None

(133) ProjectExecTransformer
Output [7]: [ws_web_site_sk#89, ws_promo_sk#90, ws_ext_sales_price#92, ws_net_profit#93, ws_sold_date_sk#94, wr_return_amt#98, wr_net_loss#99]
Input [9]: [ws_item_sk#88, ws_web_site_sk#89, ws_promo_sk#90, ws_ext_sales_price#92, ws_net_profit#93, ws_sold_date_sk#94, wr_return_amt#98, wr_net_loss#99, i_item_sk#102]

(134) ReusedExchange [Reuses operator id: 32]
Output [1]: [p_promo_sk#103]

(135) InputAdapter
Input [1]: [p_promo_sk#103]

(136) InputIteratorTransformer
Input [1]: [p_promo_sk#103]

(137) BroadcastHashJoinExecTransformer
Left keys [1]: [ws_promo_sk#90]
Right keys [1]: [p_promo_sk#103]
Join type: Inner
Join condition: None

(138) ProjectExecTransformer
Output [6]: [ws_web_site_sk#89, ws_ext_sales_price#92, ws_net_profit#93, ws_sold_date_sk#94, wr_return_amt#98, wr_net_loss#99]
Input [8]: [ws_web_site_sk#89, ws_promo_sk#90, ws_ext_sales_price#92, ws_net_profit#93, ws_sold_date_sk#94, wr_return_amt#98, wr_net_loss#99, p_promo_sk#103]

(139) ReusedExchange [Reuses operator id: 206]
Output [1]: [d_date_sk#104]

(140) InputAdapter
Input [1]: [d_date_sk#104]

(141) InputIteratorTransformer
Input [1]: [d_date_sk#104]

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

(143) ProjectExecTransformer
Output [5]: [ws_web_site_sk#89, ws_ext_sales_price#92, ws_net_profit#93, wr_return_amt#98, wr_net_loss#99]
Input [7]: [ws_web_site_sk#89, ws_ext_sales_price#92, ws_net_profit#93, ws_sold_date_sk#94, wr_return_amt#98, wr_net_loss#99, d_date_sk#104]

(144) FileSourceScanExecTransformer parquet spark_catalog.default.web_site
Output [2]: [web_site_sk#105, web_site_id#106]
Batched: true
Location: InMemoryFileIndex [{warehouse_dir}/web_site]
PushedFilters: [IsNotNull(web_site_sk)]
ReadSchema: struct<web_site_sk:int,web_site_id:string>

(145) FilterExecTransformer
Input [2]: [web_site_sk#105, web_site_id#106]
Arguments: isnotnull(web_site_sk#105)

(146) WholeStageCodegenTransformer (37)
Input [2]: [web_site_sk#105, web_site_id#106]
Arguments: false

(147) ColumnarBroadcastExchange
Input [2]: [web_site_sk#105, web_site_id#106]
Arguments: HashedRelationBroadcastMode(List(cast(input[0, int, false] as bigint)),false), [plan_id=15]

(148) InputAdapter
Input [2]: [web_site_sk#105, web_site_id#106]

(149) InputIteratorTransformer
Input [2]: [web_site_sk#105, web_site_id#106]

(150) BroadcastHashJoinExecTransformer
Left keys [1]: [ws_web_site_sk#89]
Right keys [1]: [web_site_sk#105]
Join type: Inner
Join condition: None

(151) ProjectExecTransformer
Output [4]: [web_site_id#106, UnscaledValue(ws_ext_sales_price#92) AS _pre_7#107, coalesce(cast(wr_return_amt#98 as decimal(12,2)), 0.00) AS _pre_8#108, (ws_net_profit#93 - coalesce(cast(wr_net_loss#99 as decimal(12,2)), 0.00)) AS _pre_9#109]
Input [7]: [ws_web_site_sk#89, ws_ext_sales_price#92, ws_net_profit#93, wr_return_amt#98, wr_net_loss#99, web_site_sk#105, web_site_id#106]

(152) FlushableHashAggregateExecTransformer
Input [4]: [web_site_id#106, _pre_7#107, _pre_8#108, _pre_9#109]
Keys [1]: [web_site_id#106]
Functions [3]: [partial_sum(_pre_7#107), partial_sum(_pre_8#108), partial_sum(_pre_9#109)]
Aggregate Attributes [5]: [sum#110, sum#111, isEmpty#112, sum#113, isEmpty#114]
Results [6]: [web_site_id#106, sum#115, sum#116, isEmpty#117, sum#118, isEmpty#119]

(153) ProjectExecTransformer
Output [7]: [hash(web_site_id#106, 42) AS hash_partition_key#120, web_site_id#106, sum#115, sum#116, isEmpty#117, sum#118, isEmpty#119]
Input [6]: [web_site_id#106, sum#115, sum#116, isEmpty#117, sum#118, isEmpty#119]

(154) WholeStageCodegenTransformer (38)
Input [7]: [hash_partition_key#120, web_site_id#106, sum#115, sum#116, isEmpty#117, sum#118, isEmpty#119]
Arguments: false

(155) VeloxResizeBatches
Input [7]: [hash_partition_key#120, web_site_id#106, sum#115, sum#116, isEmpty#117, sum#118, isEmpty#119]
Arguments: 1024, 2147483647, 10485760

(156) ColumnarExchange
Input [7]: [hash_partition_key#120, web_site_id#106, sum#115, sum#116, isEmpty#117, sum#118, isEmpty#119]
Arguments: hashpartitioning(web_site_id#106, 1), ENSURE_REQUIREMENTS, [web_site_id#106, sum#115, sum#116, isEmpty#117, sum#118, isEmpty#119], [plan_id=16], [shuffle_writer_type=hash]

(157) InputAdapter
Input [6]: [web_site_id#106, sum#115, sum#116, isEmpty#117, sum#118, isEmpty#119]

(158) InputIteratorTransformer
Input [6]: [web_site_id#106, sum#115, sum#116, isEmpty#117, sum#118, isEmpty#119]

(159) RegularHashAggregateExecTransformer
Input [6]: [web_site_id#106, sum#115, sum#116, isEmpty#117, sum#118, isEmpty#119]
Keys [1]: [web_site_id#106]
Functions [3]: [sum(UnscaledValue(ws_ext_sales_price#92)), sum(coalesce(cast(wr_return_amt#98 as decimal(12,2)), 0.00)), sum((ws_net_profit#93 - coalesce(cast(wr_net_loss#99 as decimal(12,2)), 0.00)))]
Aggregate Attributes [3]: [sum(UnscaledValue(ws_ext_sales_price#92))#121, sum(coalesce(cast(wr_return_amt#98 as decimal(12,2)), 0.00))#122, sum((ws_net_profit#93 - coalesce(cast(wr_net_loss#99 as decimal(12,2)), 0.00)))#123]
Results [4]: [web_site_id#106, sum(UnscaledValue(ws_ext_sales_price#92))#121, sum(coalesce(cast(wr_return_amt#98 as decimal(12,2)), 0.00))#122, sum((ws_net_profit#93 - coalesce(cast(wr_net_loss#99 as decimal(12,2)), 0.00)))#123]

(160) ProjectExecTransformer
Output [5]: [MakeDecimal(sum(UnscaledValue(ws_ext_sales_price#92))#121,17,2) AS sales#124, sum(coalesce(cast(wr_return_amt#98 as decimal(12,2)), 0.00))#122 AS returns#125, sum((ws_net_profit#93 - coalesce(cast(wr_net_loss#99 as decimal(12,2)), 0.00)))#123 AS profit#126, web channel AS channel#127, concat(web_site, web_site_id#106) AS id#128]
Input [4]: [web_site_id#106, sum(UnscaledValue(ws_ext_sales_price#92))#121, sum(coalesce(cast(wr_return_amt#98 as decimal(12,2)), 0.00))#122, sum((ws_net_profit#93 - coalesce(cast(wr_net_loss#99 as decimal(12,2)), 0.00)))#123]

(161) WholeStageCodegenTransformer (39)
Input [5]: [sales#124, returns#125, profit#126, channel#127, id#128]
Arguments: false

(162) ColumnarUnion
Arguments: UnknownPartitioning(0)

(163) InputAdapter
Input [5]: [sales#42, returns#43, profit#44, channel#45, id#46]

(164) InputIteratorTransformer
Input [5]: [sales#42, returns#43, profit#44, channel#45, id#46]

(165) ExpandExecTransformer
Input [5]: [sales#42, returns#43, profit#44, channel#45, id#46]
Arguments: [[sales#42, returns#43, profit#44, channel#45, id#46, 0], [sales#42, returns#43, profit#44, channel#45, null, 1], [sales#42, returns#43, profit#44, null, null, 3]], [sales#42, returns#43, profit#44, channel#129, id#130, spark_grouping_id#131]

(166) FlushableHashAggregateExecTransformer
Input [6]: [sales#42, returns#43, profit#44, channel#129, id#130, spark_grouping_id#131]
Keys [3]: [channel#129, id#130, spark_grouping_id#131]
Functions [3]: [partial_sum(sales#42), partial_sum(returns#43), partial_sum(profit#44)]
Aggregate Attributes [6]: [sum#132, isEmpty#133, sum#134, isEmpty#135, sum#136, isEmpty#137]
Results [9]: [channel#129, id#130, spark_grouping_id#131, sum#138, isEmpty#139, sum#140, isEmpty#141, sum#142, isEmpty#143]

(167) ProjectExecTransformer
Output [10]: [hash(channel#129, id#130, spark_grouping_id#131, 42) AS hash_partition_key#144, channel#129, id#130, spark_grouping_id#131, sum#138, isEmpty#139, sum#140, isEmpty#141, sum#142, isEmpty#143]
Input [9]: [channel#129, id#130, spark_grouping_id#131, sum#138, isEmpty#139, sum#140, isEmpty#141, sum#142, isEmpty#143]

(168) WholeStageCodegenTransformer (40)
Input [10]: [hash_partition_key#144, channel#129, id#130, spark_grouping_id#131, sum#138, isEmpty#139, sum#140, isEmpty#141, sum#142, isEmpty#143]
Arguments: false

(169) VeloxResizeBatches
Input [10]: [hash_partition_key#144, channel#129, id#130, spark_grouping_id#131, sum#138, isEmpty#139, sum#140, isEmpty#141, sum#142, isEmpty#143]
Arguments: 1024, 2147483647, 10485760

(170) ColumnarExchange
Input [10]: [hash_partition_key#144, channel#129, id#130, spark_grouping_id#131, sum#138, isEmpty#139, sum#140, isEmpty#141, sum#142, isEmpty#143]
Arguments: hashpartitioning(channel#129, id#130, spark_grouping_id#131, 1), ENSURE_REQUIREMENTS, [channel#129, id#130, spark_grouping_id#131, sum#138, isEmpty#139, sum#140, isEmpty#141, sum#142, isEmpty#143], [plan_id=17], [shuffle_writer_type=hash]

(171) InputAdapter
Input [9]: [channel#129, id#130, spark_grouping_id#131, sum#138, isEmpty#139, sum#140, isEmpty#141, sum#142, isEmpty#143]

(172) InputIteratorTransformer
Input [9]: [channel#129, id#130, spark_grouping_id#131, sum#138, isEmpty#139, sum#140, isEmpty#141, sum#142, isEmpty#143]

(173) RegularHashAggregateExecTransformer
Input [9]: [channel#129, id#130, spark_grouping_id#131, sum#138, isEmpty#139, sum#140, isEmpty#141, sum#142, isEmpty#143]
Keys [3]: [channel#129, id#130, spark_grouping_id#131]
Functions [3]: [sum(sales#42), sum(returns#43), sum(profit#44)]
Aggregate Attributes [3]: [sum(sales#42)#145, sum(returns#43)#146, sum(profit#44)#147]
Results [6]: [channel#129, id#130, spark_grouping_id#131, sum(sales#42)#145, sum(returns#43)#146, sum(profit#44)#147]

(174) ProjectExecTransformer
Output [5]: [channel#129, id#130, sum(sales#42)#145 AS sales#148, sum(returns#43)#146 AS returns#149, sum(profit#44)#147 AS profit#150]
Input [6]: [channel#129, id#130, spark_grouping_id#131, sum(sales#42)#145, sum(returns#43)#146, sum(profit#44)#147]

(175) WholeStageCodegenTransformer (41)
Input [5]: [channel#129, id#130, sales#148, returns#149, profit#150]
Arguments: false

(176) TakeOrderedAndProjectExecTransformer
Input [5]: [channel#129, id#130, sales#148, returns#149, profit#150]
Arguments: 100, [channel#129 ASC NULLS FIRST, id#130 ASC NULLS FIRST], [channel#129, id#130, sales#148, returns#149, profit#150], 0

(177) VeloxColumnarToRow
Input [5]: [channel#129, id#130, sales#148, returns#149, profit#150]

===== Subqueries =====

Subquery:1 Hosting operator id = 2 Hosting Expression = Subquery scalar-subquery#9, [id=#1]
VeloxColumnarToRow (189)
+- ^ RegularHashAggregateExecTransformer (187)
   +- ^ InputIteratorTransformer (186)
      +- ColumnarExchange (184)
         +- VeloxResizeBatches (183)
            +- ^ FlushableHashAggregateExecTransformer (181)
               +- ^ ProjectExecTransformer (180)
                  +- ^ FilterExecTransformer (179)
                     +- ^ FileSourceScanExecTransformer parquet spark_catalog.default.item (178)


(178) FileSourceScanExecTransformer parquet spark_catalog.default.item
Output [2]: [i_item_sk#18, i_current_price#19]
Batched: true
Location: InMemoryFileIndex [{warehouse_dir}/item]
PushedFilters: [IsNotNull(i_current_price), GreaterThan(i_current_price,50.00), IsNotNull(i_item_sk)]
ReadSchema: struct<i_item_sk:int,i_current_price:decimal(7,2)>

(179) FilterExecTransformer
Input [2]: [i_item_sk#18, i_current_price#19]
Arguments: ((isnotnull(i_current_price#19) AND (i_current_price#19 > 50.00)) AND isnotnull(i_item_sk#18))

(180) ProjectExecTransformer
Output [1]: [xxhash64(i_item_sk#18, 42) AS _pre_10#151]
Input [2]: [i_item_sk#18, i_current_price#19]

(181) FlushableHashAggregateExecTransformer
Input [1]: [_pre_10#151]
Keys: []
Functions [1]: [partial_velox_bloom_filter_agg(_pre_10#151, 101823, 1521109, 0, 0)]
Aggregate Attributes [1]: [buf#152]
Results [1]: [buf#153]

(182) WholeStageCodegenTransformer (1)
Input [1]: [buf#153]
Arguments: false

(183) VeloxResizeBatches
Input [1]: [buf#153]
Arguments: 1024, 2147483647, 10485760

(184) ColumnarExchange
Input [1]: [buf#153]
Arguments: SinglePartition, ENSURE_REQUIREMENTS, [plan_id=18], [shuffle_writer_type=hash]

(185) InputAdapter
Input [1]: [buf#153]

(186) InputIteratorTransformer
Input [1]: [buf#153]

(187) RegularHashAggregateExecTransformer
Input [1]: [buf#153]
Keys: []
Functions [1]: [velox_bloom_filter_agg(xxhash64(i_item_sk#18, 42), 101823, 1521109, 0, 0)]
Aggregate Attributes [1]: [bloom_filter_agg(xxhash64(i_item_sk#18, 42), 101823, 1521109, 0, 0)#154]
Results [1]: [bloom_filter_agg(xxhash64(i_item_sk#18, 42), 101823, 1521109, 0, 0)#154 AS bloomFilter#155]

(188) WholeStageCodegenTransformer (2)
Input [1]: [bloomFilter#155]
Arguments: false

(189) VeloxColumnarToRow
Input [1]: [bloomFilter#155]

Subquery:2 Hosting operator id = 2 Hosting Expression = Subquery scalar-subquery#10, [id=#2]
VeloxColumnarToRow (201)
+- ^ RegularHashAggregateExecTransformer (199)
   +- ^ InputIteratorTransformer (198)
      +- ColumnarExchange (196)
         +- VeloxResizeBatches (195)
            +- ^ FlushableHashAggregateExecTransformer (193)
               +- ^ ProjectExecTransformer (192)
                  +- ^ FilterExecTransformer (191)
                     +- ^ FileSourceScanExecTransformer parquet spark_catalog.default.promotion (190)


(190) FileSourceScanExecTransformer parquet spark_catalog.default.promotion
Output [2]: [p_promo_sk#20, p_channel_tv#21]
Batched: true
Location: InMemoryFileIndex [{warehouse_dir}/promotion]
PushedFilters: [IsNotNull(p_channel_tv), EqualTo(p_channel_tv,N), IsNotNull(p_promo_sk)]
ReadSchema: struct<p_promo_sk:int,p_channel_tv:string>

(191) FilterExecTransformer
Input [2]: [p_promo_sk#20, p_channel_tv#21]
Arguments: ((isnotnull(p_channel_tv#21) AND (p_channel_tv#21 = N)) AND isnotnull(p_promo_sk#20))

(192) ProjectExecTransformer
Output [1]: [xxhash64(p_promo_sk#20, 42) AS _pre_11#156]
Input [2]: [p_promo_sk#20, p_channel_tv#21]

(193) FlushableHashAggregateExecTransformer
Input [1]: [_pre_11#156]
Keys: []
Functions [1]: [partial_velox_bloom_filter_agg(_pre_11#156, 986, 24246, 0, 0)]
Aggregate Attributes [1]: [buf#157]
Results [1]: [buf#158]

(194) WholeStageCodegenTransformer (3)
Input [1]: [buf#158]
Arguments: false

(195) VeloxResizeBatches
Input [1]: [buf#158]
Arguments: 1024, 2147483647, 10485760

(196) ColumnarExchange
Input [1]: [buf#158]
Arguments: SinglePartition, ENSURE_REQUIREMENTS, [plan_id=19], [shuffle_writer_type=hash]

(197) InputAdapter
Input [1]: [buf#158]

(198) InputIteratorTransformer
Input [1]: [buf#158]

(199) RegularHashAggregateExecTransformer
Input [1]: [buf#158]
Keys: []
Functions [1]: [velox_bloom_filter_agg(xxhash64(p_promo_sk#20, 42), 986, 24246, 0, 0)]
Aggregate Attributes [1]: [bloom_filter_agg(xxhash64(p_promo_sk#20, 42), 986, 24246, 0, 0)#159]
Results [1]: [bloom_filter_agg(xxhash64(p_promo_sk#20, 42), 986, 24246, 0, 0)#159 AS bloomFilter#160]

(200) WholeStageCodegenTransformer (4)
Input [1]: [bloomFilter#160]
Arguments: false

(201) VeloxColumnarToRow
Input [1]: [bloomFilter#160]

Subquery:3 Hosting operator id = 1 Hosting Expression = ss_sold_date_sk#7 IN dynamicpruning#8
ColumnarBroadcastExchange (206)
+- ^ ProjectExecTransformer (204)
   +- ^ FilterExecTransformer (203)
      +- ^ FileSourceScanExecTransformer parquet spark_catalog.default.date_dim (202)


(202) FileSourceScanExecTransformer parquet spark_catalog.default.date_dim
Output [2]: [d_date_sk#22, d_date#161]
Batched: true
Location: InMemoryFileIndex [{warehouse_dir}/date_dim]
PushedFilters: [IsNotNull(d_date), GreaterThanOrEqual(d_date,2000-08-23), LessThanOrEqual(d_date,2000-09-22), IsNotNull(d_date_sk)]
ReadSchema: struct<d_date_sk:int,d_date:date>

(203) FilterExecTransformer
Input [2]: [d_date_sk#22, d_date#161]
Arguments: (((isnotnull(d_date#161) AND (d_date#161 >= 2000-08-23)) AND (d_date#161 <= 2000-09-22)) AND isnotnull(d_date_sk#22))

(204) ProjectExecTransformer
Output [1]: [d_date_sk#22]
Input [2]: [d_date_sk#22, d_date#161]

(205) WholeStageCodegenTransformer (5)
Input [1]: [d_date_sk#22]
Arguments: false

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

Subquery:4 Hosting operator id = 1 Hosting Expression = Subquery scalar-subquery#9, [id=#1]
VeloxColumnarToRow (189)
+- ^ RegularHashAggregateExecTransformer (187)
   +- ^ InputIteratorTransformer (186)
      +- ColumnarExchange (184)
         +- VeloxResizeBatches (183)
            +- ^ FlushableHashAggregateExecTransformer (181)
               +- ^ ProjectExecTransformer (180)
                  +- ^ FilterExecTransformer (179)
                     +- ^ FileSourceScanExecTransformer parquet spark_catalog.default.item (178)


Subquery:5 Hosting operator id = 1 Hosting Expression = Subquery scalar-subquery#10, [id=#2]
VeloxColumnarToRow (201)
+- ^ RegularHashAggregateExecTransformer (199)
   +- ^ InputIteratorTransformer (198)
      +- ColumnarExchange (196)
         +- VeloxResizeBatches (195)
            +- ^ FlushableHashAggregateExecTransformer (193)
               +- ^ ProjectExecTransformer (192)
                  +- ^ FilterExecTransformer (191)
                     +- ^ FileSourceScanExecTransformer parquet spark_catalog.default.promotion (190)


Subquery:6 Hosting operator id = 61 Hosting Expression = ReusedSubquery Subquery scalar-subquery#9, [id=#1]

Subquery:7 Hosting operator id = 61 Hosting Expression = ReusedSubquery Subquery scalar-subquery#10, [id=#2]

Subquery:8 Hosting operator id = 60 Hosting Expression = cs_sold_date_sk#53 IN dynamicpruning#8

Subquery:9 Hosting operator id = 60 Hosting Expression = ReusedSubquery Subquery scalar-subquery#9, [id=#1]

Subquery:10 Hosting operator id = 60 Hosting Expression = ReusedSubquery Subquery scalar-subquery#10, [id=#2]

Subquery:11 Hosting operator id = 112 Hosting Expression = ReusedSubquery Subquery scalar-subquery#9, [id=#1]

Subquery:12 Hosting operator id = 112 Hosting Expression = ReusedSubquery Subquery scalar-subquery#10, [id=#2]

Subquery:13 Hosting operator id = 111 Hosting Expression = ws_sold_date_sk#94 IN dynamicpruning#8

Subquery:14 Hosting operator id = 111 Hosting Expression = ReusedSubquery Subquery scalar-subquery#9, [id=#1]

Subquery:15 Hosting operator id = 111 Hosting Expression = ReusedSubquery Subquery scalar-subquery#10, [id=#2]


