== Physical Plan ==
TakeOrderedAndProject (77)
+- * HashAggregate (76)
   +- Exchange (75)
      +- * HashAggregate (74)
         +- Union (73)
            :- * Project (26)
            :  +- * Filter (25)
            :     +- Window (24)
            :        +- * Sort (23)
            :           +- Window (22)
            :              +- * Sort (21)
            :                 +- Exchange (20)
            :                    +- * HashAggregate (19)
            :                       +- Exchange (18)
            :                          +- * HashAggregate (17)
            :                             +- * ColumnarToRow (16)
            :                                +- CometProject (15)
            :                                   +- CometBroadcastHashJoin (14)
            :                                      :- CometProject (9)
            :                                      :  +- CometBroadcastHashJoin (8)
            :                                      :     :- CometBroadcastExchange (4)
            :                                      :     :  +- CometProject (3)
            :                                      :     :     +- CometFilter (2)
            :                                      :     :        +- CometScan parquet spark_catalog.default.web_sales (1)
            :                                      :     +- CometProject (7)
            :                                      :        +- CometFilter (6)
            :                                      :           +- CometScan parquet spark_catalog.default.web_returns (5)
            :                                      +- CometBroadcastExchange (13)
            :                                         +- CometProject (12)
            :                                            +- CometFilter (11)
            :                                               +- CometScan parquet spark_catalog.default.date_dim (10)
            :- * Project (49)
            :  +- * Filter (48)
            :     +- Window (47)
            :        +- * Sort (46)
            :           +- Window (45)
            :              +- * Sort (44)
            :                 +- Exchange (43)
            :                    +- * HashAggregate (42)
            :                       +- Exchange (41)
            :                          +- * HashAggregate (40)
            :                             +- * ColumnarToRow (39)
            :                                +- CometProject (38)
            :                                   +- CometBroadcastHashJoin (37)
            :                                      :- CometProject (35)
            :                                      :  +- CometBroadcastHashJoin (34)
            :                                      :     :- CometBroadcastExchange (30)
            :                                      :     :  +- CometProject (29)
            :                                      :     :     +- CometFilter (28)
            :                                      :     :        +- CometScan parquet spark_catalog.default.catalog_sales (27)
            :                                      :     +- CometProject (33)
            :                                      :        +- CometFilter (32)
            :                                      :           +- CometScan parquet spark_catalog.default.catalog_returns (31)
            :                                      +- ReusedExchange (36)
            +- * Project (72)
               +- * Filter (71)
                  +- Window (70)
                     +- * Sort (69)
                        +- Window (68)
                           +- * Sort (67)
                              +- Exchange (66)
                                 +- * HashAggregate (65)
                                    +- Exchange (64)
                                       +- * HashAggregate (63)
                                          +- * ColumnarToRow (62)
                                             +- CometProject (61)
                                                +- CometBroadcastHashJoin (60)
                                                   :- CometProject (58)
                                                   :  +- CometBroadcastHashJoin (57)
                                                   :     :- CometBroadcastExchange (53)
                                                   :     :  +- CometProject (52)
                                                   :     :     +- CometFilter (51)
                                                   :     :        +- CometScan parquet spark_catalog.default.store_sales (50)
                                                   :     +- CometProject (56)
                                                   :        +- CometFilter (55)
                                                   :           +- CometScan parquet spark_catalog.default.store_returns (54)
                                                   +- ReusedExchange (59)


