== Physical Plan ==
* ColumnarToRow (91)
+- CometTakeOrderedAndProject (90)
   +- CometHashAggregate (89)
      +- CometColumnarExchange (88)
         +- RowToColumnar (87)
            +- * HashAggregate (86)
               +- Union (85)
                  :- * Project (30)
                  :  +- * Filter (29)
                  :     +- Window (28)
                  :        +- * Sort (27)
                  :           +- Window (26)
                  :              +- * ColumnarToRow (25)
                  :                 +- CometSort (24)
                  :                    +- CometColumnarExchange (23)
                  :                       +- RowToColumnar (22)
                  :                          +- * HashAggregate (21)
                  :                             +- * ColumnarToRow (20)
                  :                                +- CometColumnarExchange (19)
                  :                                   +- RowToColumnar (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 (57)
                  :  +- * Filter (56)
                  :     +- Window (55)
                  :        +- * Sort (54)
                  :           +- Window (53)
                  :              +- * ColumnarToRow (52)
                  :                 +- CometSort (51)
                  :                    +- CometColumnarExchange (50)
                  :                       +- RowToColumnar (49)
                  :                          +- * HashAggregate (48)
                  :                             +- * ColumnarToRow (47)
                  :                                +- CometColumnarExchange (46)
                  :                                   +- RowToColumnar (45)
                  :                                      +- * HashAggregate (44)
                  :                                         +- * ColumnarToRow (43)
                  :                                            +- CometProject (42)
                  :                                               +- CometBroadcastHashJoin (41)
                  :                                                  :- CometProject (39)
                  :                                                  :  +- CometBroadcastHashJoin (38)
                  :                                                  :     :- CometBroadcastExchange (34)
                  :                                                  :     :  +- CometProject (33)
                  :                                                  :     :     +- CometFilter (32)
                  :                                                  :     :        +- CometScan parquet spark_catalog.default.catalog_sales (31)
                  :                                                  :     +- CometProject (37)
                  :                                                  :        +- CometFilter (36)
                  :                                                  :           +- CometScan parquet spark_catalog.default.catalog_returns (35)
                  :                                                  +- ReusedExchange (40)
                  +- * Project (84)
                     +- * Filter (83)
                        +- Window (82)
                           +- * Sort (81)
                              +- Window (80)
                                 +- * ColumnarToRow (79)
                                    +- CometSort (78)
                                       +- CometColumnarExchange (77)
                                          +- RowToColumnar (76)
                                             +- * HashAggregate (75)
                                                +- * ColumnarToRow (74)
                                                   +- CometColumnarExchange (73)
                                                      +- RowToColumnar (72)
                                                         +- * HashAggregate (71)
                                                            +- * ColumnarToRow (70)
                                                               +- CometProject (69)
                                                                  +- CometBroadcastHashJoin (68)
                                                                     :- CometProject (66)
                                                                     :  +- CometBroadcastHashJoin (65)
                                                                     :     :- CometBroadcastExchange (61)
                                                                     :     :  +- CometProject (60)
                                                                     :     :     +- CometFilter (59)
                                                                     :     :        +- CometScan parquet spark_catalog.default.store_sales (58)
                                                                     :     +- CometProject (64)
                                                                     :        +- CometFilter (63)
                                                                     :           +- CometScan parquet spark_catalog.default.store_returns (62)
                                                                     +- ReusedExchange (67)


(1) Scan 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) Scan 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) Scan 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) RowToColumnar
Input [7]: [ws_item_sk#1, sum#22, sum#23, sum#24, isEmpty#25, sum#26, isEmpty#27]

(19) CometColumnarExchange
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, CometColumnarShuffle, [plan_id=1]

(20) ColumnarToRow [codegen id : 2]
Input [7]: [ws_item_sk#1, sum#22, sum#23, sum#24, isEmpty#25, sum#26, isEmpty#27]

(21) 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]

(22) RowToColumnar
Input [3]: [item#32, return_ratio#33, currency_ratio#34]

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

(24) CometSort
Input [3]: [item#32, return_ratio#33, currency_ratio#34]
Arguments: [item#32, return_ratio#33, currency_ratio#34], [return_ratio#33 ASC NULLS FIRST]

(25) ColumnarToRow [codegen id : 3]
Input [3]: [item#32, return_ratio#33, currency_ratio#34]

(26) 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]

(27) 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

(28) 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]

(29) 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))

(30) 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]