(1) CometScan parquet spark_catalog.default.web_sales
Output [6]: [ws_item_sk#1, ws_order_number#2, ws_quantity#3, ws_net_paid#4, ws_net_profit#5, ws_sold_date_sk#6]
Batched: true
Location: InMemoryFileIndex []
PartitionFilters: [isnotnull(ws_sold_date_sk#6), dynamicpruningexpression(ws_sold_date_sk#6 IN dynamicpruning#7)]
PushedFilters: [IsNotNull(ws_net_profit), IsNotNull(ws_net_paid), IsNotNull(ws_quantity), GreaterThan(ws_net_profit,1.00), GreaterThan(ws_net_paid,0.00), GreaterThan(ws_quantity,0), IsNotNull(ws_order_number), IsNotNull(ws_item_sk)]
ReadSchema: struct<ws_item_sk:int,ws_order_number:int,ws_quantity:int,ws_net_paid:decimal(7,2),ws_net_profit:decimal(7,2)>

(2) CometFilter
Input [6]: [ws_item_sk#1, ws_order_number#2, ws_quantity#3, ws_net_paid#4, ws_net_profit#5, ws_sold_date_sk#6]
Condition : (((((((isnotnull(ws_net_profit#5) AND isnotnull(ws_net_paid#4)) AND isnotnull(ws_quantity#3)) AND (ws_net_profit#5 > 1.00)) AND (ws_net_paid#4 > 0.00)) AND (ws_quantity#3 > 0)) AND isnotnull(ws_order_number#2)) AND isnotnull(ws_item_sk#1))

(3) CometProject
Input [6]: [ws_item_sk#1, ws_order_number#2, ws_quantity#3, ws_net_paid#4, ws_net_profit#5, ws_sold_date_sk#6]
Arguments: [ws_item_sk#1, ws_order_number#2, ws_quantity#3, ws_net_paid#4, ws_sold_date_sk#6], [ws_item_sk#1, ws_order_number#2, ws_quantity#3, ws_net_paid#4, ws_sold_date_sk#6]

(4) CometBroadcastExchange
Input [5]: [ws_item_sk#1, ws_order_number#2, ws_quantity#3, ws_net_paid#4, ws_sold_date_sk#6]
Arguments: [ws_item_sk#1, ws_order_number#2, ws_quantity#3, ws_net_paid#4, ws_sold_date_sk#6]

(5) CometScan parquet spark_catalog.default.web_returns
Output [5]: [wr_item_sk#8, wr_order_number#9, wr_return_quantity#10, wr_return_amt#11, wr_returned_date_sk#12]
Batched: true
Location [not included in comparison]/{warehouse_dir}/web_returns]
PushedFilters: [IsNotNull(wr_return_amt), GreaterThan(wr_return_amt,10000.00), IsNotNull(wr_order_number), IsNotNull(wr_item_sk)]
ReadSchema: struct<wr_item_sk:int,wr_order_number:int,wr_return_quantity:int,wr_return_amt:decimal(7,2)>

(6) CometFilter
Input [5]: [wr_item_sk#8, wr_order_number#9, wr_return_quantity#10, wr_return_amt#11, wr_returned_date_sk#12]
Condition : (((isnotnull(wr_return_amt#11) AND (wr_return_amt#11 > 10000.00)) AND isnotnull(wr_order_number#9)) AND isnotnull(wr_item_sk#8))

(7) CometProject
Input [5]: [wr_item_sk#8, wr_order_number#9, wr_return_quantity#10, wr_return_amt#11, wr_returned_date_sk#12]
Arguments: [wr_item_sk#8, wr_order_number#9, wr_return_quantity#10, wr_return_amt#11], [wr_item_sk#8, wr_order_number#9, wr_return_quantity#10, wr_return_amt#11]

(8) CometBroadcastHashJoin
Left output [5]: [ws_item_sk#1, ws_order_number#2, ws_quantity#3, ws_net_paid#4, ws_sold_date_sk#6]
Right output [4]: [wr_item_sk#8, wr_order_number#9, wr_return_quantity#10, wr_return_amt#11]
Arguments: [ws_order_number#2, ws_item_sk#1], [wr_order_number#9, wr_item_sk#8], Inner, BuildLeft

(9) CometProject
Input [9]: [ws_item_sk#1, ws_order_number#2, ws_quantity#3, ws_net_paid#4, ws_sold_date_sk#6, wr_item_sk#8, wr_order_number#9, wr_return_quantity#10, wr_return_amt#11]
Arguments: [ws_item_sk#1, ws_quantity#3, ws_net_paid#4, ws_sold_date_sk#6, wr_return_quantity#10, wr_return_amt#11], [ws_item_sk#1, ws_quantity#3, ws_net_paid#4, ws_sold_date_sk#6, wr_return_quantity#10, wr_return_amt#11]

(10) CometScan parquet spark_catalog.default.date_dim
Output [3]: [d_date_sk#13, d_year#14, d_moy#15]
Batched: true
Location [not included in comparison]/{warehouse_dir}/date_dim]
PushedFilters: [IsNotNull(d_year), IsNotNull(d_moy), EqualTo(d_year,2001), EqualTo(d_moy,12), IsNotNull(d_date_sk)]
ReadSchema: struct<d_date_sk:int,d_year:int,d_moy:int>

(11) CometFilter
Input [3]: [d_date_sk#13, d_year#14, d_moy#15]
Condition : ((((isnotnull(d_year#14) AND isnotnull(d_moy#15)) AND (d_year#14 = 2001)) AND (d_moy#15 = 12)) AND isnotnull(d_date_sk#13))

(12) CometProject
Input [3]: [d_date_sk#13, d_year#14, d_moy#15]
Arguments: [d_date_sk#13], [d_date_sk#13]

(13) CometBroadcastExchange
Input [1]: [d_date_sk#13]
Arguments: [d_date_sk#13]

(14) CometBroadcastHashJoin
Left output [6]: [ws_item_sk#1, ws_quantity#3, ws_net_paid#4, ws_sold_date_sk#6, wr_return_quantity#10, wr_return_amt#11]
Right output [1]: [d_date_sk#13]
Arguments: [ws_sold_date_sk#6], [d_date_sk#13], Inner, BuildRight

(15) CometProject
Input [7]: [ws_item_sk#1, ws_quantity#3, ws_net_paid#4, ws_sold_date_sk#6, wr_return_quantity#10, wr_return_amt#11, d_date_sk#13]
Arguments: [ws_item_sk#1, ws_quantity#3, ws_net_paid#4, wr_return_quantity#10, wr_return_amt#11], [ws_item_sk#1, ws_quantity#3, ws_net_paid#4, wr_return_quantity#10, wr_return_amt#11]

(16) ColumnarToRow [codegen id : 1]
Input [5]: [ws_item_sk#1, ws_quantity#3, ws_net_paid#4, wr_return_quantity#10, wr_return_amt#11]

(17) HashAggregate [codegen id : 1]
Input [5]: [ws_item_sk#1, ws_quantity#3, ws_net_paid#4, wr_return_quantity#10, wr_return_amt#11]
Keys [1]: [ws_item_sk#1]
Functions [4]: [partial_sum(coalesce(wr_return_quantity#10, 0)), partial_sum(coalesce(ws_quantity#3, 0)), partial_sum(coalesce(cast(wr_return_amt#11 as decimal(12,2)), 0.00)), partial_sum(coalesce(cast(ws_net_paid#4 as decimal(12,2)), 0.00))]
Aggregate Attributes [6]: [sum#16, sum#17, sum#18, isEmpty#19, sum#20, isEmpty#21]
Results [7]: [ws_item_sk#1, sum#22, sum#23, sum#24, isEmpty#25, sum#26, isEmpty#27]

(18) Exchange
Input [7]: [ws_item_sk#1, sum#22, sum#23, sum#24, isEmpty#25, sum#26, isEmpty#27]
Arguments: hashpartitioning(ws_item_sk#1, 5), ENSURE_REQUIREMENTS, [plan_id=1]

(19) HashAggregate [codegen id : 2]
Input [7]: [ws_item_sk#1, sum#22, sum#23, sum#24, isEmpty#25, sum#26, isEmpty#27]
Keys [1]: [ws_item_sk#1]
Functions [4]: [sum(coalesce(wr_return_quantity#10, 0)), sum(coalesce(ws_quantity#3, 0)), sum(coalesce(cast(wr_return_amt#11 as decimal(12,2)), 0.00)), sum(coalesce(cast(ws_net_paid#4 as decimal(12,2)), 0.00))]
Aggregate Attributes [4]: [sum(coalesce(wr_return_quantity#10, 0))#28, sum(coalesce(ws_quantity#3, 0))#29, sum(coalesce(cast(wr_return_amt#11 as decimal(12,2)), 0.00))#30, sum(coalesce(cast(ws_net_paid#4 as decimal(12,2)), 0.00))#31]
Results [3]: [ws_item_sk#1 AS item#32, (cast(sum(coalesce(wr_return_quantity#10, 0))#28 as decimal(15,4)) / cast(sum(coalesce(ws_quantity#3, 0))#29 as decimal(15,4))) AS return_ratio#33, (cast(sum(coalesce(cast(wr_return_amt#11 as decimal(12,2)), 0.00))#30 as decimal(15,4)) / cast(sum(coalesce(cast(ws_net_paid#4 as decimal(12,2)), 0.00))#31 as decimal(15,4))) AS currency_ratio#34]

(20) Exchange
Input [3]: [item#32, return_ratio#33, currency_ratio#34]
Arguments: SinglePartition, ENSURE_REQUIREMENTS, [plan_id=2]

(21) Sort [codegen id : 3]
Input [3]: [item#32, return_ratio#33, currency_ratio#34]
Arguments: [return_ratio#33 ASC NULLS FIRST], false, 0

(22) Window
Input [3]: [item#32, return_ratio#33, currency_ratio#34]
Arguments: [rank(return_ratio#33) windowspecdefinition(return_ratio#33 ASC NULLS FIRST, specifiedwindowframe(RowFrame, unboundedpreceding$(), currentrow$())) AS return_rank#35], [return_ratio#33 ASC NULLS FIRST]

(23) Sort [codegen id : 4]
Input [4]: [item#32, return_ratio#33, currency_ratio#34, return_rank#35]
Arguments: [currency_ratio#34 ASC NULLS FIRST], false, 0

(24) Window
Input [4]: [item#32, return_ratio#33, currency_ratio#34, return_rank#35]
Arguments: [rank(currency_ratio#34) windowspecdefinition(currency_ratio#34 ASC NULLS FIRST, specifiedwindowframe(RowFrame, unboundedpreceding$(), currentrow$())) AS currency_rank#36], [currency_ratio#34 ASC NULLS FIRST]

(25) Filter [codegen id : 5]
Input [5]: [item#32, return_ratio#33, currency_ratio#34, return_rank#35, currency_rank#36]
Condition : ((return_rank#35 <= 10) OR (currency_rank#36 <= 10))

(26) Project [codegen id : 5]
Output [5]: [web AS channel#37, item#32, return_ratio#33, return_rank#35, currency_rank#36]
Input [5]: [item#32, return_ratio#33, currency_ratio#34, return_rank#35, currency_rank#36]

(27) CometScan parquet spark_catalog.default.catalog_sales
Output [6]: [cs_item_sk#38, cs_order_number#39, cs_quantity#40, cs_net_paid#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#44)]
PushedFilters: [IsNotNull(cs_net_profit), IsNotNull(cs_net_paid), IsNotNull(cs_quantity), GreaterThan(cs_net_profit,1.00), GreaterThan(cs_net_paid,0.00), GreaterThan(cs_quantity,0), IsNotNull(cs_order_number), IsNotNull(cs_item_sk)]
ReadSchema: struct<cs_item_sk:int,cs_order_number:int,cs_quantity:int,cs_net_paid:decimal(7,2),cs_net_profit:decimal(7,2)>

(28) CometFilter
Input [6]: [cs_item_sk#38, cs_order_number#39, cs_quantity#40, cs_net_paid#41, cs_net_profit#42, cs_sold_date_sk#43]
Condition : (((((((isnotnull(cs_net_profit#42) AND isnotnull(cs_net_paid#41)) AND isnotnull(cs_quantity#40)) AND (cs_net_profit#42 > 1.00)) AND (cs_net_paid#41 > 0.00)) AND (cs_quantity#40 > 0)) AND isnotnull(cs_order_number#39)) AND isnotnull(cs_item_sk#38))

(29) CometProject
Input [6]: [cs_item_sk#38, cs_order_number#39, cs_quantity#40, cs_net_paid#41, cs_net_profit#42, cs_sold_date_sk#43]
Arguments: [cs_item_sk#38, cs_order_number#39, cs_quantity#40, cs_net_paid#41, cs_sold_date_sk#43], [cs_item_sk#38, cs_order_number#39, cs_quantity#40, cs_net_paid#41, cs_sold_date_sk#43]

(30) CometBroadcastExchange
Input [5]: [cs_item_sk#38, cs_order_number#39, cs_quantity#40, cs_net_paid#41, cs_sold_date_sk#43]
Arguments: [cs_item_sk#38, cs_order_number#39, cs_quantity#40, cs_net_paid#41, cs_sold_date_sk#43]

(31) CometScan parquet spark_catalog.default.catalog_returns
Output [5]: [cr_item_sk#45, cr_order_number#46, cr_return_quantity#47, cr_return_amount#48, cr_returned_date_sk#49]
Batched: true
Location [not included in comparison]/{warehouse_dir}/catalog_returns]
PushedFilters: [IsNotNull(cr_return_amount), GreaterThan(cr_return_amount,10000.00), IsNotNull(cr_order_number), IsNotNull(cr_item_sk)]
ReadSchema: struct<cr_item_sk:int,cr_order_number:int,cr_return_quantity:int,cr_return_amount:decimal(7,2)>

(32) CometFilter
Input [5]: [cr_item_sk#45, cr_order_number#46, cr_return_quantity#47, cr_return_amount#48, cr_returned_date_sk#49]
Condition : (((isnotnull(cr_return_amount#48) AND (cr_return_amount#48 > 10000.00)) AND isnotnull(cr_order_number#46)) AND isnotnull(cr_item_sk#45))

(33) CometProject
Input [5]: [cr_item_sk#45, cr_order_number#46, cr_return_quantity#47, cr_return_amount#48, cr_returned_date_sk#49]
Arguments: [cr_item_sk#45, cr_order_number#46, cr_return_quantity#47, cr_return_amount#48], [cr_item_sk#45, cr_order_number#46, cr_return_quantity#47, cr_return_amount#48]

(34) CometBroadcastHashJoin
Left output [5]: [cs_item_sk#38, cs_order_number#39, cs_quantity#40, cs_net_paid#41, cs_sold_date_sk#43]
Right output [4]: [cr_item_sk#45, cr_order_number#46, cr_return_quantity#47, cr_return_amount#48]
Arguments: [cs_order_number#39, cs_item_sk#38], [cr_order_number#46, cr_item_sk#45], Inner, BuildLeft

(35) CometProject
Input [9]: [cs_item_sk#38, cs_order_number#39, cs_quantity#40, cs_net_paid#41, cs_sold_date_sk#43, cr_item_sk#45, cr_order_number#46, cr_return_quantity#47, cr_return_amount#48]
Arguments: [cs_item_sk#38, cs_quantity#40, cs_net_paid#41, cs_sold_date_sk#43, cr_return_quantity#47, cr_return_amount#48], [cs_item_sk#38, cs_quantity#40, cs_net_paid#41, cs_sold_date_sk#43, cr_return_quantity#47, cr_return_amount#48]

(36) ReusedExchange [Reuses operator id: 13]
Output [1]: [d_date_sk#50]

(37) CometBroadcastHashJoin
Left output [6]: [cs_item_sk#38, cs_quantity#40, cs_net_paid#41, cs_sold_date_sk#43, cr_return_quantity#47, cr_return_amount#48]
Right output [1]: [d_date_sk#50]
Arguments: [cs_sold_date_sk#43], [d_date_sk#50], Inner, BuildRight

(38) CometProject
Input [7]: [cs_item_sk#38, cs_quantity#40, cs_net_paid#41, cs_sold_date_sk#43, cr_return_quantity#47, cr_return_amount#48, d_date_sk#50]
Arguments: [cs_item_sk#38, cs_quantity#40, cs_net_paid#41, cr_return_quantity#47, cr_return_amount#48], [cs_item_sk#38, cs_quantity#40, cs_net_paid#41, cr_return_quantity#47, cr_return_amount#48]

(39) ColumnarToRow [codegen id : 6]
Input [5]: [cs_item_sk#38, cs_quantity#40, cs_net_paid#41, cr_return_quantity#47, cr_return_amount#48]

(40) HashAggregate [codegen id : 6]
Input [5]: [cs_item_sk#38, cs_quantity#40, cs_net_paid#41, cr_return_quantity#47, cr_return_amount#48]
Keys [1]: [cs_item_sk#38]
Functions [4]: [partial_sum(coalesce(cr_return_quantity#47, 0)), partial_sum(coalesce(cs_quantity#40, 0)), partial_sum(coalesce(cast(cr_return_amount#48 as decimal(12,2)), 0.00)), partial_sum(coalesce(cast(cs_net_paid#41 as decimal(12,2)), 0.00))]
Aggregate Attributes [6]: [sum#51, sum#52, sum#53, isEmpty#54, sum#55, isEmpty#56]
Results [7]: [cs_item_sk#38, sum#57, sum#58, sum#59, isEmpty#60, sum#61, isEmpty#62]

(41) Exchange
Input [7]: [cs_item_sk#38, sum#57, sum#58, sum#59, isEmpty#60, sum#61, isEmpty#62]
Arguments: hashpartitioning(cs_item_sk#38, 5), ENSURE_REQUIREMENTS, [plan_id=3]

(42) HashAggregate [codegen id : 7]
Input [7]: [cs_item_sk#38, sum#57, sum#58, sum#59, isEmpty#60, sum#61, isEmpty#62]
Keys [1]: [cs_item_sk#38]
Functions [4]: [sum(coalesce(cr_return_quantity#47, 0)), sum(coalesce(cs_quantity#40, 0)), sum(coalesce(cast(cr_return_amount#48 as decimal(12,2)), 0.00)), sum(coalesce(cast(cs_net_paid#41 as decimal(12,2)), 0.00))]
Aggregate Attributes [4]: [sum(coalesce(cr_return_quantity#47, 0))#63, sum(coalesce(cs_quantity#40, 0))#64, sum(coalesce(cast(cr_return_amount#48 as decimal(12,2)), 0.00))#65, sum(coalesce(cast(cs_net_paid#41 as decimal(12,2)), 0.00))#66]
Results [3]: [cs_item_sk#38 AS item#67, (cast(sum(coalesce(cr_return_quantity#47, 0))#63 as decimal(15,4)) / cast(sum(coalesce(cs_quantity#40, 0))#64 as decimal(15,4))) AS return_ratio#68, (cast(sum(coalesce(cast(cr_return_amount#48 as decimal(12,2)), 0.00))#65 as decimal(15,4)) / cast(sum(coalesce(cast(cs_net_paid#41 as decimal(12,2)), 0.00))#66 as decimal(15,4))) AS currency_ratio#69]

(43) Exchange
Input [3]: [item#67, return_ratio#68, currency_ratio#69]
Arguments: SinglePartition, ENSURE_REQUIREMENTS, [plan_id=4]

(44) Sort [codegen id : 8]
Input [3]: [item#67, return_ratio#68, currency_ratio#69]
Arguments: [return_ratio#68 ASC NULLS FIRST], false, 0

(45) Window
Input [3]: [item#67, return_ratio#68, currency_ratio#69]
Arguments: [rank(return_ratio#68) windowspecdefinition(return_ratio#68 ASC NULLS FIRST, specifiedwindowframe(RowFrame, unboundedpreceding$(), currentrow$())) AS return_rank#70], [return_ratio#68 ASC NULLS FIRST]

(46) Sort [codegen id : 9]
Input [4]: [item#67, return_ratio#68, currency_ratio#69, return_rank#70]
Arguments: [currency_ratio#69 ASC NULLS FIRST], false, 0

(47) Window
Input [4]: [item#67, return_ratio#68, currency_ratio#69, return_rank#70]
Arguments: [rank(currency_ratio#69) windowspecdefinition(currency_ratio#69 ASC NULLS FIRST, specifiedwindowframe(RowFrame, unboundedpreceding$(), currentrow$())) AS currency_rank#71], [currency_ratio#69 ASC NULLS FIRST]

(48) Filter [codegen id : 10]
Input [5]: [item#67, return_ratio#68, currency_ratio#69, return_rank#70, currency_rank#71]
Condition : ((return_rank#70 <= 10) OR (currency_rank#71 <= 10))

(49) Project [codegen id : 10]
Output [5]: [catalog AS channel#72, item#67, return_ratio#68, return_rank#70, currency_rank#71]
Input [5]: [item#67, return_ratio#68, currency_ratio#69, return_rank#70, currency_rank#71]

(50) CometScan parquet spark_catalog.default.store_sales
Output [6]: [ss_item_sk#73, ss_ticket_number#74, ss_quantity#75, ss_net_paid#76, ss_net_profit#77, ss_sold_date_sk#78]
Batched: true
Location: InMemoryFileIndex []
PartitionFilters: [isnotnull(ss_sold_date_sk#78), dynamicpruningexpression(ss_sold_date_sk#78 IN dynamicpruning#79)]
PushedFilters: [IsNotNull(ss_net_profit), IsNotNull(ss_net_paid), IsNotNull(ss_quantity), GreaterThan(ss_net_profit,1.00), GreaterThan(ss_net_paid,0.00), GreaterThan(ss_quantity,0), IsNotNull(ss_ticket_number), IsNotNull(ss_item_sk)]
ReadSchema: struct<ss_item_sk:int,ss_ticket_number:int,ss_quantity:int,ss_net_paid:decimal(7,2),ss_net_profit:decimal(7,2)>

(51) CometFilter
Input [6]: [ss_item_sk#73, ss_ticket_number#74, ss_quantity#75, ss_net_paid#76, ss_net_profit#77, ss_sold_date_sk#78]
Condition : (((((((isnotnull(ss_net_profit#77) AND isnotnull(ss_net_paid#76)) AND isnotnull(ss_quantity#75)) AND (ss_net_profit#77 > 1.00)) AND (ss_net_paid#76 > 0.00)) AND (ss_quantity#75 > 0)) AND isnotnull(ss_ticket_number#74)) AND isnotnull(ss_item_sk#73))

(52) CometProject
Input [6]: [ss_item_sk#73, ss_ticket_number#74, ss_quantity#75, ss_net_paid#76, ss_net_profit#77, ss_sold_date_sk#78]
Arguments: [ss_item_sk#73, ss_ticket_number#74, ss_quantity#75, ss_net_paid#76, ss_sold_date_sk#78], [ss_item_sk#73, ss_ticket_number#74, ss_quantity#75, ss_net_paid#76, ss_sold_date_sk#78]

(53) CometBroadcastExchange
Input [5]: [ss_item_sk#73, ss_ticket_number#74, ss_quantity#75, ss_net_paid#76, ss_sold_date_sk#78]
Arguments: [ss_item_sk#73, ss_ticket_number#74, ss_quantity#75, ss_net_paid#76, ss_sold_date_sk#78]

(54) CometScan parquet spark_catalog.default.store_returns
Output [5]: [sr_item_sk#80, sr_ticket_number#81, sr_return_quantity#82, sr_return_amt#83, sr_returned_date_sk#84]
Batched: true
Location [not included in comparison]/{warehouse_dir}/store_returns]
PushedFilters: [IsNotNull(sr_return_amt), GreaterThan(sr_return_amt,10000.00), IsNotNull(sr_ticket_number), IsNotNull(sr_item_sk)]
ReadSchema: struct<sr_item_sk:int,sr_ticket_number:int,sr_return_quantity:int,sr_return_amt:decimal(7,2)>

(55) CometFilter
Input [5]: [sr_item_sk#80, sr_ticket_number#81, sr_return_quantity#82, sr_return_amt#83, sr_returned_date_sk#84]
Condition : (((isnotnull(sr_return_amt#83) AND (sr_return_amt#83 > 10000.00)) AND isnotnull(sr_ticket_number#81)) AND isnotnull(sr_item_sk#80))

(56) CometProject
Input [5]: [sr_item_sk#80, sr_ticket_number#81, sr_return_quantity#82, sr_return_amt#83, sr_returned_date_sk#84]
Arguments: [sr_item_sk#80, sr_ticket_number#81, sr_return_quantity#82, sr_return_amt#83], [sr_item_sk#80, sr_ticket_number#81, sr_return_quantity#82, sr_return_amt#83]

(57) CometBroadcastHashJoin
Left output [5]: [ss_item_sk#73, ss_ticket_number#74, ss_quantity#75, ss_net_paid#76, ss_sold_date_sk#78]
Right output [4]: [sr_item_sk#80, sr_ticket_number#81, sr_return_quantity#82, sr_return_amt#83]
Arguments: [ss_ticket_number#74, ss_item_sk#73], [sr_ticket_number#81, sr_item_sk#80], Inner, BuildLeft

(58) CometProject
Input [9]: [ss_item_sk#73, ss_ticket_number#74, ss_quantity#75, ss_net_paid#76, ss_sold_date_sk#78, sr_item_sk#80, sr_ticket_number#81, sr_return_quantity#82, sr_return_amt#83]
Arguments: [ss_item_sk#73, ss_quantity#75, ss_net_paid#76, ss_sold_date_sk#78, sr_return_quantity#82, sr_return_amt#83], [ss_item_sk#73, ss_quantity#75, ss_net_paid#76, ss_sold_date_sk#78, sr_return_quantity#82, sr_return_amt#83]

(59) ReusedExchange [Reuses operator id: 13]
Output [1]: [d_date_sk#85]

(60) CometBroadcastHashJoin
Left output [6]: [ss_item_sk#73, ss_quantity#75, ss_net_paid#76, ss_sold_date_sk#78, sr_return_quantity#82, sr_return_amt#83]
Right output [1]: [d_date_sk#85]
Arguments: [ss_sold_date_sk#78], [d_date_sk#85], Inner, BuildRight

(61) CometProject
Input [7]: [ss_item_sk#73, ss_quantity#75, ss_net_paid#76, ss_sold_date_sk#78, sr_return_quantity#82, sr_return_amt#83, d_date_sk#85]
Arguments: [ss_item_sk#73, ss_quantity#75, ss_net_paid#76, sr_return_quantity#82, sr_return_amt#83], [ss_item_sk#73, ss_quantity#75, ss_net_paid#76, sr_return_quantity#82, sr_return_amt#83]

(62) ColumnarToRow [codegen id : 11]
Input [5]: [ss_item_sk#73, ss_quantity#75, ss_net_paid#76, sr_return_quantity#82, sr_return_amt#83]

(63) HashAggregate [codegen id : 11]
Input [5]: [ss_item_sk#73, ss_quantity#75, ss_net_paid#76, sr_return_quantity#82, sr_return_amt#83]
Keys [1]: [ss_item_sk#73]
Functions [4]: [partial_sum(coalesce(sr_return_quantity#82, 0)), partial_sum(coalesce(ss_quantity#75, 0)), partial_sum(coalesce(cast(sr_return_amt#83 as decimal(12,2)), 0.00)), partial_sum(coalesce(cast(ss_net_paid#76 as decimal(12,2)), 0.00))]
Aggregate Attributes [6]: [sum#86, sum#87, sum#88, isEmpty#89, sum#90, isEmpty#91]
Results [7]: [ss_item_sk#73, sum#92, sum#93, sum#94, isEmpty#95, sum#96, isEmpty#97]

(64) Exchange
Input [7]: [ss_item_sk#73, sum#92, sum#93, sum#94, isEmpty#95, sum#96, isEmpty#97]
Arguments: hashpartitioning(ss_item_sk#73, 5), ENSURE_REQUIREMENTS, [plan_id=5]

(65) HashAggregate [codegen id : 12]
Input [7]: [ss_item_sk#73, sum#92, sum#93, sum#94, isEmpty#95, sum#96, isEmpty#97]
Keys [1]: [ss_item_sk#73]
Functions [4]: [sum(coalesce(sr_return_quantity#82, 0)), sum(coalesce(ss_quantity#75, 0)), sum(coalesce(cast(sr_return_amt#83 as decimal(12,2)), 0.00)), sum(coalesce(cast(ss_net_paid#76 as decimal(12,2)), 0.00))]
Aggregate Attributes [4]: [sum(coalesce(sr_return_quantity#82, 0))#98, sum(coalesce(ss_quantity#75, 0))#99, sum(coalesce(cast(sr_return_amt#83 as decimal(12,2)), 0.00))#100, sum(coalesce(cast(ss_net_paid#76 as decimal(12,2)), 0.00))#101]
Results [3]: [ss_item_sk#73 AS item#102, (cast(sum(coalesce(sr_return_quantity#82, 0))#98 as decimal(15,4)) / cast(sum(coalesce(ss_quantity#75, 0))#99 as decimal(15,4))) AS return_ratio#103, (cast(sum(coalesce(cast(sr_return_amt#83 as decimal(12,2)), 0.00))#100 as decimal(15,4)) / cast(sum(coalesce(cast(ss_net_paid#76 as decimal(12,2)), 0.00))#101 as decimal(15,4))) AS currency_ratio#104]

(66) Exchange
Input [3]: [item#102, return_ratio#103, currency_ratio#104]
Arguments: SinglePartition, ENSURE_REQUIREMENTS, [plan_id=6]

(67) Sort [codegen id : 13]
Input [3]: [item#102, return_ratio#103, currency_ratio#104]
Arguments: [return_ratio#103 ASC NULLS FIRST], false, 0

(68) Window
Input [3]: [item#102, return_ratio#103, currency_ratio#104]
Arguments: [rank(return_ratio#103) windowspecdefinition(return_ratio#103 ASC NULLS FIRST, specifiedwindowframe(RowFrame, unboundedpreceding$(), currentrow$())) AS return_rank#105], [return_ratio#103 ASC NULLS FIRST]

(69) Sort [codegen id : 14]
Input [4]: [item#102, return_ratio#103, currency_ratio#104, return_rank#105]
Arguments: [currency_ratio#104 ASC NULLS FIRST], false, 0

(70) Window
Input [4]: [item#102, return_ratio#103, currency_ratio#104, return_rank#105]
Arguments: [rank(currency_ratio#104) windowspecdefinition(currency_ratio#104 ASC NULLS FIRST, specifiedwindowframe(RowFrame, unboundedpreceding$(), currentrow$())) AS currency_rank#106], [currency_ratio#104 ASC NULLS FIRST]

(71) Filter [codegen id : 15]
Input [5]: [item#102, return_ratio#103, currency_ratio#104, return_rank#105, currency_rank#106]
Condition : ((return_rank#105 <= 10) OR (currency_rank#106 <= 10))

(72) Project [codegen id : 15]
Output [5]: [store AS channel#107, item#102, return_ratio#103, return_rank#105, currency_rank#106]
Input [5]: [item#102, return_ratio#103, currency_ratio#104, return_rank#105, currency_rank#106]

(73) Union

(74) HashAggregate [codegen id : 16]
Input [5]: [channel#37, item#32, return_ratio#33, return_rank#35, currency_rank#36]
Keys [5]: [channel#37, item#32, return_ratio#33, return_rank#35, currency_rank#36]
Functions: []
Aggregate Attributes: []
Results [5]: [channel#37, item#32, return_ratio#33, return_rank#35, currency_rank#36]

(75) Exchange
Input [5]: [channel#37, item#32, return_ratio#33, return_rank#35, currency_rank#36]
Arguments: hashpartitioning(channel#37, item#32, return_ratio#33, return_rank#35, currency_rank#36, 5), ENSURE_REQUIREMENTS, [plan_id=7]

(76) HashAggregate [codegen id : 17]
Input [5]: [channel#37, item#32, return_ratio#33, return_rank#35, currency_rank#36]
Keys [5]: [channel#37, item#32, return_ratio#33, return_rank#35, currency_rank#36]
Functions: []
Aggregate Attributes: []
Results [5]: [channel#37, item#32, return_ratio#33, return_rank#35, currency_rank#36]

(77) TakeOrderedAndProject
Input [5]: [channel#37, item#32, return_ratio#33, return_rank#35, currency_rank#36]
Arguments: 100, [channel#37 ASC NULLS FIRST, return_rank#35 ASC NULLS FIRST, currency_rank#36 ASC NULLS FIRST], [channel#37, item#32, return_ratio#33, return_rank#35, currency_rank#36]

===== Subqueries =====

Subquery:1 Hosting operator id = 1 Hosting Expression = ws_sold_date_sk#6 IN dynamicpruning#7
BroadcastExchange (82)
+- * ColumnarToRow (81)
   +- CometProject (80)
      +- CometFilter (79)
         +- CometScan parquet spark_catalog.default.date_dim (78)


(78) CometScan parquet spark_catalog.default.date_dim
Output [3]: [d_date_sk#13, d_year#14, d_moy#15]
Batched: true
Location [not included in comparison]/{warehouse_dir}/date_dim]
PushedFilters: [IsNotNull(d_year), IsNotNull(d_moy), EqualTo(d_year,2001), EqualTo(d_moy,12), IsNotNull(d_date_sk)]
ReadSchema: struct<d_date_sk:int,d_year:int,d_moy:int>

(79) CometFilter
Input [3]: [d_date_sk#13, d_year#14, d_moy#15]
Condition : ((((isnotnull(d_year#14) AND isnotnull(d_moy#15)) AND (d_year#14 = 2001)) AND (d_moy#15 = 12)) AND isnotnull(d_date_sk#13))

(80) CometProject
Input [3]: [d_date_sk#13, d_year#14, d_moy#15]
Arguments: [d_date_sk#13], [d_date_sk#13]

(81) ColumnarToRow [codegen id : 1]
Input [1]: [d_date_sk#13]

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

Subquery:2 Hosting operator id = 27 Hosting Expression = cs_sold_date_sk#43 IN dynamicpruning#7

Subquery:3 Hosting operator id = 50 Hosting Expression = ss_sold_date_sk#78 IN dynamicpruning#7