(31) Scan 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)>

(32) 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))

(33) 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]

(34) 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]

(35) Scan 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)>

(36) 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))

(37) 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]

(38) 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

(39) 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]

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

(41) 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

(42) 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]

(43) 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]

(44) 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]

(45) RowToColumnar
Input [7]: [cs_item_sk#38, sum#57, sum#58, sum#59, isEmpty#60, sum#61, isEmpty#62]

(46) CometColumnarExchange
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, CometColumnarShuffle, [plan_id=3]

(47) ColumnarToRow [codegen id : 7]
Input [7]: [cs_item_sk#38, sum#57, sum#58, sum#59, isEmpty#60, sum#61, isEmpty#62]

(48) 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]

(49) RowToColumnar
Input [3]: [item#67, return_ratio#68, currency_ratio#69]

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

(51) CometSort
Input [3]: [item#67, return_ratio#68, currency_ratio#69]
Arguments: [item#67, return_ratio#68, currency_ratio#69], [return_ratio#68 ASC NULLS FIRST]

(52) ColumnarToRow [codegen id : 8]
Input [3]: [item#67, return_ratio#68, currency_ratio#69]

(53) 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]

(54) 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

(55) 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]

(56) 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))

(57) 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]

(58) Scan 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)>

(59) 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))

(60) 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]

(61) 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]

(62) Scan 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)>

(63) 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))

(64) 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]

(65) 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

(66) 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]

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

(68) 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

(69) 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]

(70) 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]

(71) 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]

(72) RowToColumnar
Input [7]: [ss_item_sk#73, sum#92, sum#93, sum#94, isEmpty#95, sum#96, isEmpty#97]

(73) CometColumnarExchange
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, CometColumnarShuffle, [plan_id=5]

(74) ColumnarToRow [codegen id : 12]
Input [7]: [ss_item_sk#73, sum#92, sum#93, sum#94, isEmpty#95, sum#96, isEmpty#97]

(75) 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]

(76) RowToColumnar
Input [3]: [item#102, return_ratio#103, currency_ratio#104]

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

(78) CometSort
Input [3]: [item#102, return_ratio#103, currency_ratio#104]
Arguments: [item#102, return_ratio#103, currency_ratio#104], [return_ratio#103 ASC NULLS FIRST]

(79) ColumnarToRow [codegen id : 13]
Input [3]: [item#102, return_ratio#103, currency_ratio#104]

(80) 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]

(81) 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

(82) 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]

(83) 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))

(84) 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]

(85) Union

(86) 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]

(87) RowToColumnar
Input [5]: [channel#37, item#32, return_ratio#33, return_rank#35, currency_rank#36]

(88) CometColumnarExchange
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, CometColumnarShuffle, [plan_id=7]

(89) CometHashAggregate
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: []

(90) CometTakeOrderedAndProject
Input [5]: [channel#37, item#32, return_ratio#33, return_rank#35, currency_rank#36]
Arguments: TakeOrderedAndProject(limit=100, orderBy=[channel#37 ASC NULLS FIRST,return_rank#35 ASC NULLS FIRST,currency_rank#36 ASC NULLS FIRST], output=[channel#37,item#32,return_ratio#33,return_rank#35,currency_rank#36]), [channel#37, item#32, return_ratio#33, return_rank#35, currency_rank#36], 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]

(91) ColumnarToRow [codegen id : 17]
Input [5]: [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 (96)
+- * ColumnarToRow (95)
   +- CometProject (94)
      +- CometFilter (93)
         +- CometScan parquet spark_catalog.default.date_dim (92)


(92) Scan 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>

(93) 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))

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

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

(96) 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 = 31 Hosting Expression = cs_sold_date_sk#43 IN dynamicpruning#7

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


