== Physical Plan ==
AdaptiveSparkPlan (874)
+- == Final Plan ==
   NativeTakeOrdered (309)
   +- NativeProject (308)
      +- NativeHashAggregate (307)
         +- InputAdapter (306)
            +- AQEShuffleRead (305)
               +- ShuffleQueryStage (304), Statistics(X)
                  +- NativeShuffleExchange (303)
                     +- NativeHashAggregate (302)
                        +- NativeExpand (301)
                           +- InputAdapter (300)
                              +- NativeUnion (299)
                                 :- NativeProject (192)
                                 :  +- NativeFilter (191)
                                 :     +- NativeProject (190)
                                 :        +- NativeHashAggregate (189)
                                 :           +- InputAdapter (188)
                                 :              +- AQEShuffleRead (187)
                                 :                 +- ShuffleQueryStage (186), Statistics(X)
                                 :                    +- NativeShuffleExchange (185)
                                 :                       +- NativeHashAggregate (184)
                                 :                          +- NativeProject (183)
                                 :                             +- NativeProject (182)
                                 :                                +- NativeSortMergeJoin Inner (181)
                                 :                                   :- NativeSort (171)
                                 :                                   :  +- InputAdapter (170)
                                 :                                   :     +- AQEShuffleRead (169)
                                 :                                   :        +- ShuffleQueryStage (168), Statistics(X)
                                 :                                   :           +- NativeShuffleExchange (167)
                                 :                                   :              +- NativeProject (166)
                                 :                                   :                 +- NativeSortMergeJoin Inner (165)
                                 :                                   :                    :- NativeSortMergeJoin LeftSemi (152)
                                 :                                   :                    :  :- NativeSort (8)
                                 :                                   :                    :  :  +- InputAdapter (7)
                                 :                                   :                    :  :     +- AQEShuffleRead (6)
                                 :                                   :                    :  :        +- ShuffleQueryStage (5), Statistics(X)
                                 :                                   :                    :  :           +- NativeShuffleExchange (4)
                                 :                                   :                    :  :              +- NativeFilter (3)
                                 :                                   :                    :  :                 +- InputAdapter (2)
                                 :                                   :                    :  :                    +- NativeParquetScan  (1)
                                 :                                   :                    :  +- NativeSort (151)
                                 :                                   :                    :     +- InputAdapter (150)
                                 :                                   :                    :        +- AQEShuffleRead (149)
                                 :                                   :                    :           +- ShuffleQueryStage (148), Statistics(X)
                                 :                                   :                    :              +- NativeShuffleExchange (147)
                                 :                                   :                    :                 +- NativeProject (146)
                                 :                                   :                    :                    +- NativeSortMergeJoin Inner (145)
                                 :                                   :                    :                       :- NativeSort (16)
                                 :                                   :                    :                       :  +- InputAdapter (15)
                                 :                                   :                    :                       :     +- AQEShuffleRead (14)
                                 :                                   :                    :                       :        +- ShuffleQueryStage (13), Statistics(X)
                                 :                                   :                    :                       :           +- NativeShuffleExchange (12)
                                 :                                   :                    :                       :              +- NativeFilter (11)
                                 :                                   :                    :                       :                 +- InputAdapter (10)
                                 :                                   :                    :                       :                    +- NativeParquetScan  (9)
                                 :                                   :                    :                       +- NativeSort (144)
                                 :                                   :                    :                          +- InputAdapter (143)
                                 :                                   :                    :                             +- AQEShuffleRead (142)
                                 :                                   :                    :                                +- ShuffleQueryStage (141), Statistics(X)
                                 :                                   :                    :                                   +- NativeShuffleExchange (140)
                                 :                                   :                    :                                      +- NativeSortMergeJoin LeftSemi (139)
                                 :                                   :                    :                                         :- NativeSort (104)
                                 :                                   :                    :                                         :  +- InputAdapter (103)
                                 :                                   :                    :                                         :     +- AQEShuffleRead (102)
                                 :                                   :                    :                                         :        +- ShuffleQueryStage (101), Statistics(X)
                                 :                                   :                    :                                         :           +- NativeShuffleExchange (100)
                                 :                                   :                    :                                         :              +- NativeProject (99)
                                 :                                   :                    :                                         :                 +- NativeHashAggregate (98)
                                 :                                   :                    :                                         :                    +- InputAdapter (97)
                                 :                                   :                    :                                         :                       +- AQEShuffleRead (96)
                                 :                                   :                    :                                         :                          +- ShuffleQueryStage (95), Statistics(X)
                                 :                                   :                    :                                         :                             +- NativeShuffleExchange (94)
                                 :                                   :                    :                                         :                                +- NativeHashAggregate (93)
                                 :                                   :                    :                                         :                                   +- NativeProject (92)
                                 :                                   :                    :                                         :                                      +- NativeSortMergeJoin Inner (91)
                                 :                                   :                    :                                         :                                         :- NativeSort (84)
                                 :                                   :                    :                                         :                                         :  +- InputAdapter (83)
                                 :                                   :                    :                                         :                                         :     +- AQEShuffleRead (82)
                                 :                                   :                    :                                         :                                         :        +- ShuffleQueryStage (81), Statistics(X)
                                 :                                   :                    :                                         :                                         :           +- NativeShuffleExchange (80)
                                 :                                   :                    :                                         :                                         :              +- NativeProject (79)
                                 :                                   :                    :                                         :                                         :                 +- NativeSortMergeJoin Inner (78)
                                 :                                   :                    :                                         :                                         :                    :- NativeSort (24)
                                 :                                   :                    :                                         :                                         :                    :  +- InputAdapter (23)
                                 :                                   :                    :                                         :                                         :                    :     +- AQEShuffleRead (22)
                                 :                                   :                    :                                         :                                         :                    :        +- ShuffleQueryStage (21), Statistics(X)
                                 :                                   :                    :                                         :                                         :                    :           +- NativeShuffleExchange (20)
                                 :                                   :                    :                                         :                                         :                    :              +- NativeFilter (19)
                                 :                                   :                    :                                         :                                         :                    :                 +- InputAdapter (18)
                                 :                                   :                    :                                         :                                         :                    :                    +- NativeParquetScan  (17)
                                 :                                   :                    :                                         :                                         :                    +- NativeSort (77)
                                 :                                   :                    :                                         :                                         :                       +- InputAdapter (76)
                                 :                                   :                    :                                         :                                         :                          +- AQEShuffleRead (75)
                                 :                                   :                    :                                         :                                         :                             +- ShuffleQueryStage (74), Statistics(X)
                                 :                                   :                    :                                         :                                         :                                +- NativeShuffleExchange (73)
                                 :                                   :                    :                                         :                                         :                                   +- NativeSortMergeJoin LeftSemi (72)
                                 :                                   :                    :                                         :                                         :                                      :- NativeSort (32)
                                 :                                   :                    :                                         :                                         :                                      :  +- InputAdapter (31)
                                 :                                   :                    :                                         :                                         :                                      :     +- AQEShuffleRead (30)
                                 :                                   :                    :                                         :                                         :                                      :        +- ShuffleQueryStage (29), Statistics(X)
                                 :                                   :                    :                                         :                                         :                                      :           +- NativeShuffleExchange (28)
                                 :                                   :                    :                                         :                                         :                                      :              +- NativeFilter (27)
                                 :                                   :                    :                                         :                                         :                                      :                 +- InputAdapter (26)
                                 :                                   :                    :                                         :                                         :                                      :                    +- NativeParquetScan  (25)
                                 :                                   :                    :                                         :                                         :                                      +- NativeSort (71)
                                 :                                   :                    :                                         :                                         :                                         +- InputAdapter (70)
                                 :                                   :                    :                                         :                                         :                                            +- AQEShuffleRead (69)
                                 :                                   :                    :                                         :                                         :                                               +- ShuffleQueryStage (68), Statistics(X)
                                 :                                   :                    :                                         :                                         :                                                  +- NativeShuffleExchange (67)
                                 :                                   :                    :                                         :                                         :                                                     +- NativeProject (66)
                                 :                                   :                    :                                         :                                         :                                                        +- NativeSortMergeJoin Inner (65)
                                 :                                   :                    :                                         :                                         :                                                           :- NativeSort (55)
                                 :                                   :                    :                                         :                                         :                                                           :  +- InputAdapter (54)
                                 :                                   :                    :                                         :                                         :                                                           :     +- AQEShuffleRead (53)
                                 :                                   :                    :                                         :                                         :                                                           :        +- ShuffleQueryStage (52), Statistics(X)
                                 :                                   :                    :                                         :                                         :                                                           :           +- NativeShuffleExchange (51)
                                 :                                   :                    :                                         :                                         :                                                           :              +- NativeProject (50)
                                 :                                   :                    :                                         :                                         :                                                           :                 +- NativeSortMergeJoin Inner (49)
                                 :                                   :                    :                                         :                                         :                                                           :                    :- NativeSort (40)
                                 :                                   :                    :                                         :                                         :                                                           :                    :  +- InputAdapter (39)
                                 :                                   :                    :                                         :                                         :                                                           :                    :     +- AQEShuffleRead (38)
                                 :                                   :                    :                                         :                                         :                                                           :                    :        +- ShuffleQueryStage (37), Statistics(X)
                                 :                                   :                    :                                         :                                         :                                                           :                    :           +- NativeShuffleExchange (36)
                                 :                                   :                    :                                         :                                         :                                                           :                    :              +- NativeFilter (35)
                                 :                                   :                    :                                         :                                         :                                                           :                    :                 +- InputAdapter (34)
                                 :                                   :                    :                                         :                                         :                                                           :                    :                    +- NativeParquetScan  (33)
                                 :                                   :                    :                                         :                                         :                                                           :                    +- NativeSort (48)
                                 :                                   :                    :                                         :                                         :                                                           :                       +- InputAdapter (47)
                                 :                                   :                    :                                         :                                         :                                                           :                          +- AQEShuffleRead (46)
                                 :                                   :                    :                                         :                                         :                                                           :                             +- ShuffleQueryStage (45), Statistics(X)
                                 :                                   :                    :                                         :                                         :                                                           :                                +- NativeShuffleExchange (44)
                                 :                                   :                    :                                         :                                         :                                                           :                                   +- NativeFilter (43)
                                 :                                   :                    :                                         :                                         :                                                           :                                      +- InputAdapter (42)
                                 :                                   :                    :                                         :                                         :                                                           :                                         +- NativeParquetScan  (41)
                                 :                                   :                    :                                         :                                         :                                                           +- NativeSort (64)
                                 :                                   :                    :                                         :                                         :                                                              +- InputAdapter (63)
                                 :                                   :                    :                                         :                                         :                                                                 +- AQEShuffleRead (62)
                                 :                                   :                    :                                         :                                         :                                                                    +- ShuffleQueryStage (61), Statistics(X)
                                 :                                   :                    :                                         :                                         :                                                                       +- NativeShuffleExchange (60)
                                 :                                   :                    :                                         :                                         :                                                                          +- NativeProject (59)
                                 :                                   :                    :                                         :                                         :                                                                             +- NativeFilter (58)
                                 :                                   :                    :                                         :                                         :                                                                                +- InputAdapter (57)
                                 :                                   :                    :                                         :                                         :                                                                                   +- NativeParquetScan  (56)
                                 :                                   :                    :                                         :                                         +- NativeSort (90)
                                 :                                   :                    :                                         :                                            +- InputAdapter (89)
                                 :                                   :                    :                                         :                                               +- InputAdapter (88)
                                 :                                   :                    :                                         :                                                  +- AQEShuffleRead (87)
                                 :                                   :                    :                                         :                                                     +- ShuffleQueryStage (86), Statistics(X)
                                 :                                   :                    :                                         :                                                        +- ReusedExchange (85)
                                 :                                   :                    :                                         +- NativeSort (138)
                                 :                                   :                    :                                            +- InputAdapter (137)
                                 :                                   :                    :                                               +- AQEShuffleRead (136)
                                 :                                   :                    :                                                  +- ShuffleQueryStage (135), Statistics(X)
                                 :                                   :                    :                                                     +- NativeShuffleExchange (134)
                                 :                                   :                    :                                                        +- NativeProject (133)
                                 :                                   :                    :                                                           +- NativeSortMergeJoin Inner (132)
                                 :                                   :                    :                                                              :- NativeSort (125)
                                 :                                   :                    :                                                              :  +- InputAdapter (124)
                                 :                                   :                    :                                                              :     +- AQEShuffleRead (123)
                                 :                                   :                    :                                                              :        +- ShuffleQueryStage (122), Statistics(X)
                                 :                                   :                    :                                                              :           +- NativeShuffleExchange (121)
                                 :                                   :                    :                                                              :              +- NativeProject (120)
                                 :                                   :                    :                                                              :                 +- NativeSortMergeJoin Inner (119)
                                 :                                   :                    :                                                              :                    :- NativeSort (112)
                                 :                                   :                    :                                                              :                    :  +- InputAdapter (111)
                                 :                                   :                    :                                                              :                    :     +- AQEShuffleRead (110)
                                 :                                   :                    :                                                              :                    :        +- ShuffleQueryStage (109), Statistics(X)
                                 :                                   :                    :                                                              :                    :           +- NativeShuffleExchange (108)
                                 :                                   :                    :                                                              :                    :              +- NativeFilter (107)
                                 :                                   :                    :                                                              :                    :                 +- InputAdapter (106)
                                 :                                   :                    :                                                              :                    :                    +- NativeParquetScan  (105)
                                 :                                   :                    :                                                              :                    +- NativeSort (118)
                                 :                                   :                    :                                                              :                       +- InputAdapter (117)
                                 :                                   :                    :                                                              :                          +- InputAdapter (116)
                                 :                                   :                    :                                                              :                             +- AQEShuffleRead (115)
                                 :                                   :                    :                                                              :                                +- ShuffleQueryStage (114), Statistics(X)
                                 :                                   :                    :                                                              :                                   +- ReusedExchange (113)
                                 :                                   :                    :                                                              +- NativeSort (131)
                                 :                                   :                    :                                                                 +- InputAdapter (130)
                                 :                                   :                    :                                                                    +- InputAdapter (129)
                                 :                                   :                    :                                                                       +- AQEShuffleRead (128)
                                 :                                   :                    :                                                                          +- ShuffleQueryStage (127), Statistics(X)
                                 :                                   :                    :                                                                             +- ReusedExchange (126)
                                 :                                   :                    +- NativeSortMergeJoin LeftSemi (164)
                                 :                                   :                       :- NativeSort (158)
                                 :                                   :                       :  +- InputAdapter (157)
                                 :                                   :                       :     +- InputAdapter (156)
                                 :                                   :                       :        +- AQEShuffleRead (155)
                                 :                                   :                       :           +- ShuffleQueryStage (154), Statistics(X)
                                 :                                   :                       :              +- ReusedExchange (153)
                                 :                                   :                       +- NativeSort (163)
                                 :                                   :                          +- InputAdapter (162)
                                 :                                   :                             +- AQEShuffleRead (161)
                                 :                                   :                                +- ShuffleQueryStage (160), Statistics(X)
                                 :                                   :                                   +- ReusedExchange (159)
                                 :                                   +- NativeSort (180)
                                 :                                      +- InputAdapter (179)
                                 :                                         +- AQEShuffleRead (178)
                                 :                                            +- ShuffleQueryStage (177), Statistics(X)
                                 :                                               +- NativeShuffleExchange (176)
                                 :                                                  +- NativeProject (175)
                                 :                                                     +- NativeFilter (174)
                                 :                                                        +- InputAdapter (173)
                                 :                                                           +- NativeParquetScan  (172)
                                 :- NativeProject (245)
                                 :  +- NativeFilter (244)
                                 :     +- NativeProject (243)
                                 :        +- NativeHashAggregate (242)
                                 :           +- InputAdapter (241)
                                 :              +- AQEShuffleRead (240)
                                 :                 +- ShuffleQueryStage (239), Statistics(X)
                                 :                    +- NativeShuffleExchange (238)
                                 :                       +- NativeHashAggregate (237)
                                 :                          +- NativeProject (236)
                                 :                             +- NativeProject (235)
                                 :                                +- NativeSortMergeJoin Inner (234)
                                 :                                   :- NativeSort (227)
                                 :                                   :  +- InputAdapter (226)
                                 :                                   :     +- AQEShuffleRead (225)
                                 :                                   :        +- ShuffleQueryStage (224), Statistics(X)
                                 :                                   :           +- NativeShuffleExchange (223)
                                 :                                   :              +- NativeProject (222)
                                 :                                   :                 +- NativeSortMergeJoin Inner (221)
                                 :                                   :                    :- NativeSortMergeJoin LeftSemi (207)
                                 :                                   :                    :  :- NativeSort (200)
                                 :                                   :                    :  :  +- InputAdapter (199)
                                 :                                   :                    :  :     +- AQEShuffleRead (198)
                                 :                                   :                    :  :        +- ShuffleQueryStage (197), Statistics(X)
                                 :                                   :                    :  :           +- NativeShuffleExchange (196)
                                 :                                   :                    :  :              +- NativeFilter (195)
                                 :                                   :                    :  :                 +- InputAdapter (194)
                                 :                                   :                    :  :                    +- NativeParquetScan  (193)
                                 :                                   :                    :  +- NativeSort (206)
                                 :                                   :                    :     +- InputAdapter (205)
                                 :                                   :                    :        +- InputAdapter (204)
                                 :                                   :                    :           +- AQEShuffleRead (203)
                                 :                                   :                    :              +- ShuffleQueryStage (202), Statistics(X)
                                 :                                   :                    :                 +- ReusedExchange (201)
                                 :                                   :                    +- NativeSortMergeJoin LeftSemi (220)
                                 :                                   :                       :- NativeSort (213)
                                 :                                   :                       :  +- InputAdapter (212)
                                 :                                   :                       :     +- InputAdapter (211)
                                 :                                   :                       :        +- AQEShuffleRead (210)
                                 :                                   :                       :           +- ShuffleQueryStage (209), Statistics(X)
                                 :                                   :                       :              +- ReusedExchange (208)
                                 :                                   :                       +- NativeSort (219)
                                 :                                   :                          +- InputAdapter (218)
                                 :                                   :                             +- InputAdapter (217)
                                 :                                   :                                +- AQEShuffleRead (216)
                                 :                                   :                                   +- ShuffleQueryStage (215), Statistics(X)
                                 :                                   :                                      +- ReusedExchange (214)
                                 :                                   +- NativeSort (233)
                                 :                                      +- InputAdapter (232)
                                 :                                         +- InputAdapter (231)
                                 :                                            +- AQEShuffleRead (230)
                                 :                                               +- ShuffleQueryStage (229), Statistics(X)
                                 :                                                  +- ReusedExchange (228)
                                 +- NativeProject (298)
                                    +- NativeFilter (297)
                                       +- NativeProject (296)
                                          +- NativeHashAggregate (295)
                                             +- InputAdapter (294)
                                                +- AQEShuffleRead (293)
                                                   +- ShuffleQueryStage (292), Statistics(X)
                                                      +- NativeShuffleExchange (291)
                                                         +- NativeHashAggregate (290)
                                                            +- NativeProject (289)
                                                               +- NativeProject (288)
                                                                  +- NativeSortMergeJoin Inner (287)
                                                                     :- NativeSort (280)
                                                                     :  +- InputAdapter (279)
                                                                     :     +- AQEShuffleRead (278)
                                                                     :        +- ShuffleQueryStage (277), Statistics(X)
                                                                     :           +- NativeShuffleExchange (276)
                                                                     :              +- NativeProject (275)
                                                                     :                 +- NativeSortMergeJoin Inner (274)
                                                                     :                    :- NativeSortMergeJoin LeftSemi (260)
                                                                     :                    :  :- NativeSort (253)
                                                                     :                    :  :  +- InputAdapter (252)
                                                                     :                    :  :     +- AQEShuffleRead (251)
                                                                     :                    :  :        +- ShuffleQueryStage (250), Statistics(X)
                                                                     :                    :  :           +- NativeShuffleExchange (249)
                                                                     :                    :  :              +- NativeFilter (248)
                                                                     :                    :  :                 +- InputAdapter (247)
                                                                     :                    :  :                    +- NativeParquetScan  (246)
                                                                     :                    :  +- NativeSort (259)
                                                                     :                    :     +- InputAdapter (258)
                                                                     :                    :        +- InputAdapter (257)
                                                                     :                    :           +- AQEShuffleRead (256)
                                                                     :                    :              +- ShuffleQueryStage (255), Statistics(X)
                                                                     :                    :                 +- ReusedExchange (254)
                                                                     :                    +- NativeSortMergeJoin LeftSemi (273)
                                                                     :                       :- NativeSort (266)
                                                                     :                       :  +- InputAdapter (265)
                                                                     :                       :     +- InputAdapter (264)
                                                                     :                       :        +- AQEShuffleRead (263)
                                                                     :                       :           +- ShuffleQueryStage (262), Statistics(X)
                                                                     :                       :              +- ReusedExchange (261)
                                                                     :                       +- NativeSort (272)
                                                                     :                          +- InputAdapter (271)
                                                                     :                             +- InputAdapter (270)
                                                                     :                                +- AQEShuffleRead (269)
                                                                     :                                   +- ShuffleQueryStage (268), Statistics(X)
                                                                     :                                      +- ReusedExchange (267)
                                                                     +- NativeSort (286)
                                                                        +- InputAdapter (285)
                                                                           +- InputAdapter (284)
                                                                              +- AQEShuffleRead (283)
                                                                                 +- ShuffleQueryStage (282), Statistics(X)
                                                                                    +- ReusedExchange (281)
+- == Initial Plan ==
   TakeOrderedAndProject (873)
   +- HashAggregate (872)
      +- Exchange (871)
         +- HashAggregate (870)
            +- Expand (869)
               +- Union (868)
                  :- Project (495)
                  :  +- Filter (494)
                  :     +- HashAggregate (493)
                  :        +- Exchange (492)
                  :           +- HashAggregate (491)
                  :              +- Project (490)
                  :                 +- SortMergeJoin Inner (489)
                  :                    :- Sort (483)
                  :                    :  +- Exchange (482)
                  :                    :     +- Project (481)
                  :                    :        +- SortMergeJoin Inner (480)
                  :                    :           :- SortMergeJoin LeftSemi (394)
                  :                    :           :  :- Sort (313)
                  :                    :           :  :  +- Exchange (312)
                  :                    :           :  :     +- Filter (311)
                  :                    :           :  :        +- Scan parquet (310)
                  :                    :           :  +- Sort (393)
                  :                    :           :     +- Exchange (392)
                  :                    :           :        +- Project (391)
                  :                    :           :           +- SortMergeJoin Inner (390)
                  :                    :           :              :- Sort (317)
                  :                    :           :              :  +- Exchange (316)
                  :                    :           :              :     +- Filter (315)
                  :                    :           :              :        +- Scan parquet (314)
                  :                    :           :              +- Sort (389)
                  :                    :           :                 +- Exchange (388)
                  :                    :           :                    +- SortMergeJoin LeftSemi (387)
                  :                    :           :                       :- Sort (365)
                  :                    :           :                       :  +- Exchange (364)
                  :                    :           :                       :     +- HashAggregate (363)
                  :                    :           :                       :        +- Exchange (362)
                  :                    :           :                       :           +- HashAggregate (361)
                  :                    :           :                       :              +- Project (360)
                  :                    :           :                       :                 +- SortMergeJoin Inner (359)
                  :                    :           :                       :                    :- Sort (353)
                  :                    :           :                       :                    :  +- Exchange (352)
                  :                    :           :                       :                    :     +- Project (351)
                  :                    :           :                       :                    :        +- SortMergeJoin Inner (350)
                  :                    :           :                       :                    :           :- Sort (321)
                  :                    :           :                       :                    :           :  +- Exchange (320)
                  :                    :           :                       :                    :           :     +- Filter (319)
                  :                    :           :                       :                    :           :        +- Scan parquet (318)
                  :                    :           :                       :                    :           +- Sort (349)
                  :                    :           :                       :                    :              +- Exchange (348)
                  :                    :           :                       :                    :                 +- SortMergeJoin LeftSemi (347)
                  :                    :           :                       :                    :                    :- Sort (325)
                  :                    :           :                       :                    :                    :  +- Exchange (324)
                  :                    :           :                       :                    :                    :     +- Filter (323)
                  :                    :           :                       :                    :                    :        +- Scan parquet (322)
                  :                    :           :                       :                    :                    +- Sort (346)
                  :                    :           :                       :                    :                       +- Exchange (345)
                  :                    :           :                       :                    :                          +- Project (344)
                  :                    :           :                       :                    :                             +- SortMergeJoin Inner (343)
                  :                    :           :                       :                    :                                :- Sort (337)
                  :                    :           :                       :                    :                                :  +- Exchange (336)
                  :                    :           :                       :                    :                                :     +- Project (335)
                  :                    :           :                       :                    :                                :        +- SortMergeJoin Inner (334)
                  :                    :           :                       :                    :                                :           :- Sort (329)
                  :                    :           :                       :                    :                                :           :  +- Exchange (328)
                  :                    :           :                       :                    :                                :           :     +- Filter (327)
                  :                    :           :                       :                    :                                :           :        +- Scan parquet (326)
                  :                    :           :                       :                    :                                :           +- Sort (333)
                  :                    :           :                       :                    :                                :              +- Exchange (332)
                  :                    :           :                       :                    :                                :                 +- Filter (331)
                  :                    :           :                       :                    :                                :                    +- Scan parquet (330)
                  :                    :           :                       :                    :                                +- Sort (342)
                  :                    :           :                       :                    :                                   +- Exchange (341)
                  :                    :           :                       :                    :                                      +- Project (340)
                  :                    :           :                       :                    :                                         +- Filter (339)
                  :                    :           :                       :                    :                                            +- Scan parquet (338)
                  :                    :           :                       :                    +- Sort (358)
                  :                    :           :                       :                       +- Exchange (357)
                  :                    :           :                       :                          +- Project (356)
                  :                    :           :                       :                             +- Filter (355)
                  :                    :           :                       :                                +- Scan parquet (354)
                  :                    :           :                       +- Sort (386)
                  :                    :           :                          +- Exchange (385)
                  :                    :           :                             +- Project (384)
                  :                    :           :                                +- SortMergeJoin Inner (383)
                  :                    :           :                                   :- Sort (377)
                  :                    :           :                                   :  +- Exchange (376)
                  :                    :           :                                   :     +- Project (375)
                  :                    :           :                                   :        +- SortMergeJoin Inner (374)
                  :                    :           :                                   :           :- Sort (369)
                  :                    :           :                                   :           :  +- Exchange (368)
                  :                    :           :                                   :           :     +- Filter (367)
                  :                    :           :                                   :           :        +- Scan parquet (366)
                  :                    :           :                                   :           +- Sort (373)
                  :                    :           :                                   :              +- Exchange (372)
                  :                    :           :                                   :                 +- Filter (371)
                  :                    :           :                                   :                    +- Scan parquet (370)
                  :                    :           :                                   +- Sort (382)
                  :                    :           :                                      +- Exchange (381)
                  :                    :           :                                         +- Project (380)
                  :                    :           :                                            +- Filter (379)
                  :                    :           :                                               +- Scan parquet (378)
                  :                    :           +- SortMergeJoin LeftSemi (479)
                  :                    :              :- Sort (398)
                  :                    :              :  +- Exchange (397)
                  :                    :              :     +- Filter (396)
                  :                    :              :        +- Scan parquet (395)
                  :                    :              +- Sort (478)
                  :                    :                 +- Exchange (477)
                  :                    :                    +- Project (476)
                  :                    :                       +- SortMergeJoin Inner (475)
                  :                    :                          :- Sort (402)
                  :                    :                          :  +- Exchange (401)
                  :                    :                          :     +- Filter (400)
                  :                    :                          :        +- Scan parquet (399)
                  :                    :                          +- Sort (474)
                  :                    :                             +- Exchange (473)
                  :                    :                                +- SortMergeJoin LeftSemi (472)
                  :                    :                                   :- Sort (450)
                  :                    :                                   :  +- Exchange (449)
                  :                    :                                   :     +- HashAggregate (448)
                  :                    :                                   :        +- Exchange (447)
                  :                    :                                   :           +- HashAggregate (446)
                  :                    :                                   :              +- Project (445)
                  :                    :                                   :                 +- SortMergeJoin Inner (444)
                  :                    :                                   :                    :- Sort (438)
                  :                    :                                   :                    :  +- Exchange (437)
                  :                    :                                   :                    :     +- Project (436)
                  :                    :                                   :                    :        +- SortMergeJoin Inner (435)
                  :                    :                                   :                    :           :- Sort (406)
                  :                    :                                   :                    :           :  +- Exchange (405)
                  :                    :                                   :                    :           :     +- Filter (404)
                  :                    :                                   :                    :           :        +- Scan parquet (403)
                  :                    :                                   :                    :           +- Sort (434)
                  :                    :                                   :                    :              +- Exchange (433)
                  :                    :                                   :                    :                 +- SortMergeJoin LeftSemi (432)
                  :                    :                                   :                    :                    :- Sort (410)
                  :                    :                                   :                    :                    :  +- Exchange (409)
                  :                    :                                   :                    :                    :     +- Filter (408)
                  :                    :                                   :                    :                    :        +- Scan parquet (407)
                  :                    :                                   :                    :                    +- Sort (431)
                  :                    :                                   :                    :                       +- Exchange (430)
                  :                    :                                   :                    :                          +- Project (429)
                  :                    :                                   :                    :                             +- SortMergeJoin Inner (428)
                  :                    :                                   :                    :                                :- Sort (422)
                  :                    :                                   :                    :                                :  +- Exchange (421)
                  :                    :                                   :                    :                                :     +- Project (420)
                  :                    :                                   :                    :                                :        +- SortMergeJoin Inner (419)
                  :                    :                                   :                    :                                :           :- Sort (414)
                  :                    :                                   :                    :                                :           :  +- Exchange (413)
                  :                    :                                   :                    :                                :           :     +- Filter (412)
                  :                    :                                   :                    :                                :           :        +- Scan parquet (411)
                  :                    :                                   :                    :                                :           +- Sort (418)
                  :                    :                                   :                    :                                :              +- Exchange (417)
                  :                    :                                   :                    :                                :                 +- Filter (416)
                  :                    :                                   :                    :                                :                    +- Scan parquet (415)
                  :                    :                                   :                    :                                +- Sort (427)
                  :                    :                                   :                    :                                   +- Exchange (426)
                  :                    :                                   :                    :                                      +- Project (425)
                  :                    :                                   :                    :                                         +- Filter (424)
                  :                    :                                   :                    :                                            +- Scan parquet (423)
                  :                    :                                   :                    +- Sort (443)
                  :                    :                                   :                       +- Exchange (442)
                  :                    :                                   :                          +- Project (441)
                  :                    :                                   :                             +- Filter (440)
                  :                    :                                   :                                +- Scan parquet (439)
                  :                    :                                   +- Sort (471)
                  :                    :                                      +- Exchange (470)
                  :                    :                                         +- Project (469)
                  :                    :                                            +- SortMergeJoin Inner (468)
                  :                    :                                               :- Sort (462)
                  :                    :                                               :  +- Exchange (461)
                  :                    :                                               :     +- Project (460)
                  :                    :                                               :        +- SortMergeJoin Inner (459)
                  :                    :                                               :           :- Sort (454)
                  :                    :                                               :           :  +- Exchange (453)
                  :                    :                                               :           :     +- Filter (452)
                  :                    :                                               :           :        +- Scan parquet (451)
                  :                    :                                               :           +- Sort (458)
                  :                    :                                               :              +- Exchange (457)
                  :                    :                                               :                 +- Filter (456)
                  :                    :                                               :                    +- Scan parquet (455)
                  :                    :                                               +- Sort (467)
                  :                    :                                                  +- Exchange (466)
                  :                    :                                                     +- Project (465)
                  :                    :                                                        +- Filter (464)
                  :                    :                                                           +- Scan parquet (463)
                  :                    +- Sort (488)
                  :                       +- Exchange (487)
                  :                          +- Project (486)
                  :                             +- Filter (485)
                  :                                +- Scan parquet (484)
                  :- Project (681)
                  :  +- Filter (680)
                  :     +- HashAggregate (679)
                  :        +- Exchange (678)
                  :           +- HashAggregate (677)
                  :              +- Project (676)
                  :                 +- SortMergeJoin Inner (675)
                  :                    :- Sort (669)
                  :                    :  +- Exchange (668)
                  :                    :     +- Project (667)
                  :                    :        +- SortMergeJoin Inner (666)
                  :                    :           :- SortMergeJoin LeftSemi (580)
                  :                    :           :  :- Sort (499)
                  :                    :           :  :  +- Exchange (498)
                  :                    :           :  :     +- Filter (497)
                  :                    :           :  :        +- Scan parquet (496)
                  :                    :           :  +- Sort (579)
                  :                    :           :     +- Exchange (578)
                  :                    :           :        +- Project (577)
                  :                    :           :           +- SortMergeJoin Inner (576)
                  :                    :           :              :- Sort (503)
                  :                    :           :              :  +- Exchange (502)
                  :                    :           :              :     +- Filter (501)
                  :                    :           :              :        +- Scan parquet (500)
                  :                    :           :              +- Sort (575)
                  :                    :           :                 +- Exchange (574)
                  :                    :           :                    +- SortMergeJoin LeftSemi (573)
                  :                    :           :                       :- Sort (551)
                  :                    :           :                       :  +- Exchange (550)
                  :                    :           :                       :     +- HashAggregate (549)
                  :                    :           :                       :        +- Exchange (548)
                  :                    :           :                       :           +- HashAggregate (547)
                  :                    :           :                       :              +- Project (546)
                  :                    :           :                       :                 +- SortMergeJoin Inner (545)
                  :                    :           :                       :                    :- Sort (539)
                  :                    :           :                       :                    :  +- Exchange (538)
                  :                    :           :                       :                    :     +- Project (537)
                  :                    :           :                       :                    :        +- SortMergeJoin Inner (536)
                  :                    :           :                       :                    :           :- Sort (507)
                  :                    :           :                       :                    :           :  +- Exchange (506)
                  :                    :           :                       :                    :           :     +- Filter (505)
                  :                    :           :                       :                    :           :        +- Scan parquet (504)
                  :                    :           :                       :                    :           +- Sort (535)
                  :                    :           :                       :                    :              +- Exchange (534)
                  :                    :           :                       :                    :                 +- SortMergeJoin LeftSemi (533)
                  :                    :           :                       :                    :                    :- Sort (511)
                  :                    :           :                       :                    :                    :  +- Exchange (510)
                  :                    :           :                       :                    :                    :     +- Filter (509)
                  :                    :           :                       :                    :                    :        +- Scan parquet (508)
                  :                    :           :                       :                    :                    +- Sort (532)
                  :                    :           :                       :                    :                       +- Exchange (531)
                  :                    :           :                       :                    :                          +- Project (530)
                  :                    :           :                       :                    :                             +- SortMergeJoin Inner (529)
                  :                    :           :                       :                    :                                :- Sort (523)
                  :                    :           :                       :                    :                                :  +- Exchange (522)
                  :                    :           :                       :                    :                                :     +- Project (521)
                  :                    :           :                       :                    :                                :        +- SortMergeJoin Inner (520)
                  :                    :           :                       :                    :                                :           :- Sort (515)
                  :                    :           :                       :                    :                                :           :  +- Exchange (514)
                  :                    :           :                       :                    :                                :           :     +- Filter (513)
                  :                    :           :                       :                    :                                :           :        +- Scan parquet (512)
                  :                    :           :                       :                    :                                :           +- Sort (519)
                  :                    :           :                       :                    :                                :              +- Exchange (518)
                  :                    :           :                       :                    :                                :                 +- Filter (517)
                  :                    :           :                       :                    :                                :                    +- Scan parquet (516)
                  :                    :           :                       :                    :                                +- Sort (528)
                  :                    :           :                       :                    :                                   +- Exchange (527)
                  :                    :           :                       :                    :                                      +- Project (526)
                  :                    :           :                       :                    :                                         +- Filter (525)
                  :                    :           :                       :                    :                                            +- Scan parquet (524)
                  :                    :           :                       :                    +- Sort (544)
                  :                    :           :                       :                       +- Exchange (543)
                  :                    :           :                       :                          +- Project (542)
                  :                    :           :                       :                             +- Filter (541)
                  :                    :           :                       :                                +- Scan parquet (540)
                  :                    :           :                       +- Sort (572)
                  :                    :           :                          +- Exchange (571)
                  :                    :           :                             +- Project (570)
                  :                    :           :                                +- SortMergeJoin Inner (569)
                  :                    :           :                                   :- Sort (563)
                  :                    :           :                                   :  +- Exchange (562)
                  :                    :           :                                   :     +- Project (561)
                  :                    :           :                                   :        +- SortMergeJoin Inner (560)
                  :                    :           :                                   :           :- Sort (555)
                  :                    :           :                                   :           :  +- Exchange (554)
                  :                    :           :                                   :           :     +- Filter (553)
                  :                    :           :                                   :           :        +- Scan parquet (552)
                  :                    :           :                                   :           +- Sort (559)
                  :                    :           :                                   :              +- Exchange (558)
                  :                    :           :                                   :                 +- Filter (557)
                  :                    :           :                                   :                    +- Scan parquet (556)
                  :                    :           :                                   +- Sort (568)
                  :                    :           :                                      +- Exchange (567)
                  :                    :           :                                         +- Project (566)
                  :                    :           :                                            +- Filter (565)
                  :                    :           :                                               +- Scan parquet (564)
                  :                    :           +- SortMergeJoin LeftSemi (665)
                  :                    :              :- Sort (584)
                  :                    :              :  +- Exchange (583)
                  :                    :              :     +- Filter (582)
                  :                    :              :        +- Scan parquet (581)
                  :                    :              +- Sort (664)
                  :                    :                 +- Exchange (663)
                  :                    :                    +- Project (662)
                  :                    :                       +- SortMergeJoin Inner (661)
                  :                    :                          :- Sort (588)
                  :                    :                          :  +- Exchange (587)
                  :                    :                          :     +- Filter (586)
                  :                    :                          :        +- Scan parquet (585)
                  :                    :                          +- Sort (660)
                  :                    :                             +- Exchange (659)
                  :                    :                                +- SortMergeJoin LeftSemi (658)
                  :                    :                                   :- Sort (636)
                  :                    :                                   :  +- Exchange (635)
                  :                    :                                   :     +- HashAggregate (634)
                  :                    :                                   :        +- Exchange (633)
                  :                    :                                   :           +- HashAggregate (632)
                  :                    :                                   :              +- Project (631)
                  :                    :                                   :                 +- SortMergeJoin Inner (630)
                  :                    :                                   :                    :- Sort (624)
                  :                    :                                   :                    :  +- Exchange (623)
                  :                    :                                   :                    :     +- Project (622)
                  :                    :                                   :                    :        +- SortMergeJoin Inner (621)
                  :                    :                                   :                    :           :- Sort (592)
                  :                    :                                   :                    :           :  +- Exchange (591)
                  :                    :                                   :                    :           :     +- Filter (590)
                  :                    :                                   :                    :           :        +- Scan parquet (589)
                  :                    :                                   :                    :           +- Sort (620)
                  :                    :                                   :                    :              +- Exchange (619)
                  :                    :                                   :                    :                 +- SortMergeJoin LeftSemi (618)
                  :                    :                                   :                    :                    :- Sort (596)
                  :                    :                                   :                    :                    :  +- Exchange (595)
                  :                    :                                   :                    :                    :     +- Filter (594)
                  :                    :                                   :                    :                    :        +- Scan parquet (593)
                  :                    :                                   :                    :                    +- Sort (617)
                  :                    :                                   :                    :                       +- Exchange (616)
                  :                    :                                   :                    :                          +- Project (615)
                  :                    :                                   :                    :                             +- SortMergeJoin Inner (614)
                  :                    :                                   :                    :                                :- Sort (608)
                  :                    :                                   :                    :                                :  +- Exchange (607)
                  :                    :                                   :                    :                                :     +- Project (606)
                  :                    :                                   :                    :                                :        +- SortMergeJoin Inner (605)
                  :                    :                                   :                    :                                :           :- Sort (600)
                  :                    :                                   :                    :                                :           :  +- Exchange (599)
                  :                    :                                   :                    :                                :           :     +- Filter (598)
                  :                    :                                   :                    :                                :           :        +- Scan parquet (597)
                  :                    :                                   :                    :                                :           +- Sort (604)
                  :                    :                                   :                    :                                :              +- Exchange (603)
                  :                    :                                   :                    :                                :                 +- Filter (602)
                  :                    :                                   :                    :                                :                    +- Scan parquet (601)
                  :                    :                                   :                    :                                +- Sort (613)
                  :                    :                                   :                    :                                   +- Exchange (612)
                  :                    :                                   :                    :                                      +- Project (611)
                  :                    :                                   :                    :                                         +- Filter (610)
                  :                    :                                   :                    :                                            +- Scan parquet (609)
                  :                    :                                   :                    +- Sort (629)
                  :                    :                                   :                       +- Exchange (628)
                  :                    :                                   :                          +- Project (627)
                  :                    :                                   :                             +- Filter (626)
                  :                    :                                   :                                +- Scan parquet (625)
                  :                    :                                   +- Sort (657)
                  :                    :                                      +- Exchange (656)
                  :                    :                                         +- Project (655)
                  :                    :                                            +- SortMergeJoin Inner (654)
                  :                    :                                               :- Sort (648)
                  :                    :                                               :  +- Exchange (647)
                  :                    :                                               :     +- Project (646)
                  :                    :                                               :        +- SortMergeJoin Inner (645)
                  :                    :                                               :           :- Sort (640)
                  :                    :                                               :           :  +- Exchange (639)
                  :                    :                                               :           :     +- Filter (638)
                  :                    :                                               :           :        +- Scan parquet (637)
                  :                    :                                               :           +- Sort (644)
                  :                    :                                               :              +- Exchange (643)
                  :                    :                                               :                 +- Filter (642)
                  :                    :                                               :                    +- Scan parquet (641)
                  :                    :                                               +- Sort (653)
                  :                    :                                                  +- Exchange (652)
                  :                    :                                                     +- Project (651)
                  :                    :                                                        +- Filter (650)
                  :                    :                                                           +- Scan parquet (649)
                  :                    +- Sort (674)
                  :                       +- Exchange (673)
                  :                          +- Project (672)
                  :                             +- Filter (671)
                  :                                +- Scan parquet (670)
                  +- Project (867)
                     +- Filter (866)
                        +- HashAggregate (865)
                           +- Exchange (864)
                              +- HashAggregate (863)
                                 +- Project (862)
                                    +- SortMergeJoin Inner (861)
                                       :- Sort (855)
                                       :  +- Exchange (854)
                                       :     +- Project (853)
                                       :        +- SortMergeJoin Inner (852)
                                       :           :- SortMergeJoin LeftSemi (766)
                                       :           :  :- Sort (685)
                                       :           :  :  +- Exchange (684)
                                       :           :  :     +- Filter (683)
                                       :           :  :        +- Scan parquet (682)
                                       :           :  +- Sort (765)
                                       :           :     +- Exchange (764)
                                       :           :        +- Project (763)
                                       :           :           +- SortMergeJoin Inner (762)
                                       :           :              :- Sort (689)
                                       :           :              :  +- Exchange (688)
                                       :           :              :     +- Filter (687)
                                       :           :              :        +- Scan parquet (686)
                                       :           :              +- Sort (761)
                                       :           :                 +- Exchange (760)
                                       :           :                    +- SortMergeJoin LeftSemi (759)
                                       :           :                       :- Sort (737)
                                       :           :                       :  +- Exchange (736)
                                       :           :                       :     +- HashAggregate (735)
                                       :           :                       :        +- Exchange (734)
                                       :           :                       :           +- HashAggregate (733)
                                       :           :                       :              +- Project (732)
                                       :           :                       :                 +- SortMergeJoin Inner (731)
                                       :           :                       :                    :- Sort (725)
                                       :           :                       :                    :  +- Exchange (724)
                                       :           :                       :                    :     +- Project (723)
                                       :           :                       :                    :        +- SortMergeJoin Inner (722)
                                       :           :                       :                    :           :- Sort (693)
                                       :           :                       :                    :           :  +- Exchange (692)
                                       :           :                       :                    :           :     +- Filter (691)
                                       :           :                       :                    :           :        +- Scan parquet (690)
                                       :           :                       :                    :           +- Sort (721)
                                       :           :                       :                    :              +- Exchange (720)
                                       :           :                       :                    :                 +- SortMergeJoin LeftSemi (719)
                                       :           :                       :                    :                    :- Sort (697)
                                       :           :                       :                    :                    :  +- Exchange (696)
                                       :           :                       :                    :                    :     +- Filter (695)
                                       :           :                       :                    :                    :        +- Scan parquet (694)
                                       :           :                       :                    :                    +- Sort (718)
                                       :           :                       :                    :                       +- Exchange (717)
                                       :           :                       :                    :                          +- Project (716)
                                       :           :                       :                    :                             +- SortMergeJoin Inner (715)
                                       :           :                       :                    :                                :- Sort (709)
                                       :           :                       :                    :                                :  +- Exchange (708)
                                       :           :                       :                    :                                :     +- Project (707)
                                       :           :                       :                    :                                :        +- SortMergeJoin Inner (706)
                                       :           :                       :                    :                                :           :- Sort (701)
                                       :           :                       :                    :                                :           :  +- Exchange (700)
                                       :           :                       :                    :                                :           :     +- Filter (699)
                                       :           :                       :                    :                                :           :        +- Scan parquet (698)
                                       :           :                       :                    :                                :           +- Sort (705)
                                       :           :                       :                    :                                :              +- Exchange (704)
                                       :           :                       :                    :                                :                 +- Filter (703)
                                       :           :                       :                    :                                :                    +- Scan parquet (702)
                                       :           :                       :                    :                                +- Sort (714)
                                       :           :                       :                    :                                   +- Exchange (713)
                                       :           :                       :                    :                                      +- Project (712)
                                       :           :                       :                    :                                         +- Filter (711)
                                       :           :                       :                    :                                            +- Scan parquet (710)
                                       :           :                       :                    +- Sort (730)
                                       :           :                       :                       +- Exchange (729)
                                       :           :                       :                          +- Project (728)
                                       :           :                       :                             +- Filter (727)
                                       :           :                       :                                +- Scan parquet (726)
                                       :           :                       +- Sort (758)
                                       :           :                          +- Exchange (757)
                                       :           :                             +- Project (756)
                                       :           :                                +- SortMergeJoin Inner (755)
                                       :           :                                   :- Sort (749)
                                       :           :                                   :  +- Exchange (748)
                                       :           :                                   :     +- Project (747)
                                       :           :                                   :        +- SortMergeJoin Inner (746)
                                       :           :                                   :           :- Sort (741)
                                       :           :                                   :           :  +- Exchange (740)
                                       :           :                                   :           :     +- Filter (739)
                                       :           :                                   :           :        +- Scan parquet (738)
                                       :           :                                   :           +- Sort (745)
                                       :           :                                   :              +- Exchange (744)
                                       :           :                                   :                 +- Filter (743)
                                       :           :                                   :                    +- Scan parquet (742)
                                       :           :                                   +- Sort (754)
                                       :           :                                      +- Exchange (753)
                                       :           :                                         +- Project (752)
                                       :           :                                            +- Filter (751)
                                       :           :                                               +- Scan parquet (750)
                                       :           +- SortMergeJoin LeftSemi (851)
                                       :              :- Sort (770)
                                       :              :  +- Exchange (769)
                                       :              :     +- Filter (768)
                                       :              :        +- Scan parquet (767)
                                       :              +- Sort (850)
                                       :                 +- Exchange (849)
                                       :                    +- Project (848)
                                       :                       +- SortMergeJoin Inner (847)
                                       :                          :- Sort (774)
                                       :                          :  +- Exchange (773)
                                       :                          :     +- Filter (772)
                                       :                          :        +- Scan parquet (771)
                                       :                          +- Sort (846)
                                       :                             +- Exchange (845)
                                       :                                +- SortMergeJoin LeftSemi (844)
                                       :                                   :- Sort (822)
                                       :                                   :  +- Exchange (821)
                                       :                                   :     +- HashAggregate (820)
                                       :                                   :        +- Exchange (819)
                                       :                                   :           +- HashAggregate (818)
                                       :                                   :              +- Project (817)
                                       :                                   :                 +- SortMergeJoin Inner (816)
                                       :                                   :                    :- Sort (810)
                                       :                                   :                    :  +- Exchange (809)
                                       :                                   :                    :     +- Project (808)
                                       :                                   :                    :        +- SortMergeJoin Inner (807)
                                       :                                   :                    :           :- Sort (778)
                                       :                                   :                    :           :  +- Exchange (777)
                                       :                                   :                    :           :     +- Filter (776)
                                       :                                   :                    :           :        +- Scan parquet (775)
                                       :                                   :                    :           +- Sort (806)
                                       :                                   :                    :              +- Exchange (805)
                                       :                                   :                    :                 +- SortMergeJoin LeftSemi (804)
                                       :                                   :                    :                    :- Sort (782)
                                       :                                   :                    :                    :  +- Exchange (781)
                                       :                                   :                    :                    :     +- Filter (780)
                                       :                                   :                    :                    :        +- Scan parquet (779)
                                       :                                   :                    :                    +- Sort (803)
                                       :                                   :                    :                       +- Exchange (802)
                                       :                                   :                    :                          +- Project (801)
                                       :                                   :                    :                             +- SortMergeJoin Inner (800)
                                       :                                   :                    :                                :- Sort (794)
                                       :                                   :                    :                                :  +- Exchange (793)
                                       :                                   :                    :                                :     +- Project (792)
                                       :                                   :                    :                                :        +- SortMergeJoin Inner (791)
                                       :                                   :                    :                                :           :- Sort (786)
                                       :                                   :                    :                                :           :  +- Exchange (785)
                                       :                                   :                    :                                :           :     +- Filter (784)
                                       :                                   :                    :                                :           :        +- Scan parquet (783)
                                       :                                   :                    :                                :           +- Sort (790)
                                       :                                   :                    :                                :              +- Exchange (789)
                                       :                                   :                    :                                :                 +- Filter (788)
                                       :                                   :                    :                                :                    +- Scan parquet (787)
                                       :                                   :                    :                                +- Sort (799)
                                       :                                   :                    :                                   +- Exchange (798)
                                       :                                   :                    :                                      +- Project (797)
                                       :                                   :                    :                                         +- Filter (796)
                                       :                                   :                    :                                            +- Scan parquet (795)
                                       :                                   :                    +- Sort (815)
                                       :                                   :                       +- Exchange (814)
                                       :                                   :                          +- Project (813)
                                       :                                   :                             +- Filter (812)
                                       :                                   :                                +- Scan parquet (811)
                                       :                                   +- Sort (843)
                                       :                                      +- Exchange (842)
                                       :                                         +- Project (841)
                                       :                                            +- SortMergeJoin Inner (840)
                                       :                                               :- Sort (834)
                                       :                                               :  +- Exchange (833)
                                       :                                               :     +- Project (832)
                                       :                                               :        +- SortMergeJoin Inner (831)
                                       :                                               :           :- Sort (826)
                                       :                                               :           :  +- Exchange (825)
                                       :                                               :           :     +- Filter (824)
                                       :                                               :           :        +- Scan parquet (823)
                                       :                                               :           +- Sort (830)
                                       :                                               :              +- Exchange (829)
                                       :                                               :                 +- Filter (828)
                                       :                                               :                    +- Scan parquet (827)
                                       :                                               +- Sort (839)
                                       :                                                  +- Exchange (838)
                                       :                                                     +- Project (837)
                                       :                                                        +- Filter (836)
                                       :                                                           +- Scan parquet (835)
                                       +- Sort (860)
                                          +- Exchange (859)
                                             +- Project (858)
                                                +- Filter (857)
                                                   +- Scan parquet (856)


(310) Scan parquet
Output [4]: [ss_sold_date_sk#1, ss_item_sk#2, ss_quantity#3, ss_list_price#4]
Batched: true
Location: InMemoryFileIndex [file:/<warehouse_dir>]
PushedFilters: [IsNotNull(ss_item_sk), IsNotNull(ss_sold_date_sk)]
ReadSchema: struct<ss_sold_date_sk:int,ss_item_sk:int,ss_quantity:int,ss_list_price:decimal(7,2)>

(2) InputAdapter
Input [4]: [ss_sold_date_sk#1, ss_item_sk#2, ss_quantity#3, ss_list_price#4]
Arguments: [#1, #2, #3, #4]

(3) NativeFilter
Input [4]: [#1#1, #2#2, #3#3, #4#4]
Condition : (isnotnull(ss_item_sk#2) AND isnotnull(ss_sold_date_sk#1))

(4) NativeShuffleExchange
Input [4]: [#1#1, #2#2, #3#3, #4#4]
Arguments: hashpartitioning(ss_item_sk#2, 100), ENSURE_REQUIREMENTS, [plan_id=1]

(5) ShuffleQueryStage
Output [4]: [#1#1, #2#2, #3#3, #4#4]
Arguments: X

(6) AQEShuffleRead
Input [4]: [#1#1, #2#2, #3#3, #4#4]
Arguments: coalesced

(7) InputAdapter
Input [4]: [#1#1, #2#2, #3#3, #4#4]

(8) NativeSort
Input [4]: [#1#1, #2#2, #3#3, #4#4]
Arguments: [ss_item_sk#2 ASC NULLS FIRST], false

(314) Scan parquet
Output [4]: [i_item_sk#5, i_brand_id#6, i_class_id#7, i_category_id#8]
Batched: true
Location: InMemoryFileIndex [file:/<warehouse_dir>]
PushedFilters: [IsNotNull(i_brand_id), IsNotNull(i_class_id), IsNotNull(i_category_id)]
ReadSchema: struct<i_item_sk:int,i_brand_id:int,i_class_id:int,i_category_id:int>

(10) InputAdapter
Input [4]: [i_item_sk#5, i_brand_id#6, i_class_id#7, i_category_id#8]
Arguments: [#5, #6, #7, #8]

(11) NativeFilter
Input [4]: [#5#5, #6#6, #7#7, #8#8]
Condition : ((isnotnull(i_brand_id#6) AND isnotnull(i_class_id#7)) AND isnotnull(i_category_id#8))

(12) NativeShuffleExchange
Input [4]: [#5#5, #6#6, #7#7, #8#8]
Arguments: hashpartitioning(i_brand_id#6, i_class_id#7, i_category_id#8, 100), ENSURE_REQUIREMENTS, [plan_id=2]

(13) ShuffleQueryStage
Output [4]: [#5#5, #6#6, #7#7, #8#8]
Arguments: X

(14) AQEShuffleRead
Input [4]: [#5#5, #6#6, #7#7, #8#8]
Arguments: coalesced

(15) InputAdapter
Input [4]: [#5#5, #6#6, #7#7, #8#8]

(16) NativeSort
Input [4]: [#5#5, #6#6, #7#7, #8#8]
Arguments: [i_brand_id#6 ASC NULLS FIRST, i_class_id#7 ASC NULLS FIRST, i_category_id#8 ASC NULLS FIRST], false

(318) Scan parquet
Output [2]: [ss_sold_date_sk#9, ss_item_sk#10]
Batched: true
Location: InMemoryFileIndex [file:/<warehouse_dir>]
PushedFilters: [IsNotNull(ss_item_sk), IsNotNull(ss_sold_date_sk)]
ReadSchema: struct<ss_sold_date_sk:int,ss_item_sk:int>

(18) InputAdapter
Input [2]: [ss_sold_date_sk#9, ss_item_sk#10]
Arguments: [#9, #10]

(19) NativeFilter
Input [2]: [#9#9, #10#10]
Condition : (isnotnull(ss_item_sk#10) AND isnotnull(ss_sold_date_sk#9))

(20) NativeShuffleExchange
Input [2]: [#9#9, #10#10]
Arguments: hashpartitioning(ss_item_sk#10, 100), ENSURE_REQUIREMENTS, [plan_id=3]

(21) ShuffleQueryStage
Output [2]: [#9#9, #10#10]
Arguments: X

(22) AQEShuffleRead
Input [2]: [#9#9, #10#10]
Arguments: coalesced

(23) InputAdapter
Input [2]: [#9#9, #10#10]

(24) NativeSort
Input [2]: [#9#9, #10#10]
Arguments: [ss_item_sk#10 ASC NULLS FIRST], false

(322) Scan parquet
Output [4]: [i_item_sk#11, i_brand_id#12, i_class_id#13, i_category_id#14]
Batched: true
Location: InMemoryFileIndex [file:/<warehouse_dir>]
PushedFilters: [IsNotNull(i_item_sk), IsNotNull(i_brand_id), IsNotNull(i_class_id), IsNotNull(i_category_id)]
ReadSchema: struct<i_item_sk:int,i_brand_id:int,i_class_id:int,i_category_id:int>

(26) InputAdapter
Input [4]: [i_item_sk#11, i_brand_id#12, i_class_id#13, i_category_id#14]
Arguments: [#11, #12, #13, #14]

(27) NativeFilter
Input [4]: [#11#11, #12#12, #13#13, #14#14]
Condition : (((isnotnull(i_item_sk#11) AND isnotnull(i_brand_id#12)) AND isnotnull(i_class_id#13)) AND isnotnull(i_category_id#14))

(28) NativeShuffleExchange
Input [4]: [#11#11, #12#12, #13#13, #14#14]
Arguments: hashpartitioning(coalesce(i_brand_id#12, 0), isnull(i_brand_id#12), coalesce(i_class_id#13, 0), isnull(i_class_id#13), coalesce(i_category_id#14, 0), isnull(i_category_id#14), 100), ENSURE_REQUIREMENTS, [plan_id=4]

(29) ShuffleQueryStage
Output [4]: [#11#11, #12#12, #13#13, #14#14]
Arguments: X

(30) AQEShuffleRead
Input [4]: [#11#11, #12#12, #13#13, #14#14]
Arguments: coalesced

(31) InputAdapter
Input [4]: [#11#11, #12#12, #13#13, #14#14]

(32) NativeSort
Input [4]: [#11#11, #12#12, #13#13, #14#14]
Arguments: [coalesce(i_brand_id#12, 0) ASC NULLS FIRST, isnull(i_brand_id#12) ASC NULLS FIRST, coalesce(i_class_id#13, 0) ASC NULLS FIRST, isnull(i_class_id#13) ASC NULLS FIRST, coalesce(i_category_id#14, 0) ASC NULLS FIRST, isnull(i_category_id#14) ASC NULLS FIRST], false

(326) Scan parquet
Output [2]: [cs_sold_date_sk#15, cs_item_sk#16]
Batched: true
Location: InMemoryFileIndex [file:/<warehouse_dir>]
PushedFilters: [IsNotNull(cs_item_sk), IsNotNull(cs_sold_date_sk)]
ReadSchema: struct<cs_sold_date_sk:int,cs_item_sk:int>

(34) InputAdapter
Input [2]: [cs_sold_date_sk#15, cs_item_sk#16]
Arguments: [#15, #16]

(35) NativeFilter
Input [2]: [#15#15, #16#16]
Condition : (isnotnull(cs_item_sk#16) AND isnotnull(cs_sold_date_sk#15))

(36) NativeShuffleExchange
Input [2]: [#15#15, #16#16]
Arguments: hashpartitioning(cs_item_sk#16, 100), ENSURE_REQUIREMENTS, [plan_id=5]

(37) ShuffleQueryStage
Output [2]: [#15#15, #16#16]
Arguments: X

(38) AQEShuffleRead
Input [2]: [#15#15, #16#16]
Arguments: coalesced

(39) InputAdapter
Input [2]: [#15#15, #16#16]

(40) NativeSort
Input [2]: [#15#15, #16#16]
Arguments: [cs_item_sk#16 ASC NULLS FIRST], false

(330) Scan parquet
Output [4]: [i_item_sk#17, i_brand_id#18, i_class_id#19, i_category_id#20]
Batched: true
Location: InMemoryFileIndex [file:/<warehouse_dir>]
PushedFilters: [IsNotNull(i_item_sk)]
ReadSchema: struct<i_item_sk:int,i_brand_id:int,i_class_id:int,i_category_id:int>

(42) InputAdapter
Input [4]: [i_item_sk#17, i_brand_id#18, i_class_id#19, i_category_id#20]
Arguments: [#17, #18, #19, #20]

(43) NativeFilter
Input [4]: [#17#17, #18#18, #19#19, #20#20]
Condition : isnotnull(i_item_sk#17)

(44) NativeShuffleExchange
Input [4]: [#17#17, #18#18, #19#19, #20#20]
Arguments: hashpartitioning(i_item_sk#17, 100), ENSURE_REQUIREMENTS, [plan_id=6]

(45) ShuffleQueryStage
Output [4]: [#17#17, #18#18, #19#19, #20#20]
Arguments: X

(46) AQEShuffleRead
Input [4]: [#17#17, #18#18, #19#19, #20#20]
Arguments: coalesced

(47) InputAdapter
Input [4]: [#17#17, #18#18, #19#19, #20#20]

(48) NativeSort
Input [4]: [#17#17, #18#18, #19#19, #20#20]
Arguments: [i_item_sk#17 ASC NULLS FIRST], false

(49) NativeSortMergeJoin
Left keys [1]: [cs_item_sk#16]
Right keys [1]: [i_item_sk#17]
Join type: Inner
Join condition: None

(50) NativeProject
Output [4]: [cs_sold_date_sk#15, i_brand_id#18, i_class_id#19, i_category_id#20]
Input [6]: [#15#15, #16#16, #17#17, #18#18, #19#19, #20#20]

(51) NativeShuffleExchange
Input [4]: [cs_sold_date_sk#15, i_brand_id#18, i_class_id#19, i_category_id#20]
Arguments: hashpartitioning(cs_sold_date_sk#15, 100), ENSURE_REQUIREMENTS, [plan_id=7]

(52) ShuffleQueryStage
Output [4]: [cs_sold_date_sk#15, i_brand_id#18, i_class_id#19, i_category_id#20]
Arguments: X

(53) AQEShuffleRead
Input [4]: [cs_sold_date_sk#15, i_brand_id#18, i_class_id#19, i_category_id#20]
Arguments: coalesced

(54) InputAdapter
Input [4]: [cs_sold_date_sk#15, i_brand_id#18, i_class_id#19, i_category_id#20]

(55) NativeSort
Input [4]: [cs_sold_date_sk#15, i_brand_id#18, i_class_id#19, i_category_id#20]
Arguments: [cs_sold_date_sk#15 ASC NULLS FIRST], false

(338) Scan parquet
Output [2]: [d_date_sk#21, d_year#22]
Batched: true
Location: InMemoryFileIndex [file:/<warehouse_dir>]
PushedFilters: [IsNotNull(d_year), GreaterThanOrEqual(d_year,1999), LessThanOrEqual(d_year,2001), IsNotNull(d_date_sk)]
ReadSchema: struct<d_date_sk:int,d_year:int>

(57) InputAdapter
Input [2]: [d_date_sk#21, d_year#22]
Arguments: [#21, #22]

(58) NativeFilter
Input [2]: [#21#21, #22#22]
Condition : (((isnotnull(d_year#22) AND (d_year#22 >= 1999)) AND (d_year#22 <= 2001)) AND isnotnull(d_date_sk#21))

(59) NativeProject
Output [1]: [d_date_sk#21]
Input [2]: [#21#21, #22#22]

(60) NativeShuffleExchange
Input [1]: [d_date_sk#21]
Arguments: hashpartitioning(d_date_sk#21, 100), ENSURE_REQUIREMENTS, [plan_id=8]

(61) ShuffleQueryStage
Output [1]: [d_date_sk#21]
Arguments: X

(62) AQEShuffleRead
Input [1]: [d_date_sk#21]
Arguments: coalesced

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

(64) NativeSort
Input [1]: [d_date_sk#21]
Arguments: [d_date_sk#21 ASC NULLS FIRST], false

(65) NativeSortMergeJoin
Left keys [1]: [cs_sold_date_sk#15]
Right keys [1]: [d_date_sk#21]
Join type: Inner
Join condition: None

(66) NativeProject
Output [3]: [i_brand_id#18, i_class_id#19, i_category_id#20]
Input [5]: [cs_sold_date_sk#15, i_brand_id#18, i_class_id#19, i_category_id#20, d_date_sk#21]

(67) NativeShuffleExchange
Input [3]: [i_brand_id#18, i_class_id#19, i_category_id#20]
Arguments: hashpartitioning(coalesce(i_brand_id#18, 0), isnull(i_brand_id#18), coalesce(i_class_id#19, 0), isnull(i_class_id#19), coalesce(i_category_id#20, 0), isnull(i_category_id#20), 100), ENSURE_REQUIREMENTS, [plan_id=9]

(68) ShuffleQueryStage
Output [3]: [i_brand_id#18, i_class_id#19, i_category_id#20]
Arguments: X

(69) AQEShuffleRead
Input [3]: [i_brand_id#18, i_class_id#19, i_category_id#20]
Arguments: coalesced

(70) InputAdapter
Input [3]: [i_brand_id#18, i_class_id#19, i_category_id#20]

(71) NativeSort
Input [3]: [i_brand_id#18, i_class_id#19, i_category_id#20]
Arguments: [coalesce(i_brand_id#18, 0) ASC NULLS FIRST, isnull(i_brand_id#18) ASC NULLS FIRST, coalesce(i_class_id#19, 0) ASC NULLS FIRST, isnull(i_class_id#19) ASC NULLS FIRST, coalesce(i_category_id#20, 0) ASC NULLS FIRST, isnull(i_category_id#20) ASC NULLS FIRST], false

(72) NativeSortMergeJoin
Left keys [6]: [coalesce(i_brand_id#12, 0), isnull(i_brand_id#12), coalesce(i_class_id#13, 0), isnull(i_class_id#13), coalesce(i_category_id#14, 0), isnull(i_category_id#14)]
Right keys [6]: [coalesce(i_brand_id#18, 0), isnull(i_brand_id#18), coalesce(i_class_id#19, 0), isnull(i_class_id#19), coalesce(i_category_id#20, 0), isnull(i_category_id#20)]
Join type: LeftSemi
Join condition: None

(73) NativeShuffleExchange
Input [4]: [#11#11, #12#12, #13#13, #14#14]
Arguments: hashpartitioning(i_item_sk#11, 100), ENSURE_REQUIREMENTS, [plan_id=10]

(74) ShuffleQueryStage
Output [4]: [#11#11, #12#12, #13#13, #14#14]
Arguments: X

(75) AQEShuffleRead
Input [4]: [#11#11, #12#12, #13#13, #14#14]
Arguments: coalesced

(76) InputAdapter
Input [4]: [#11#11, #12#12, #13#13, #14#14]

(77) NativeSort
Input [4]: [#11#11, #12#12, #13#13, #14#14]
Arguments: [i_item_sk#11 ASC NULLS FIRST], false

(78) NativeSortMergeJoin
Left keys [1]: [ss_item_sk#10]
Right keys [1]: [i_item_sk#11]
Join type: Inner
Join condition: None

(79) NativeProject
Output [4]: [ss_sold_date_sk#9, i_brand_id#12, i_class_id#13, i_category_id#14]
Input [6]: [#9#9, #10#10, #11#11, #12#12, #13#13, #14#14]

(80) NativeShuffleExchange
Input [4]: [ss_sold_date_sk#9, i_brand_id#12, i_class_id#13, i_category_id#14]
Arguments: hashpartitioning(ss_sold_date_sk#9, 100), ENSURE_REQUIREMENTS, [plan_id=11]

(81) ShuffleQueryStage
Output [4]: [ss_sold_date_sk#9, i_brand_id#12, i_class_id#13, i_category_id#14]
Arguments: X

(82) AQEShuffleRead
Input [4]: [ss_sold_date_sk#9, i_brand_id#12, i_class_id#13, i_category_id#14]
Arguments: coalesced

(83) InputAdapter
Input [4]: [ss_sold_date_sk#9, i_brand_id#12, i_class_id#13, i_category_id#14]

(84) NativeSort
Input [4]: [ss_sold_date_sk#9, i_brand_id#12, i_class_id#13, i_category_id#14]
Arguments: [ss_sold_date_sk#9 ASC NULLS FIRST], false

(85) ReusedExchange [Reuses operator id: 60]
Output [1]: [d_date_sk#23]

(86) ShuffleQueryStage
Output [1]: [d_date_sk#23]
Arguments: X

(87) AQEShuffleRead
Input [1]: [d_date_sk#23]
Arguments: coalesced

(88) InputAdapter
Input [1]: [d_date_sk#23]
Arguments: [#23]

(89) InputAdapter
Input [1]: [#23#23]

(90) NativeSort
Input [1]: [#23#23]
Arguments: [d_date_sk#23 ASC NULLS FIRST], false

(91) NativeSortMergeJoin
Left keys [1]: [ss_sold_date_sk#9]
Right keys [1]: [d_date_sk#23]
Join type: Inner
Join condition: None

(92) NativeProject
Output [3]: [i_brand_id#12 AS brand_id#24, i_class_id#13 AS class_id#25, i_category_id#14 AS category_id#26]
Input [5]: [ss_sold_date_sk#9, i_brand_id#12, i_class_id#13, i_category_id#14, #23#23]

(93) NativeHashAggregate
Input [3]: [brand_id#24, class_id#25, category_id#26]
Keys [3]: [brand_id#24, class_id#25, category_id#26]
Functions: []
Aggregate Attributes: []
Results [3]: [brand_id#24, class_id#25, category_id#26]

(94) NativeShuffleExchange
Input [3]: [brand_id#24, class_id#25, category_id#26]
Arguments: hashpartitioning(brand_id#24, class_id#25, category_id#26, 100), ENSURE_REQUIREMENTS, [plan_id=12]

(95) ShuffleQueryStage
Output [3]: [brand_id#24, class_id#25, category_id#26]
Arguments: X

(96) AQEShuffleRead
Input [3]: [brand_id#24, class_id#25, category_id#26]
Arguments: coalesced

(97) InputAdapter
Input [3]: [brand_id#24, class_id#25, category_id#26]

(98) NativeHashAggregate
Input [3]: [brand_id#24, class_id#25, category_id#26]
Keys [3]: [brand_id#24, class_id#25, category_id#26]
Functions: []
Aggregate Attributes: []
Results [3]: [brand_id#24, class_id#25, category_id#26]

(99) NativeProject
Output [3]: [brand_id#24, class_id#25, category_id#26]
Input [3]: [brand_id#24, class_id#25, category_id#26]

(100) NativeShuffleExchange
Input [3]: [brand_id#24, class_id#25, category_id#26]
Arguments: hashpartitioning(coalesce(brand_id#24, 0), isnull(brand_id#24), coalesce(class_id#25, 0), isnull(class_id#25), coalesce(category_id#26, 0), isnull(category_id#26), 100), ENSURE_REQUIREMENTS, [plan_id=13]

(101) ShuffleQueryStage
Output [3]: [brand_id#24, class_id#25, category_id#26]
Arguments: X

(102) AQEShuffleRead
Input [3]: [brand_id#24, class_id#25, category_id#26]
Arguments: coalesced

(103) InputAdapter
Input [3]: [brand_id#24, class_id#25, category_id#26]

(104) NativeSort
Input [3]: [brand_id#24, class_id#25, category_id#26]
Arguments: [coalesce(brand_id#24, 0) ASC NULLS FIRST, isnull(brand_id#24) ASC NULLS FIRST, coalesce(class_id#25, 0) ASC NULLS FIRST, isnull(class_id#25) ASC NULLS FIRST, coalesce(category_id#26, 0) ASC NULLS FIRST, isnull(category_id#26) ASC NULLS FIRST], false

(366) Scan parquet
Output [2]: [ws_sold_date_sk#27, ws_item_sk#28]
Batched: true
Location: InMemoryFileIndex [file:/<warehouse_dir>]
PushedFilters: [IsNotNull(ws_item_sk), IsNotNull(ws_sold_date_sk)]
ReadSchema: struct<ws_sold_date_sk:int,ws_item_sk:int>

(106) InputAdapter
Input [2]: [ws_sold_date_sk#27, ws_item_sk#28]
Arguments: [#27, #28]

(107) NativeFilter
Input [2]: [#27#27, #28#28]
Condition : (isnotnull(ws_item_sk#28) AND isnotnull(ws_sold_date_sk#27))

(108) NativeShuffleExchange
Input [2]: [#27#27, #28#28]
Arguments: hashpartitioning(ws_item_sk#28, 100), ENSURE_REQUIREMENTS, [plan_id=14]

(109) ShuffleQueryStage
Output [2]: [#27#27, #28#28]
Arguments: X

(110) AQEShuffleRead
Input [2]: [#27#27, #28#28]
Arguments: coalesced

(111) InputAdapter
Input [2]: [#27#27, #28#28]

(112) NativeSort
Input [2]: [#27#27, #28#28]
Arguments: [ws_item_sk#28 ASC NULLS FIRST], false

(113) ReusedExchange [Reuses operator id: 44]
Output [4]: [i_item_sk#29, i_brand_id#30, i_class_id#31, i_category_id#32]

(114) ShuffleQueryStage
Output [4]: [i_item_sk#29, i_brand_id#30, i_class_id#31, i_category_id#32]
Arguments: X

(115) AQEShuffleRead
Input [4]: [i_item_sk#29, i_brand_id#30, i_class_id#31, i_category_id#32]
Arguments: coalesced

(116) InputAdapter
Input [4]: [i_item_sk#29, i_brand_id#30, i_class_id#31, i_category_id#32]
Arguments: [#29, #30, #31, #32]

(117) InputAdapter
Input [4]: [#29#29, #30#30, #31#31, #32#32]

(118) NativeSort
Input [4]: [#29#29, #30#30, #31#31, #32#32]
Arguments: [i_item_sk#29 ASC NULLS FIRST], false

(119) NativeSortMergeJoin
Left keys [1]: [ws_item_sk#28]
Right keys [1]: [i_item_sk#29]
Join type: Inner
Join condition: None

(120) NativeProject
Output [4]: [ws_sold_date_sk#27, i_brand_id#30, i_class_id#31, i_category_id#32]
Input [6]: [#27#27, #28#28, #29#29, #30#30, #31#31, #32#32]

(121) NativeShuffleExchange
Input [4]: [ws_sold_date_sk#27, i_brand_id#30, i_class_id#31, i_category_id#32]
Arguments: hashpartitioning(ws_sold_date_sk#27, 100), ENSURE_REQUIREMENTS, [plan_id=15]

(122) ShuffleQueryStage
Output [4]: [ws_sold_date_sk#27, i_brand_id#30, i_class_id#31, i_category_id#32]
Arguments: X

(123) AQEShuffleRead
Input [4]: [ws_sold_date_sk#27, i_brand_id#30, i_class_id#31, i_category_id#32]
Arguments: coalesced

(124) InputAdapter
Input [4]: [ws_sold_date_sk#27, i_brand_id#30, i_class_id#31, i_category_id#32]

(125) NativeSort
Input [4]: [ws_sold_date_sk#27, i_brand_id#30, i_class_id#31, i_category_id#32]
Arguments: [ws_sold_date_sk#27 ASC NULLS FIRST], false

(126) ReusedExchange [Reuses operator id: 60]
Output [1]: [d_date_sk#33]

(127) ShuffleQueryStage
Output [1]: [d_date_sk#33]
Arguments: X

(128) AQEShuffleRead
Input [1]: [d_date_sk#33]
Arguments: coalesced

(129) InputAdapter
Input [1]: [d_date_sk#33]
Arguments: [#33]

(130) InputAdapter
Input [1]: [#33#33]

(131) NativeSort
Input [1]: [#33#33]
Arguments: [d_date_sk#33 ASC NULLS FIRST], false

(132) NativeSortMergeJoin
Left keys [1]: [ws_sold_date_sk#27]
Right keys [1]: [d_date_sk#33]
Join type: Inner
Join condition: None

(133) NativeProject
Output [3]: [i_brand_id#30, i_class_id#31, i_category_id#32]
Input [5]: [ws_sold_date_sk#27, i_brand_id#30, i_class_id#31, i_category_id#32, #33#33]

(134) NativeShuffleExchange
Input [3]: [i_brand_id#30, i_class_id#31, i_category_id#32]
Arguments: hashpartitioning(coalesce(i_brand_id#30, 0), isnull(i_brand_id#30), coalesce(i_class_id#31, 0), isnull(i_class_id#31), coalesce(i_category_id#32, 0), isnull(i_category_id#32), 100), ENSURE_REQUIREMENTS, [plan_id=16]

(135) ShuffleQueryStage
Output [3]: [i_brand_id#30, i_class_id#31, i_category_id#32]
Arguments: X

(136) AQEShuffleRead
Input [3]: [i_brand_id#30, i_class_id#31, i_category_id#32]
Arguments: coalesced

(137) InputAdapter
Input [3]: [i_brand_id#30, i_class_id#31, i_category_id#32]

(138) NativeSort
Input [3]: [i_brand_id#30, i_class_id#31, i_category_id#32]
Arguments: [coalesce(i_brand_id#30, 0) ASC NULLS FIRST, isnull(i_brand_id#30) ASC NULLS FIRST, coalesce(i_class_id#31, 0) ASC NULLS FIRST, isnull(i_class_id#31) ASC NULLS FIRST, coalesce(i_category_id#32, 0) ASC NULLS FIRST, isnull(i_category_id#32) ASC NULLS FIRST], false

(139) NativeSortMergeJoin
Left keys [6]: [coalesce(brand_id#24, 0), isnull(brand_id#24), coalesce(class_id#25, 0), isnull(class_id#25), coalesce(category_id#26, 0), isnull(category_id#26)]
Right keys [6]: [coalesce(i_brand_id#30, 0), isnull(i_brand_id#30), coalesce(i_class_id#31, 0), isnull(i_class_id#31), coalesce(i_category_id#32, 0), isnull(i_category_id#32)]
Join type: LeftSemi
Join condition: None

(140) NativeShuffleExchange
Input [3]: [brand_id#24, class_id#25, category_id#26]
Arguments: hashpartitioning(brand_id#24, class_id#25, category_id#26, 100), ENSURE_REQUIREMENTS, [plan_id=17]

(141) ShuffleQueryStage
Output [3]: [brand_id#24, class_id#25, category_id#26]
Arguments: X

(142) AQEShuffleRead
Input [3]: [brand_id#24, class_id#25, category_id#26]
Arguments: coalesced

(143) InputAdapter
Input [3]: [brand_id#24, class_id#25, category_id#26]

(144) NativeSort
Input [3]: [brand_id#24, class_id#25, category_id#26]
Arguments: [brand_id#24 ASC NULLS FIRST, class_id#25 ASC NULLS FIRST, category_id#26 ASC NULLS FIRST], false

(145) NativeSortMergeJoin
Left keys [3]: [i_brand_id#6, i_class_id#7, i_category_id#8]
Right keys [3]: [brand_id#24, class_id#25, category_id#26]
Join type: Inner
Join condition: None

(146) NativeProject
Output [1]: [i_item_sk#5 AS ss_item_sk#34]
Input [7]: [#5#5, #6#6, #7#7, #8#8, brand_id#24, class_id#25, category_id#26]

(147) NativeShuffleExchange
Input [1]: [ss_item_sk#34]
Arguments: hashpartitioning(ss_item_sk#34, 100), ENSURE_REQUIREMENTS, [plan_id=18]

(148) ShuffleQueryStage
Output [1]: [ss_item_sk#34]
Arguments: X

(149) AQEShuffleRead
Input [1]: [ss_item_sk#34]
Arguments: coalesced

(150) InputAdapter
Input [1]: [ss_item_sk#34]

(151) NativeSort
Input [1]: [ss_item_sk#34]
Arguments: [ss_item_sk#34 ASC NULLS FIRST], false

(152) NativeSortMergeJoin
Left keys [1]: [ss_item_sk#2]
Right keys [1]: [ss_item_sk#34]
Join type: LeftSemi
Join condition: None

(153) ReusedExchange [Reuses operator id: 44]
Output [4]: [i_item_sk#35, i_brand_id#36, i_class_id#37, i_category_id#38]

(154) ShuffleQueryStage
Output [4]: [i_item_sk#35, i_brand_id#36, i_class_id#37, i_category_id#38]
Arguments: X

(155) AQEShuffleRead
Input [4]: [i_item_sk#35, i_brand_id#36, i_class_id#37, i_category_id#38]
Arguments: coalesced

(156) InputAdapter
Input [4]: [i_item_sk#35, i_brand_id#36, i_class_id#37, i_category_id#38]
Arguments: [#35, #36, #37, #38]

(157) InputAdapter
Input [4]: [#35#35, #36#36, #37#37, #38#38]

(158) NativeSort
Input [4]: [#35#35, #36#36, #37#37, #38#38]
Arguments: [i_item_sk#35 ASC NULLS FIRST], false

(159) ReusedExchange [Reuses operator id: 147]
Output [1]: [ss_item_sk#34]

(160) ShuffleQueryStage
Output [1]: [ss_item_sk#34]
Arguments: X

(161) AQEShuffleRead
Input [1]: [ss_item_sk#34]
Arguments: coalesced

(162) InputAdapter
Input [1]: [ss_item_sk#34]

(163) NativeSort
Input [1]: [ss_item_sk#34]
Arguments: [ss_item_sk#34 ASC NULLS FIRST], false

(164) NativeSortMergeJoin
Left keys [1]: [i_item_sk#35]
Right keys [1]: [ss_item_sk#34]
Join type: LeftSemi
Join condition: None

(165) NativeSortMergeJoin
Left keys [1]: [ss_item_sk#2]
Right keys [1]: [i_item_sk#35]
Join type: Inner
Join condition: None

(166) NativeProject
Output [6]: [ss_sold_date_sk#1, ss_quantity#3, ss_list_price#4, i_brand_id#36, i_class_id#37, i_category_id#38]
Input [8]: [#1#1, #2#2, #3#3, #4#4, #35#35, #36#36, #37#37, #38#38]

(167) NativeShuffleExchange
Input [6]: [ss_sold_date_sk#1, ss_quantity#3, ss_list_price#4, i_brand_id#36, i_class_id#37, i_category_id#38]
Arguments: hashpartitioning(ss_sold_date_sk#1, 100), ENSURE_REQUIREMENTS, [plan_id=19]

(168) ShuffleQueryStage
Output [6]: [ss_sold_date_sk#1, ss_quantity#3, ss_list_price#4, i_brand_id#36, i_class_id#37, i_category_id#38]
Arguments: X

(169) AQEShuffleRead
Input [6]: [ss_sold_date_sk#1, ss_quantity#3, ss_list_price#4, i_brand_id#36, i_class_id#37, i_category_id#38]
Arguments: coalesced

(170) InputAdapter
Input [6]: [ss_sold_date_sk#1, ss_quantity#3, ss_list_price#4, i_brand_id#36, i_class_id#37, i_category_id#38]

(171) NativeSort
Input [6]: [ss_sold_date_sk#1, ss_quantity#3, ss_list_price#4, i_brand_id#36, i_class_id#37, i_category_id#38]
Arguments: [ss_sold_date_sk#1 ASC NULLS FIRST], false

(484) Scan parquet
Output [3]: [d_date_sk#39, d_year#40, d_moy#41]
Batched: true
Location: InMemoryFileIndex [file:/<warehouse_dir>]
PushedFilters: [IsNotNull(d_year), IsNotNull(d_moy), EqualTo(d_year,2001), EqualTo(d_moy,11), IsNotNull(d_date_sk)]
ReadSchema: struct<d_date_sk:int,d_year:int,d_moy:int>

(173) InputAdapter
Input [3]: [d_date_sk#39, d_year#40, d_moy#41]
Arguments: [#39, #40, #41]

(174) NativeFilter
Input [3]: [#39#39, #40#40, #41#41]
Condition : ((((isnotnull(d_year#40) AND isnotnull(d_moy#41)) AND (d_year#40 = 2001)) AND (d_moy#41 = 11)) AND isnotnull(d_date_sk#39))

(175) NativeProject
Output [1]: [d_date_sk#39]
Input [3]: [#39#39, #40#40, #41#41]

(176) NativeShuffleExchange
Input [1]: [d_date_sk#39]
Arguments: hashpartitioning(d_date_sk#39, 100), ENSURE_REQUIREMENTS, [plan_id=20]

(177) ShuffleQueryStage
Output [1]: [d_date_sk#39]
Arguments: X

(178) AQEShuffleRead
Input [1]: [d_date_sk#39]
Arguments: coalesced

(179) InputAdapter
Input [1]: [d_date_sk#39]

(180) NativeSort
Input [1]: [d_date_sk#39]
Arguments: [d_date_sk#39 ASC NULLS FIRST], false

(181) NativeSortMergeJoin
Left keys [1]: [ss_sold_date_sk#1]
Right keys [1]: [d_date_sk#39]
Join type: Inner
Join condition: None

(182) NativeProject
Output [5]: [ss_quantity#3, ss_list_price#4, i_brand_id#36, i_class_id#37, i_category_id#38]
Input [7]: [ss_sold_date_sk#1, ss_quantity#3, ss_list_price#4, i_brand_id#36, i_class_id#37, i_category_id#38, d_date_sk#39]

(183) NativeProject
Output [4]: [i_brand_id#36 AS i_brand_id#36, i_class_id#37 AS i_class_id#37, i_category_id#38 AS i_category_id#38, (cast(ss_quantity#3 as decimal(10,0)) * ss_list_price#4) AS _c3#42]
Input [5]: [ss_quantity#3, ss_list_price#4, i_brand_id#36, i_class_id#37, i_category_id#38]

(184) NativeHashAggregate
Input [4]: [i_brand_id#36, i_class_id#37, i_category_id#38, _c3#42]
Keys [3]: [i_brand_id#36, i_class_id#37, i_category_id#38]
Functions [2]: [partial_sum(_c3#42), partial_count(1)]
Aggregate Attributes [3]: [sum#43, isEmpty#44, count#45]
Results [5]: [i_brand_id#36, i_class_id#37, i_category_id#38, #46, #47]

(185) NativeShuffleExchange
Input [5]: [i_brand_id#36, i_class_id#37, i_category_id#38, #46, #47]
Arguments: hashpartitioning(i_brand_id#36, i_class_id#37, i_category_id#38, 100), ENSURE_REQUIREMENTS, [plan_id=21]

(186) ShuffleQueryStage
Output [5]: [i_brand_id#36, i_class_id#37, i_category_id#38, #46, #47]
Arguments: X

(187) AQEShuffleRead
Input [5]: [i_brand_id#36, i_class_id#37, i_category_id#38, #46, #47]
Arguments: coalesced

(188) InputAdapter
Input [5]: [i_brand_id#36, i_class_id#37, i_category_id#38, #46, #47]

(189) NativeHashAggregate
Input [5]: [i_brand_id#36, i_class_id#37, i_category_id#38, #46, #47]
Keys [3]: [i_brand_id#36, i_class_id#37, i_category_id#38]
Functions [2]: [sum((cast(ss_quantity#3 as decimal(10,0)) * ss_list_price#4)), count(1)]
Aggregate Attributes [2]: [sum((cast(ss_quantity#3 as decimal(10,0)) * ss_list_price#4))#48, count(1)#49]
Results [5]: [i_brand_id#36, i_class_id#37, i_category_id#38, sum((cast(ss_quantity#3 as decimal(10,0)) * ss_list_price#4))#48, count(1)#49]

(190) NativeProject
Output [5]: [i_brand_id#36, i_class_id#37, i_category_id#38, sum((cast(ss_quantity#3 as decimal(10,0)) * ss_list_price#4))#48 AS sales#50, count(1)#49 AS number_sales#51]
Input [5]: [i_brand_id#36, i_class_id#37, i_category_id#38, sum((cast(ss_quantity#3 as decimal(10,0)) * ss_list_price#4))#48, count(1)#49]

(191) NativeFilter
Input [5]: [i_brand_id#36, i_class_id#37, i_category_id#38, sales#50, number_sales#51]
Condition : (isnotnull(sales#50) AND (cast(sales#50 as decimal(32,6)) > cast(Subquery subquery#52, [id=#53] as decimal(32,6))))

(192) NativeProject
Output [6]: [sales#50, number_sales#51, store AS channel#54, i_brand_id#36 AS i_brand_id#55, i_class_id#37 AS i_class_id#56, i_category_id#38 AS i_category_id#57]
Input [5]: [i_brand_id#36, i_class_id#37, i_category_id#38, sales#50, number_sales#51]

(496) Scan parquet
Output [4]: [cs_sold_date_sk#58, cs_item_sk#59, cs_quantity#60, cs_list_price#61]
Batched: true
Location: InMemoryFileIndex [file:/<warehouse_dir>]
PushedFilters: [IsNotNull(cs_item_sk), IsNotNull(cs_sold_date_sk)]
ReadSchema: struct<cs_sold_date_sk:int,cs_item_sk:int,cs_quantity:int,cs_list_price:decimal(7,2)>

(194) InputAdapter
Input [4]: [cs_sold_date_sk#58, cs_item_sk#59, cs_quantity#60, cs_list_price#61]
Arguments: [#58, #59, #60, #61]

(195) NativeFilter
Input [4]: [#58#58, #59#59, #60#60, #61#61]
Condition : (isnotnull(cs_item_sk#59) AND isnotnull(cs_sold_date_sk#58))

(196) NativeShuffleExchange
Input [4]: [#58#58, #59#59, #60#60, #61#61]
Arguments: hashpartitioning(cs_item_sk#59, 100), ENSURE_REQUIREMENTS, [plan_id=22]

(197) ShuffleQueryStage
Output [4]: [#58#58, #59#59, #60#60, #61#61]
Arguments: X

(198) AQEShuffleRead
Input [4]: [#58#58, #59#59, #60#60, #61#61]
Arguments: coalesced

(199) InputAdapter
Input [4]: [#58#58, #59#59, #60#60, #61#61]

(200) NativeSort
Input [4]: [#58#58, #59#59, #60#60, #61#61]
Arguments: [cs_item_sk#59 ASC NULLS FIRST], false

(201) ReusedExchange [Reuses operator id: 147]
Output [1]: [ss_item_sk#62]

(202) ShuffleQueryStage
Output [1]: [ss_item_sk#62]
Arguments: X

(203) AQEShuffleRead
Input [1]: [ss_item_sk#62]
Arguments: coalesced

(204) InputAdapter
Input [1]: [ss_item_sk#62]
Arguments: [#62]

(205) InputAdapter
Input [1]: [#62#62]

(206) NativeSort
Input [1]: [#62#62]
Arguments: [ss_item_sk#62 ASC NULLS FIRST], false

(207) NativeSortMergeJoin
Left keys [1]: [cs_item_sk#59]
Right keys [1]: [ss_item_sk#62]
Join type: LeftSemi
Join condition: None

(208) ReusedExchange [Reuses operator id: 44]
Output [4]: [i_item_sk#63, i_brand_id#64, i_class_id#65, i_category_id#66]

(209) ShuffleQueryStage
Output [4]: [i_item_sk#63, i_brand_id#64, i_class_id#65, i_category_id#66]
Arguments: X

(210) AQEShuffleRead
Input [4]: [i_item_sk#63, i_brand_id#64, i_class_id#65, i_category_id#66]
Arguments: coalesced

(211) InputAdapter
Input [4]: [i_item_sk#63, i_brand_id#64, i_class_id#65, i_category_id#66]
Arguments: [#63, #64, #65, #66]

(212) InputAdapter
Input [4]: [#63#63, #64#64, #65#65, #66#66]

(213) NativeSort
Input [4]: [#63#63, #64#64, #65#65, #66#66]
Arguments: [i_item_sk#63 ASC NULLS FIRST], false

(214) ReusedExchange [Reuses operator id: 147]
Output [1]: [ss_item_sk#62]

(215) ShuffleQueryStage
Output [1]: [ss_item_sk#62]
Arguments: X

(216) AQEShuffleRead
Input [1]: [ss_item_sk#62]
Arguments: coalesced

(217) InputAdapter
Input [1]: [ss_item_sk#62]
Arguments: [#62]

(218) InputAdapter
Input [1]: [#62#62]

(219) NativeSort
Input [1]: [#62#62]
Arguments: [ss_item_sk#62 ASC NULLS FIRST], false

(220) NativeSortMergeJoin
Left keys [1]: [i_item_sk#63]
Right keys [1]: [ss_item_sk#62]
Join type: LeftSemi
Join condition: None

(221) NativeSortMergeJoin
Left keys [1]: [cs_item_sk#59]
Right keys [1]: [i_item_sk#63]
Join type: Inner
Join condition: None

(222) NativeProject
Output [6]: [cs_sold_date_sk#58, cs_quantity#60, cs_list_price#61, i_brand_id#64, i_class_id#65, i_category_id#66]
Input [8]: [#58#58, #59#59, #60#60, #61#61, #63#63, #64#64, #65#65, #66#66]

(223) NativeShuffleExchange
Input [6]: [cs_sold_date_sk#58, cs_quantity#60, cs_list_price#61, i_brand_id#64, i_class_id#65, i_category_id#66]
Arguments: hashpartitioning(cs_sold_date_sk#58, 100), ENSURE_REQUIREMENTS, [plan_id=23]

(224) ShuffleQueryStage
Output [6]: [cs_sold_date_sk#58, cs_quantity#60, cs_list_price#61, i_brand_id#64, i_class_id#65, i_category_id#66]
Arguments: X

(225) AQEShuffleRead
Input [6]: [cs_sold_date_sk#58, cs_quantity#60, cs_list_price#61, i_brand_id#64, i_class_id#65, i_category_id#66]
Arguments: coalesced

(226) InputAdapter
Input [6]: [cs_sold_date_sk#58, cs_quantity#60, cs_list_price#61, i_brand_id#64, i_class_id#65, i_category_id#66]

(227) NativeSort
Input [6]: [cs_sold_date_sk#58, cs_quantity#60, cs_list_price#61, i_brand_id#64, i_class_id#65, i_category_id#66]
Arguments: [cs_sold_date_sk#58 ASC NULLS FIRST], false

(228) ReusedExchange [Reuses operator id: 176]
Output [1]: [d_date_sk#67]

(229) ShuffleQueryStage
Output [1]: [d_date_sk#67]
Arguments: X

(230) AQEShuffleRead
Input [1]: [d_date_sk#67]
Arguments: coalesced

(231) InputAdapter
Input [1]: [d_date_sk#67]
Arguments: [#67]

(232) InputAdapter
Input [1]: [#67#67]

(233) NativeSort
Input [1]: [#67#67]
Arguments: [d_date_sk#67 ASC NULLS FIRST], false

(234) NativeSortMergeJoin
Left keys [1]: [cs_sold_date_sk#58]
Right keys [1]: [d_date_sk#67]
Join type: Inner
Join condition: None

(235) NativeProject
Output [5]: [cs_quantity#60, cs_list_price#61, i_brand_id#64, i_class_id#65, i_category_id#66]
Input [7]: [cs_sold_date_sk#58, cs_quantity#60, cs_list_price#61, i_brand_id#64, i_class_id#65, i_category_id#66, #67#67]

(236) NativeProject
Output [4]: [i_brand_id#64 AS i_brand_id#64, i_class_id#65 AS i_class_id#65, i_category_id#66 AS i_category_id#66, (cast(cs_quantity#60 as decimal(10,0)) * cs_list_price#61) AS _c3#68]
Input [5]: [cs_quantity#60, cs_list_price#61, i_brand_id#64, i_class_id#65, i_category_id#66]

(237) NativeHashAggregate
Input [4]: [i_brand_id#64, i_class_id#65, i_category_id#66, _c3#68]
Keys [3]: [i_brand_id#64, i_class_id#65, i_category_id#66]
Functions [2]: [partial_sum(_c3#68), partial_count(1)]
Aggregate Attributes [3]: [sum#69, isEmpty#70, count#71]
Results [5]: [i_brand_id#64, i_class_id#65, i_category_id#66, #46, #47]

(238) NativeShuffleExchange
Input [5]: [i_brand_id#64, i_class_id#65, i_category_id#66, #46, #47]
Arguments: hashpartitioning(i_brand_id#64, i_class_id#65, i_category_id#66, 100), ENSURE_REQUIREMENTS, [plan_id=24]

(239) ShuffleQueryStage
Output [5]: [i_brand_id#64, i_class_id#65, i_category_id#66, #46, #47]
Arguments: X

(240) AQEShuffleRead
Input [5]: [i_brand_id#64, i_class_id#65, i_category_id#66, #46, #47]
Arguments: coalesced

(241) InputAdapter
Input [5]: [i_brand_id#64, i_class_id#65, i_category_id#66, #46, #47]

(242) NativeHashAggregate
Input [5]: [i_brand_id#64, i_class_id#65, i_category_id#66, #46, #47]
Keys [3]: [i_brand_id#64, i_class_id#65, i_category_id#66]
Functions [2]: [sum((cast(cs_quantity#60 as decimal(10,0)) * cs_list_price#61)), count(1)]
Aggregate Attributes [2]: [sum((cast(cs_quantity#60 as decimal(10,0)) * cs_list_price#61))#72, count(1)#73]
Results [5]: [i_brand_id#64, i_class_id#65, i_category_id#66, sum((cast(cs_quantity#60 as decimal(10,0)) * cs_list_price#61))#72, count(1)#73]

(243) NativeProject
Output [5]: [i_brand_id#64, i_class_id#65, i_category_id#66, sum((cast(cs_quantity#60 as decimal(10,0)) * cs_list_price#61))#72 AS sales#74, count(1)#73 AS number_sales#75]
Input [5]: [i_brand_id#64, i_class_id#65, i_category_id#66, sum((cast(cs_quantity#60 as decimal(10,0)) * cs_list_price#61))#72, count(1)#73]

(244) NativeFilter
Input [5]: [i_brand_id#64, i_class_id#65, i_category_id#66, sales#74, number_sales#75]
Condition : (isnotnull(sales#74) AND (cast(sales#74 as decimal(32,6)) > cast(ReusedSubquery Subquery subquery#52, [id=#53] as decimal(32,6))))

(245) NativeProject
Output [6]: [sales#74, number_sales#75, catalog AS channel#76, i_brand_id#64, i_class_id#65, i_category_id#66]
Input [5]: [i_brand_id#64, i_class_id#65, i_category_id#66, sales#74, number_sales#75]

(682) Scan parquet
Output [4]: [ws_sold_date_sk#77, ws_item_sk#78, ws_quantity#79, ws_list_price#80]
Batched: true
Location: InMemoryFileIndex [file:/<warehouse_dir>]
PushedFilters: [IsNotNull(ws_item_sk), IsNotNull(ws_sold_date_sk)]
ReadSchema: struct<ws_sold_date_sk:int,ws_item_sk:int,ws_quantity:int,ws_list_price:decimal(7,2)>

(247) InputAdapter
Input [4]: [ws_sold_date_sk#77, ws_item_sk#78, ws_quantity#79, ws_list_price#80]
Arguments: [#77, #78, #79, #80]

(248) NativeFilter
Input [4]: [#77#77, #78#78, #79#79, #80#80]
Condition : (isnotnull(ws_item_sk#78) AND isnotnull(ws_sold_date_sk#77))

(249) NativeShuffleExchange
Input [4]: [#77#77, #78#78, #79#79, #80#80]
Arguments: hashpartitioning(ws_item_sk#78, 100), ENSURE_REQUIREMENTS, [plan_id=25]

(250) ShuffleQueryStage
Output [4]: [#77#77, #78#78, #79#79, #80#80]
Arguments: X

(251) AQEShuffleRead
Input [4]: [#77#77, #78#78, #79#79, #80#80]
Arguments: coalesced

(252) InputAdapter
Input [4]: [#77#77, #78#78, #79#79, #80#80]

(253) NativeSort
Input [4]: [#77#77, #78#78, #79#79, #80#80]
Arguments: [ws_item_sk#78 ASC NULLS FIRST], false

(254) ReusedExchange [Reuses operator id: 147]
Output [1]: [ss_item_sk#81]

(255) ShuffleQueryStage
Output [1]: [ss_item_sk#81]
Arguments: X

(256) AQEShuffleRead
Input [1]: [ss_item_sk#81]
Arguments: coalesced

(257) InputAdapter
Input [1]: [ss_item_sk#81]
Arguments: [#81]

(258) InputAdapter
Input [1]: [#81#81]

(259) NativeSort
Input [1]: [#81#81]
Arguments: [ss_item_sk#81 ASC NULLS FIRST], false

(260) NativeSortMergeJoin
Left keys [1]: [ws_item_sk#78]
Right keys [1]: [ss_item_sk#81]
Join type: LeftSemi
Join condition: None

(261) ReusedExchange [Reuses operator id: 44]
Output [4]: [i_item_sk#82, i_brand_id#83, i_class_id#84, i_category_id#85]

(262) ShuffleQueryStage
Output [4]: [i_item_sk#82, i_brand_id#83, i_class_id#84, i_category_id#85]
Arguments: X

(263) AQEShuffleRead
Input [4]: [i_item_sk#82, i_brand_id#83, i_class_id#84, i_category_id#85]
Arguments: coalesced

(264) InputAdapter
Input [4]: [i_item_sk#82, i_brand_id#83, i_class_id#84, i_category_id#85]
Arguments: [#82, #83, #84, #85]

(265) InputAdapter
Input [4]: [#82#82, #83#83, #84#84, #85#85]

(266) NativeSort
Input [4]: [#82#82, #83#83, #84#84, #85#85]
Arguments: [i_item_sk#82 ASC NULLS FIRST], false

(267) ReusedExchange [Reuses operator id: 147]
Output [1]: [ss_item_sk#81]

(268) ShuffleQueryStage
Output [1]: [ss_item_sk#81]
Arguments: X

(269) AQEShuffleRead
Input [1]: [ss_item_sk#81]
Arguments: coalesced

(270) InputAdapter
Input [1]: [ss_item_sk#81]
Arguments: [#81]

(271) InputAdapter
Input [1]: [#81#81]

(272) NativeSort
Input [1]: [#81#81]
Arguments: [ss_item_sk#81 ASC NULLS FIRST], false

(273) NativeSortMergeJoin
Left keys [1]: [i_item_sk#82]
Right keys [1]: [ss_item_sk#81]
Join type: LeftSemi
Join condition: None

(274) NativeSortMergeJoin
Left keys [1]: [ws_item_sk#78]
Right keys [1]: [i_item_sk#82]
Join type: Inner
Join condition: None

(275) NativeProject
Output [6]: [ws_sold_date_sk#77, ws_quantity#79, ws_list_price#80, i_brand_id#83, i_class_id#84, i_category_id#85]
Input [8]: [#77#77, #78#78, #79#79, #80#80, #82#82, #83#83, #84#84, #85#85]

(276) NativeShuffleExchange
Input [6]: [ws_sold_date_sk#77, ws_quantity#79, ws_list_price#80, i_brand_id#83, i_class_id#84, i_category_id#85]
Arguments: hashpartitioning(ws_sold_date_sk#77, 100), ENSURE_REQUIREMENTS, [plan_id=26]

(277) ShuffleQueryStage
Output [6]: [ws_sold_date_sk#77, ws_quantity#79, ws_list_price#80, i_brand_id#83, i_class_id#84, i_category_id#85]
Arguments: X

(278) AQEShuffleRead
Input [6]: [ws_sold_date_sk#77, ws_quantity#79, ws_list_price#80, i_brand_id#83, i_class_id#84, i_category_id#85]
Arguments: coalesced

(279) InputAdapter
Input [6]: [ws_sold_date_sk#77, ws_quantity#79, ws_list_price#80, i_brand_id#83, i_class_id#84, i_category_id#85]

(280) NativeSort
Input [6]: [ws_sold_date_sk#77, ws_quantity#79, ws_list_price#80, i_brand_id#83, i_class_id#84, i_category_id#85]
Arguments: [ws_sold_date_sk#77 ASC NULLS FIRST], false

(281) ReusedExchange [Reuses operator id: 176]
Output [1]: [d_date_sk#86]

(282) ShuffleQueryStage
Output [1]: [d_date_sk#86]
Arguments: X

(283) AQEShuffleRead
Input [1]: [d_date_sk#86]
Arguments: coalesced

(284) InputAdapter
Input [1]: [d_date_sk#86]
Arguments: [#86]

(285) InputAdapter
Input [1]: [#86#86]

(286) NativeSort
Input [1]: [#86#86]
Arguments: [d_date_sk#86 ASC NULLS FIRST], false

(287) NativeSortMergeJoin
Left keys [1]: [ws_sold_date_sk#77]
Right keys [1]: [d_date_sk#86]
Join type: Inner
Join condition: None

(288) NativeProject
Output [5]: [ws_quantity#79, ws_list_price#80, i_brand_id#83, i_class_id#84, i_category_id#85]
Input [7]: [ws_sold_date_sk#77, ws_quantity#79, ws_list_price#80, i_brand_id#83, i_class_id#84, i_category_id#85, #86#86]

(289) NativeProject
Output [4]: [i_brand_id#83 AS i_brand_id#83, i_class_id#84 AS i_class_id#84, i_category_id#85 AS i_category_id#85, (cast(ws_quantity#79 as decimal(10,0)) * ws_list_price#80) AS _c3#87]
Input [5]: [ws_quantity#79, ws_list_price#80, i_brand_id#83, i_class_id#84, i_category_id#85]

(290) NativeHashAggregate
Input [4]: [i_brand_id#83, i_class_id#84, i_category_id#85, _c3#87]
Keys [3]: [i_brand_id#83, i_class_id#84, i_category_id#85]
Functions [2]: [partial_sum(_c3#87), partial_count(1)]
Aggregate Attributes [3]: [sum#88, isEmpty#89, count#90]
Results [5]: [i_brand_id#83, i_class_id#84, i_category_id#85, #46, #47]

(291) NativeShuffleExchange
Input [5]: [i_brand_id#83, i_class_id#84, i_category_id#85, #46, #47]
Arguments: hashpartitioning(i_brand_id#83, i_class_id#84, i_category_id#85, 100), ENSURE_REQUIREMENTS, [plan_id=27]

(292) ShuffleQueryStage
Output [5]: [i_brand_id#83, i_class_id#84, i_category_id#85, #46, #47]
Arguments: X

(293) AQEShuffleRead
Input [5]: [i_brand_id#83, i_class_id#84, i_category_id#85, #46, #47]
Arguments: coalesced

(294) InputAdapter
Input [5]: [i_brand_id#83, i_class_id#84, i_category_id#85, #46, #47]

(295) NativeHashAggregate
Input [5]: [i_brand_id#83, i_class_id#84, i_category_id#85, #46, #47]
Keys [3]: [i_brand_id#83, i_class_id#84, i_category_id#85]
Functions [2]: [sum((cast(ws_quantity#79 as decimal(10,0)) * ws_list_price#80)), count(1)]
Aggregate Attributes [2]: [sum((cast(ws_quantity#79 as decimal(10,0)) * ws_list_price#80))#91, count(1)#92]
Results [5]: [i_brand_id#83, i_class_id#84, i_category_id#85, sum((cast(ws_quantity#79 as decimal(10,0)) * ws_list_price#80))#91, count(1)#92]

(296) NativeProject
Output [5]: [i_brand_id#83, i_class_id#84, i_category_id#85, sum((cast(ws_quantity#79 as decimal(10,0)) * ws_list_price#80))#91 AS sales#93, count(1)#92 AS number_sales#94]
Input [5]: [i_brand_id#83, i_class_id#84, i_category_id#85, sum((cast(ws_quantity#79 as decimal(10,0)) * ws_list_price#80))#91, count(1)#92]

(297) NativeFilter
Input [5]: [i_brand_id#83, i_class_id#84, i_category_id#85, sales#93, number_sales#94]
Condition : (isnotnull(sales#93) AND (cast(sales#93 as decimal(32,6)) > cast(ReusedSubquery Subquery subquery#52, [id=#53] as decimal(32,6))))

(298) NativeProject
Output [6]: [sales#93, number_sales#94, web AS channel#95, i_brand_id#83, i_class_id#84, i_category_id#85]
Input [5]: [i_brand_id#83, i_class_id#84, i_category_id#85, sales#93, number_sales#94]

(299) NativeUnion
Arguments: [sales#50, number_sales#51, channel#54, i_brand_id#55, i_class_id#56, i_category_id#57]

(300) InputAdapter
Input [6]: [sales#50, number_sales#51, channel#54, i_brand_id#55, i_class_id#56, i_category_id#57]
Arguments: [#50, #96, #54, #55, #56, #57]

(301) NativeExpand
Input [6]: [#50#50, #96#51, #54#54, #55#55, #56#56, #57#57]
Arguments: [[sales#50, number_sales#51, channel#54, i_brand_id#55, i_class_id#56, i_category_id#57, 0], [sales#50, number_sales#51, channel#54, i_brand_id#55, i_class_id#56, null, 1], [sales#50, number_sales#51, channel#54, i_brand_id#55, null, null, 3], [sales#50, number_sales#51, channel#54, null, null, null, 7], [sales#50, number_sales#51, null, null, null, null, 15]], [sales#50, number_sales#51, channel#97, i_brand_id#98, i_class_id#99, i_category_id#100, spark_grouping_id#101]

(302) NativeHashAggregate
Input [7]: [sales#50, number_sales#51, channel#97, i_brand_id#98, i_class_id#99, i_category_id#100, spark_grouping_id#101]
Keys [5]: [channel#97, i_brand_id#98, i_class_id#99, i_category_id#100, spark_grouping_id#101]
Functions [2]: [partial_sum(sales#50), partial_sum(number_sales#51)]
Aggregate Attributes [3]: [sum#102, isEmpty#103, sum#104]
Results [7]: [channel#97, i_brand_id#98, i_class_id#99, i_category_id#100, spark_grouping_id#101, #46, #47]

(303) NativeShuffleExchange
Input [7]: [channel#97, i_brand_id#98, i_class_id#99, i_category_id#100, spark_grouping_id#101, #46, #47]
Arguments: hashpartitioning(channel#97, i_brand_id#98, i_class_id#99, i_category_id#100, spark_grouping_id#101, 100), ENSURE_REQUIREMENTS, [plan_id=28]

(304) ShuffleQueryStage
Output [7]: [channel#97, i_brand_id#98, i_class_id#99, i_category_id#100, spark_grouping_id#101, #46, #47]
Arguments: X

(305) AQEShuffleRead
Input [7]: [channel#97, i_brand_id#98, i_class_id#99, i_category_id#100, spark_grouping_id#101, #46, #47]
Arguments: coalesced

(306) InputAdapter
Input [7]: [channel#97, i_brand_id#98, i_class_id#99, i_category_id#100, spark_grouping_id#101, #46, #47]

(307) NativeHashAggregate
Input [7]: [channel#97, i_brand_id#98, i_class_id#99, i_category_id#100, spark_grouping_id#101, #46, #47]
Keys [5]: [channel#97, i_brand_id#98, i_class_id#99, i_category_id#100, spark_grouping_id#101]
Functions [2]: [sum(sales#50), sum(number_sales#51)]
Aggregate Attributes [2]: [sum(sales#50)#105, sum(number_sales#51)#106]
Results [7]: [channel#97, i_brand_id#98, i_class_id#99, i_category_id#100, spark_grouping_id#101, sum(sales#50)#105, sum(number_sales#51)#106]

(308) NativeProject
Output [6]: [channel#97, i_brand_id#98, i_class_id#99, i_category_id#100, sum(sales#50)#105 AS sum(sales)#107, sum(number_sales#51)#106 AS sum(number_sales)#108]
Input [7]: [channel#97, i_brand_id#98, i_class_id#99, i_category_id#100, spark_grouping_id#101, sum(sales#50)#105, sum(number_sales#51)#106]

(309) NativeTakeOrdered
Input [6]: [channel#97, i_brand_id#98, i_class_id#99, i_category_id#100, sum(sales)#107, sum(number_sales)#108]
Arguments: X, X, [channel#97 ASC NULLS FIRST, i_brand_id#98 ASC NULLS FIRST, i_class_id#99 ASC NULLS FIRST, i_category_id#100 ASC NULLS FIRST]

(310) Scan parquet
Output [4]: [ss_sold_date_sk#1, ss_item_sk#2, ss_quantity#3, ss_list_price#4]
Batched: true
Location: InMemoryFileIndex [file:/<warehouse_dir>]
PushedFilters: [IsNotNull(ss_item_sk), IsNotNull(ss_sold_date_sk)]
ReadSchema: struct<ss_sold_date_sk:int,ss_item_sk:int,ss_quantity:int,ss_list_price:decimal(7,2)>

(311) Filter
Input [4]: [ss_sold_date_sk#1, ss_item_sk#2, ss_quantity#3, ss_list_price#4]
Condition : (isnotnull(ss_item_sk#2) AND isnotnull(ss_sold_date_sk#1))

(312) Exchange
Input [4]: [ss_sold_date_sk#1, ss_item_sk#2, ss_quantity#3, ss_list_price#4]
Arguments: hashpartitioning(ss_item_sk#2, 100), ENSURE_REQUIREMENTS, [plan_id=29]

(313) Sort
Input [4]: [ss_sold_date_sk#1, ss_item_sk#2, ss_quantity#3, ss_list_price#4]
Arguments: [ss_item_sk#2 ASC NULLS FIRST], false, 0

(314) Scan parquet
Output [4]: [i_item_sk#5, i_brand_id#6, i_class_id#7, i_category_id#8]
Batched: true
Location: InMemoryFileIndex [file:/<warehouse_dir>]
PushedFilters: [IsNotNull(i_brand_id), IsNotNull(i_class_id), IsNotNull(i_category_id)]
ReadSchema: struct<i_item_sk:int,i_brand_id:int,i_class_id:int,i_category_id:int>

(315) Filter
Input [4]: [i_item_sk#5, i_brand_id#6, i_class_id#7, i_category_id#8]
Condition : ((isnotnull(i_brand_id#6) AND isnotnull(i_class_id#7)) AND isnotnull(i_category_id#8))

(316) Exchange
Input [4]: [i_item_sk#5, i_brand_id#6, i_class_id#7, i_category_id#8]
Arguments: hashpartitioning(i_brand_id#6, i_class_id#7, i_category_id#8, 100), ENSURE_REQUIREMENTS, [plan_id=30]

(317) Sort
Input [4]: [i_item_sk#5, i_brand_id#6, i_class_id#7, i_category_id#8]
Arguments: [i_brand_id#6 ASC NULLS FIRST, i_class_id#7 ASC NULLS FIRST, i_category_id#8 ASC NULLS FIRST], false, 0

(318) Scan parquet
Output [2]: [ss_sold_date_sk#9, ss_item_sk#10]
Batched: true
Location: InMemoryFileIndex [file:/<warehouse_dir>]
PushedFilters: [IsNotNull(ss_item_sk), IsNotNull(ss_sold_date_sk)]
ReadSchema: struct<ss_sold_date_sk:int,ss_item_sk:int>

(319) Filter
Input [2]: [ss_sold_date_sk#9, ss_item_sk#10]
Condition : (isnotnull(ss_item_sk#10) AND isnotnull(ss_sold_date_sk#9))

(320) Exchange
Input [2]: [ss_sold_date_sk#9, ss_item_sk#10]
Arguments: hashpartitioning(ss_item_sk#10, 100), ENSURE_REQUIREMENTS, [plan_id=31]

(321) Sort
Input [2]: [ss_sold_date_sk#9, ss_item_sk#10]
Arguments: [ss_item_sk#10 ASC NULLS FIRST], false, 0

(322) Scan parquet
Output [4]: [i_item_sk#11, i_brand_id#12, i_class_id#13, i_category_id#14]
Batched: true
Location: InMemoryFileIndex [file:/<warehouse_dir>]
PushedFilters: [IsNotNull(i_item_sk), IsNotNull(i_brand_id), IsNotNull(i_class_id), IsNotNull(i_category_id)]
ReadSchema: struct<i_item_sk:int,i_brand_id:int,i_class_id:int,i_category_id:int>

(323) Filter
Input [4]: [i_item_sk#11, i_brand_id#12, i_class_id#13, i_category_id#14]
Condition : (((isnotnull(i_item_sk#11) AND isnotnull(i_brand_id#12)) AND isnotnull(i_class_id#13)) AND isnotnull(i_category_id#14))

(324) Exchange
Input [4]: [i_item_sk#11, i_brand_id#12, i_class_id#13, i_category_id#14]
Arguments: hashpartitioning(coalesce(i_brand_id#12, 0), isnull(i_brand_id#12), coalesce(i_class_id#13, 0), isnull(i_class_id#13), coalesce(i_category_id#14, 0), isnull(i_category_id#14), 100), ENSURE_REQUIREMENTS, [plan_id=32]

(325) Sort
Input [4]: [i_item_sk#11, i_brand_id#12, i_class_id#13, i_category_id#14]
Arguments: [coalesce(i_brand_id#12, 0) ASC NULLS FIRST, isnull(i_brand_id#12) ASC NULLS FIRST, coalesce(i_class_id#13, 0) ASC NULLS FIRST, isnull(i_class_id#13) ASC NULLS FIRST, coalesce(i_category_id#14, 0) ASC NULLS FIRST, isnull(i_category_id#14) ASC NULLS FIRST], false, 0

(326) Scan parquet
Output [2]: [cs_sold_date_sk#15, cs_item_sk#16]
Batched: true
Location: InMemoryFileIndex [file:/<warehouse_dir>]
PushedFilters: [IsNotNull(cs_item_sk), IsNotNull(cs_sold_date_sk)]
ReadSchema: struct<cs_sold_date_sk:int,cs_item_sk:int>

(327) Filter
Input [2]: [cs_sold_date_sk#15, cs_item_sk#16]
Condition : (isnotnull(cs_item_sk#16) AND isnotnull(cs_sold_date_sk#15))

(328) Exchange
Input [2]: [cs_sold_date_sk#15, cs_item_sk#16]
Arguments: hashpartitioning(cs_item_sk#16, 100), ENSURE_REQUIREMENTS, [plan_id=33]

(329) Sort
Input [2]: [cs_sold_date_sk#15, cs_item_sk#16]
Arguments: [cs_item_sk#16 ASC NULLS FIRST], false, 0

(330) Scan parquet
Output [4]: [i_item_sk#17, i_brand_id#18, i_class_id#19, i_category_id#20]
Batched: true
Location: InMemoryFileIndex [file:/<warehouse_dir>]
PushedFilters: [IsNotNull(i_item_sk)]
ReadSchema: struct<i_item_sk:int,i_brand_id:int,i_class_id:int,i_category_id:int>

(331) Filter
Input [4]: [i_item_sk#17, i_brand_id#18, i_class_id#19, i_category_id#20]
Condition : isnotnull(i_item_sk#17)

(332) Exchange
Input [4]: [i_item_sk#17, i_brand_id#18, i_class_id#19, i_category_id#20]
Arguments: hashpartitioning(i_item_sk#17, 100), ENSURE_REQUIREMENTS, [plan_id=34]

(333) Sort
Input [4]: [i_item_sk#17, i_brand_id#18, i_class_id#19, i_category_id#20]
Arguments: [i_item_sk#17 ASC NULLS FIRST], false, 0

(334) SortMergeJoin
Left keys [1]: [cs_item_sk#16]
Right keys [1]: [i_item_sk#17]
Join type: Inner
Join condition: None

(335) Project
Output [4]: [cs_sold_date_sk#15, i_brand_id#18, i_class_id#19, i_category_id#20]
Input [6]: [cs_sold_date_sk#15, cs_item_sk#16, i_item_sk#17, i_brand_id#18, i_class_id#19, i_category_id#20]

(336) Exchange
Input [4]: [cs_sold_date_sk#15, i_brand_id#18, i_class_id#19, i_category_id#20]
Arguments: hashpartitioning(cs_sold_date_sk#15, 100), ENSURE_REQUIREMENTS, [plan_id=35]

(337) Sort
Input [4]: [cs_sold_date_sk#15, i_brand_id#18, i_class_id#19, i_category_id#20]
Arguments: [cs_sold_date_sk#15 ASC NULLS FIRST], false, 0

(338) Scan parquet
Output [2]: [d_date_sk#21, d_year#22]
Batched: true
Location: InMemoryFileIndex [file:/<warehouse_dir>]
PushedFilters: [IsNotNull(d_year), GreaterThanOrEqual(d_year,1999), LessThanOrEqual(d_year,2001), IsNotNull(d_date_sk)]
ReadSchema: struct<d_date_sk:int,d_year:int>

(339) Filter
Input [2]: [d_date_sk#21, d_year#22]
Condition : (((isnotnull(d_year#22) AND (d_year#22 >= 1999)) AND (d_year#22 <= 2001)) AND isnotnull(d_date_sk#21))

(340) Project
Output [1]: [d_date_sk#21]
Input [2]: [d_date_sk#21, d_year#22]

(341) Exchange
Input [1]: [d_date_sk#21]
Arguments: hashpartitioning(d_date_sk#21, 100), ENSURE_REQUIREMENTS, [plan_id=36]

(342) Sort
Input [1]: [d_date_sk#21]
Arguments: [d_date_sk#21 ASC NULLS FIRST], false, 0

(343) SortMergeJoin
Left keys [1]: [cs_sold_date_sk#15]
Right keys [1]: [d_date_sk#21]
Join type: Inner
Join condition: None

(344) Project
Output [3]: [i_brand_id#18, i_class_id#19, i_category_id#20]
Input [5]: [cs_sold_date_sk#15, i_brand_id#18, i_class_id#19, i_category_id#20, d_date_sk#21]

(345) Exchange
Input [3]: [i_brand_id#18, i_class_id#19, i_category_id#20]
Arguments: hashpartitioning(coalesce(i_brand_id#18, 0), isnull(i_brand_id#18), coalesce(i_class_id#19, 0), isnull(i_class_id#19), coalesce(i_category_id#20, 0), isnull(i_category_id#20), 100), ENSURE_REQUIREMENTS, [plan_id=37]

(346) Sort
Input [3]: [i_brand_id#18, i_class_id#19, i_category_id#20]
Arguments: [coalesce(i_brand_id#18, 0) ASC NULLS FIRST, isnull(i_brand_id#18) ASC NULLS FIRST, coalesce(i_class_id#19, 0) ASC NULLS FIRST, isnull(i_class_id#19) ASC NULLS FIRST, coalesce(i_category_id#20, 0) ASC NULLS FIRST, isnull(i_category_id#20) ASC NULLS FIRST], false, 0

(347) SortMergeJoin
Left keys [6]: [coalesce(i_brand_id#12, 0), isnull(i_brand_id#12), coalesce(i_class_id#13, 0), isnull(i_class_id#13), coalesce(i_category_id#14, 0), isnull(i_category_id#14)]
Right keys [6]: [coalesce(i_brand_id#18, 0), isnull(i_brand_id#18), coalesce(i_class_id#19, 0), isnull(i_class_id#19), coalesce(i_category_id#20, 0), isnull(i_category_id#20)]
Join type: LeftSemi
Join condition: None

(348) Exchange
Input [4]: [i_item_sk#11, i_brand_id#12, i_class_id#13, i_category_id#14]
Arguments: hashpartitioning(i_item_sk#11, 100), ENSURE_REQUIREMENTS, [plan_id=38]

(349) Sort
Input [4]: [i_item_sk#11, i_brand_id#12, i_class_id#13, i_category_id#14]
Arguments: [i_item_sk#11 ASC NULLS FIRST], false, 0

(350) SortMergeJoin
Left keys [1]: [ss_item_sk#10]
Right keys [1]: [i_item_sk#11]
Join type: Inner
Join condition: None

(351) Project
Output [4]: [ss_sold_date_sk#9, i_brand_id#12, i_class_id#13, i_category_id#14]
Input [6]: [ss_sold_date_sk#9, ss_item_sk#10, i_item_sk#11, i_brand_id#12, i_class_id#13, i_category_id#14]

(352) Exchange
Input [4]: [ss_sold_date_sk#9, i_brand_id#12, i_class_id#13, i_category_id#14]
Arguments: hashpartitioning(ss_sold_date_sk#9, 100), ENSURE_REQUIREMENTS, [plan_id=39]

(353) Sort
Input [4]: [ss_sold_date_sk#9, i_brand_id#12, i_class_id#13, i_category_id#14]
Arguments: [ss_sold_date_sk#9 ASC NULLS FIRST], false, 0

(354) Scan parquet
Output [2]: [d_date_sk#23, d_year#109]
Batched: true
Location: InMemoryFileIndex [file:/<warehouse_dir>]
PushedFilters: [IsNotNull(d_year), GreaterThanOrEqual(d_year,1999), LessThanOrEqual(d_year,2001), IsNotNull(d_date_sk)]
ReadSchema: struct<d_date_sk:int,d_year:int>

(355) Filter
Input [2]: [d_date_sk#23, d_year#109]
Condition : (((isnotnull(d_year#109) AND (d_year#109 >= 1999)) AND (d_year#109 <= 2001)) AND isnotnull(d_date_sk#23))

(356) Project
Output [1]: [d_date_sk#23]
Input [2]: [d_date_sk#23, d_year#109]

(357) Exchange
Input [1]: [d_date_sk#23]
Arguments: hashpartitioning(d_date_sk#23, 100), ENSURE_REQUIREMENTS, [plan_id=40]

(358) Sort
Input [1]: [d_date_sk#23]
Arguments: [d_date_sk#23 ASC NULLS FIRST], false, 0

(359) SortMergeJoin
Left keys [1]: [ss_sold_date_sk#9]
Right keys [1]: [d_date_sk#23]
Join type: Inner
Join condition: None

(360) Project
Output [3]: [i_brand_id#12 AS brand_id#24, i_class_id#13 AS class_id#25, i_category_id#14 AS category_id#26]
Input [5]: [ss_sold_date_sk#9, i_brand_id#12, i_class_id#13, i_category_id#14, d_date_sk#23]

(361) HashAggregate
Input [3]: [brand_id#24, class_id#25, category_id#26]
Keys [3]: [brand_id#24, class_id#25, category_id#26]
Functions: []
Aggregate Attributes: []
Results [3]: [brand_id#24, class_id#25, category_id#26]

(362) Exchange
Input [3]: [brand_id#24, class_id#25, category_id#26]
Arguments: hashpartitioning(brand_id#24, class_id#25, category_id#26, 100), ENSURE_REQUIREMENTS, [plan_id=41]

(363) HashAggregate
Input [3]: [brand_id#24, class_id#25, category_id#26]
Keys [3]: [brand_id#24, class_id#25, category_id#26]
Functions: []
Aggregate Attributes: []
Results [3]: [brand_id#24, class_id#25, category_id#26]

(364) Exchange
Input [3]: [brand_id#24, class_id#25, category_id#26]
Arguments: hashpartitioning(coalesce(brand_id#24, 0), isnull(brand_id#24), coalesce(class_id#25, 0), isnull(class_id#25), coalesce(category_id#26, 0), isnull(category_id#26), 100), ENSURE_REQUIREMENTS, [plan_id=42]

(365) Sort
Input [3]: [brand_id#24, class_id#25, category_id#26]
Arguments: [coalesce(brand_id#24, 0) ASC NULLS FIRST, isnull(brand_id#24) ASC NULLS FIRST, coalesce(class_id#25, 0) ASC NULLS FIRST, isnull(class_id#25) ASC NULLS FIRST, coalesce(category_id#26, 0) ASC NULLS FIRST, isnull(category_id#26) ASC NULLS FIRST], false, 0

(366) Scan parquet
Output [2]: [ws_sold_date_sk#27, ws_item_sk#28]
Batched: true
Location: InMemoryFileIndex [file:/<warehouse_dir>]
PushedFilters: [IsNotNull(ws_item_sk), IsNotNull(ws_sold_date_sk)]
ReadSchema: struct<ws_sold_date_sk:int,ws_item_sk:int>

(367) Filter
Input [2]: [ws_sold_date_sk#27, ws_item_sk#28]
Condition : (isnotnull(ws_item_sk#28) AND isnotnull(ws_sold_date_sk#27))

(368) Exchange
Input [2]: [ws_sold_date_sk#27, ws_item_sk#28]
Arguments: hashpartitioning(ws_item_sk#28, 100), ENSURE_REQUIREMENTS, [plan_id=43]

(369) Sort
Input [2]: [ws_sold_date_sk#27, ws_item_sk#28]
Arguments: [ws_item_sk#28 ASC NULLS FIRST], false, 0

(370) Scan parquet
Output [4]: [i_item_sk#29, i_brand_id#30, i_class_id#31, i_category_id#32]
Batched: true
Location: InMemoryFileIndex [file:/<warehouse_dir>]
PushedFilters: [IsNotNull(i_item_sk)]
ReadSchema: struct<i_item_sk:int,i_brand_id:int,i_class_id:int,i_category_id:int>

(371) Filter
Input [4]: [i_item_sk#29, i_brand_id#30, i_class_id#31, i_category_id#32]
Condition : isnotnull(i_item_sk#29)

(372) Exchange
Input [4]: [i_item_sk#29, i_brand_id#30, i_class_id#31, i_category_id#32]
Arguments: hashpartitioning(i_item_sk#29, 100), ENSURE_REQUIREMENTS, [plan_id=44]

(373) Sort
Input [4]: [i_item_sk#29, i_brand_id#30, i_class_id#31, i_category_id#32]
Arguments: [i_item_sk#29 ASC NULLS FIRST], false, 0

(374) SortMergeJoin
Left keys [1]: [ws_item_sk#28]
Right keys [1]: [i_item_sk#29]
Join type: Inner
Join condition: None

(375) Project
Output [4]: [ws_sold_date_sk#27, i_brand_id#30, i_class_id#31, i_category_id#32]
Input [6]: [ws_sold_date_sk#27, ws_item_sk#28, i_item_sk#29, i_brand_id#30, i_class_id#31, i_category_id#32]

(376) Exchange
Input [4]: [ws_sold_date_sk#27, i_brand_id#30, i_class_id#31, i_category_id#32]
Arguments: hashpartitioning(ws_sold_date_sk#27, 100), ENSURE_REQUIREMENTS, [plan_id=45]

(377) Sort
Input [4]: [ws_sold_date_sk#27, i_brand_id#30, i_class_id#31, i_category_id#32]
Arguments: [ws_sold_date_sk#27 ASC NULLS FIRST], false, 0

(378) Scan parquet
Output [2]: [d_date_sk#33, d_year#110]
Batched: true
Location: InMemoryFileIndex [file:/<warehouse_dir>]
PushedFilters: [IsNotNull(d_year), GreaterThanOrEqual(d_year,1999), LessThanOrEqual(d_year,2001), IsNotNull(d_date_sk)]
ReadSchema: struct<d_date_sk:int,d_year:int>

(379) Filter
Input [2]: [d_date_sk#33, d_year#110]
Condition : (((isnotnull(d_year#110) AND (d_year#110 >= 1999)) AND (d_year#110 <= 2001)) AND isnotnull(d_date_sk#33))

(380) Project
Output [1]: [d_date_sk#33]
Input [2]: [d_date_sk#33, d_year#110]

(381) Exchange
Input [1]: [d_date_sk#33]
Arguments: hashpartitioning(d_date_sk#33, 100), ENSURE_REQUIREMENTS, [plan_id=46]

(382) Sort
Input [1]: [d_date_sk#33]
Arguments: [d_date_sk#33 ASC NULLS FIRST], false, 0

(383) SortMergeJoin
Left keys [1]: [ws_sold_date_sk#27]
Right keys [1]: [d_date_sk#33]
Join type: Inner
Join condition: None

(384) Project
Output [3]: [i_brand_id#30, i_class_id#31, i_category_id#32]
Input [5]: [ws_sold_date_sk#27, i_brand_id#30, i_class_id#31, i_category_id#32, d_date_sk#33]

(385) Exchange
Input [3]: [i_brand_id#30, i_class_id#31, i_category_id#32]
Arguments: hashpartitioning(coalesce(i_brand_id#30, 0), isnull(i_brand_id#30), coalesce(i_class_id#31, 0), isnull(i_class_id#31), coalesce(i_category_id#32, 0), isnull(i_category_id#32), 100), ENSURE_REQUIREMENTS, [plan_id=47]

(386) Sort
Input [3]: [i_brand_id#30, i_class_id#31, i_category_id#32]
Arguments: [coalesce(i_brand_id#30, 0) ASC NULLS FIRST, isnull(i_brand_id#30) ASC NULLS FIRST, coalesce(i_class_id#31, 0) ASC NULLS FIRST, isnull(i_class_id#31) ASC NULLS FIRST, coalesce(i_category_id#32, 0) ASC NULLS FIRST, isnull(i_category_id#32) ASC NULLS FIRST], false, 0

(387) SortMergeJoin
Left keys [6]: [coalesce(brand_id#24, 0), isnull(brand_id#24), coalesce(class_id#25, 0), isnull(class_id#25), coalesce(category_id#26, 0), isnull(category_id#26)]
Right keys [6]: [coalesce(i_brand_id#30, 0), isnull(i_brand_id#30), coalesce(i_class_id#31, 0), isnull(i_class_id#31), coalesce(i_category_id#32, 0), isnull(i_category_id#32)]
Join type: LeftSemi
Join condition: None

(388) Exchange
Input [3]: [brand_id#24, class_id#25, category_id#26]
Arguments: hashpartitioning(brand_id#24, class_id#25, category_id#26, 100), ENSURE_REQUIREMENTS, [plan_id=48]

(389) Sort
Input [3]: [brand_id#24, class_id#25, category_id#26]
Arguments: [brand_id#24 ASC NULLS FIRST, class_id#25 ASC NULLS FIRST, category_id#26 ASC NULLS FIRST], false, 0

(390) SortMergeJoin
Left keys [3]: [i_brand_id#6, i_class_id#7, i_category_id#8]
Right keys [3]: [brand_id#24, class_id#25, category_id#26]
Join type: Inner
Join condition: None

(391) Project
Output [1]: [i_item_sk#5 AS ss_item_sk#34]
Input [7]: [i_item_sk#5, i_brand_id#6, i_class_id#7, i_category_id#8, brand_id#24, class_id#25, category_id#26]

(392) Exchange
Input [1]: [ss_item_sk#34]
Arguments: hashpartitioning(ss_item_sk#34, 100), ENSURE_REQUIREMENTS, [plan_id=49]

(393) Sort
Input [1]: [ss_item_sk#34]
Arguments: [ss_item_sk#34 ASC NULLS FIRST], false, 0

(394) SortMergeJoin
Left keys [1]: [ss_item_sk#2]
Right keys [1]: [ss_item_sk#34]
Join type: LeftSemi
Join condition: None

(395) Scan parquet
Output [4]: [i_item_sk#35, i_brand_id#36, i_class_id#37, i_category_id#38]
Batched: true
Location: InMemoryFileIndex [file:/<warehouse_dir>]
PushedFilters: [IsNotNull(i_item_sk)]
ReadSchema: struct<i_item_sk:int,i_brand_id:int,i_class_id:int,i_category_id:int>

(396) Filter
Input [4]: [i_item_sk#35, i_brand_id#36, i_class_id#37, i_category_id#38]
Condition : isnotnull(i_item_sk#35)

(397) Exchange
Input [4]: [i_item_sk#35, i_brand_id#36, i_class_id#37, i_category_id#38]
Arguments: hashpartitioning(i_item_sk#35, 100), ENSURE_REQUIREMENTS, [plan_id=50]

(398) Sort
Input [4]: [i_item_sk#35, i_brand_id#36, i_class_id#37, i_category_id#38]
Arguments: [i_item_sk#35 ASC NULLS FIRST], false, 0

(399) Scan parquet
Output [4]: [i_item_sk#5, i_brand_id#6, i_class_id#7, i_category_id#8]
Batched: true
Location: InMemoryFileIndex [file:/<warehouse_dir>]
PushedFilters: [IsNotNull(i_brand_id), IsNotNull(i_class_id), IsNotNull(i_category_id)]
ReadSchema: struct<i_item_sk:int,i_brand_id:int,i_class_id:int,i_category_id:int>

(400) Filter
Input [4]: [i_item_sk#5, i_brand_id#6, i_class_id#7, i_category_id#8]
Condition : ((isnotnull(i_brand_id#6) AND isnotnull(i_class_id#7)) AND isnotnull(i_category_id#8))

(401) Exchange
Input [4]: [i_item_sk#5, i_brand_id#6, i_class_id#7, i_category_id#8]
Arguments: hashpartitioning(i_brand_id#6, i_class_id#7, i_category_id#8, 100), ENSURE_REQUIREMENTS, [plan_id=51]

(402) Sort
Input [4]: [i_item_sk#5, i_brand_id#6, i_class_id#7, i_category_id#8]
Arguments: [i_brand_id#6 ASC NULLS FIRST, i_class_id#7 ASC NULLS FIRST, i_category_id#8 ASC NULLS FIRST], false, 0

(403) Scan parquet
Output [2]: [ss_sold_date_sk#9, ss_item_sk#10]
Batched: true
Location: InMemoryFileIndex [file:/<warehouse_dir>]
PushedFilters: [IsNotNull(ss_item_sk), IsNotNull(ss_sold_date_sk)]
ReadSchema: struct<ss_sold_date_sk:int,ss_item_sk:int>

(404) Filter
Input [2]: [ss_sold_date_sk#9, ss_item_sk#10]
Condition : (isnotnull(ss_item_sk#10) AND isnotnull(ss_sold_date_sk#9))

(405) Exchange
Input [2]: [ss_sold_date_sk#9, ss_item_sk#10]
Arguments: hashpartitioning(ss_item_sk#10, 100), ENSURE_REQUIREMENTS, [plan_id=52]

(406) Sort
Input [2]: [ss_sold_date_sk#9, ss_item_sk#10]
Arguments: [ss_item_sk#10 ASC NULLS FIRST], false, 0

(407) Scan parquet
Output [4]: [i_item_sk#11, i_brand_id#12, i_class_id#13, i_category_id#14]
Batched: true
Location: InMemoryFileIndex [file:/<warehouse_dir>]
PushedFilters: [IsNotNull(i_item_sk), IsNotNull(i_brand_id), IsNotNull(i_class_id), IsNotNull(i_category_id)]
ReadSchema: struct<i_item_sk:int,i_brand_id:int,i_class_id:int,i_category_id:int>

(408) Filter
Input [4]: [i_item_sk#11, i_brand_id#12, i_class_id#13, i_category_id#14]
Condition : (((isnotnull(i_item_sk#11) AND isnotnull(i_brand_id#12)) AND isnotnull(i_class_id#13)) AND isnotnull(i_category_id#14))

(409) Exchange
Input [4]: [i_item_sk#11, i_brand_id#12, i_class_id#13, i_category_id#14]
Arguments: hashpartitioning(coalesce(i_brand_id#12, 0), isnull(i_brand_id#12), coalesce(i_class_id#13, 0), isnull(i_class_id#13), coalesce(i_category_id#14, 0), isnull(i_category_id#14), 100), ENSURE_REQUIREMENTS, [plan_id=53]

(410) Sort
Input [4]: [i_item_sk#11, i_brand_id#12, i_class_id#13, i_category_id#14]
Arguments: [coalesce(i_brand_id#12, 0) ASC NULLS FIRST, isnull(i_brand_id#12) ASC NULLS FIRST, coalesce(i_class_id#13, 0) ASC NULLS FIRST, isnull(i_class_id#13) ASC NULLS FIRST, coalesce(i_category_id#14, 0) ASC NULLS FIRST, isnull(i_category_id#14) ASC NULLS FIRST], false, 0

(411) Scan parquet
Output [2]: [cs_sold_date_sk#15, cs_item_sk#16]
Batched: true
Location: InMemoryFileIndex [file:/<warehouse_dir>]
PushedFilters: [IsNotNull(cs_item_sk), IsNotNull(cs_sold_date_sk)]
ReadSchema: struct<cs_sold_date_sk:int,cs_item_sk:int>

(412) Filter
Input [2]: [cs_sold_date_sk#15, cs_item_sk#16]
Condition : (isnotnull(cs_item_sk#16) AND isnotnull(cs_sold_date_sk#15))

(413) Exchange
Input [2]: [cs_sold_date_sk#15, cs_item_sk#16]
Arguments: hashpartitioning(cs_item_sk#16, 100), ENSURE_REQUIREMENTS, [plan_id=54]

(414) Sort
Input [2]: [cs_sold_date_sk#15, cs_item_sk#16]
Arguments: [cs_item_sk#16 ASC NULLS FIRST], false, 0

(415) Scan parquet
Output [4]: [i_item_sk#17, i_brand_id#18, i_class_id#19, i_category_id#20]
Batched: true
Location: InMemoryFileIndex [file:/<warehouse_dir>]
PushedFilters: [IsNotNull(i_item_sk)]
ReadSchema: struct<i_item_sk:int,i_brand_id:int,i_class_id:int,i_category_id:int>

(416) Filter
Input [4]: [i_item_sk#17, i_brand_id#18, i_class_id#19, i_category_id#20]
Condition : isnotnull(i_item_sk#17)

(417) Exchange
Input [4]: [i_item_sk#17, i_brand_id#18, i_class_id#19, i_category_id#20]
Arguments: hashpartitioning(i_item_sk#17, 100), ENSURE_REQUIREMENTS, [plan_id=55]

(418) Sort
Input [4]: [i_item_sk#17, i_brand_id#18, i_class_id#19, i_category_id#20]
Arguments: [i_item_sk#17 ASC NULLS FIRST], false, 0

(419) SortMergeJoin
Left keys [1]: [cs_item_sk#16]
Right keys [1]: [i_item_sk#17]
Join type: Inner
Join condition: None

(420) Project
Output [4]: [cs_sold_date_sk#15, i_brand_id#18, i_class_id#19, i_category_id#20]
Input [6]: [cs_sold_date_sk#15, cs_item_sk#16, i_item_sk#17, i_brand_id#18, i_class_id#19, i_category_id#20]

(421) Exchange
Input [4]: [cs_sold_date_sk#15, i_brand_id#18, i_class_id#19, i_category_id#20]
Arguments: hashpartitioning(cs_sold_date_sk#15, 100), ENSURE_REQUIREMENTS, [plan_id=56]

(422) Sort
Input [4]: [cs_sold_date_sk#15, i_brand_id#18, i_class_id#19, i_category_id#20]
Arguments: [cs_sold_date_sk#15 ASC NULLS FIRST], false, 0

(423) Scan parquet
Output [2]: [d_date_sk#21, d_year#22]
Batched: true
Location: InMemoryFileIndex [file:/<warehouse_dir>]
PushedFilters: [IsNotNull(d_year), GreaterThanOrEqual(d_year,1999), LessThanOrEqual(d_year,2001), IsNotNull(d_date_sk)]
ReadSchema: struct<d_date_sk:int,d_year:int>

(424) Filter
Input [2]: [d_date_sk#21, d_year#22]
Condition : (((isnotnull(d_year#22) AND (d_year#22 >= 1999)) AND (d_year#22 <= 2001)) AND isnotnull(d_date_sk#21))

(425) Project
Output [1]: [d_date_sk#21]
Input [2]: [d_date_sk#21, d_year#22]

(426) Exchange
Input [1]: [d_date_sk#21]
Arguments: hashpartitioning(d_date_sk#21, 100), ENSURE_REQUIREMENTS, [plan_id=57]

(427) Sort
Input [1]: [d_date_sk#21]
Arguments: [d_date_sk#21 ASC NULLS FIRST], false, 0

(428) SortMergeJoin
Left keys [1]: [cs_sold_date_sk#15]
Right keys [1]: [d_date_sk#21]
Join type: Inner
Join condition: None

(429) Project
Output [3]: [i_brand_id#18, i_class_id#19, i_category_id#20]
Input [5]: [cs_sold_date_sk#15, i_brand_id#18, i_class_id#19, i_category_id#20, d_date_sk#21]

(430) Exchange
Input [3]: [i_brand_id#18, i_class_id#19, i_category_id#20]
Arguments: hashpartitioning(coalesce(i_brand_id#18, 0), isnull(i_brand_id#18), coalesce(i_class_id#19, 0), isnull(i_class_id#19), coalesce(i_category_id#20, 0), isnull(i_category_id#20), 100), ENSURE_REQUIREMENTS, [plan_id=58]

(431) Sort
Input [3]: [i_brand_id#18, i_class_id#19, i_category_id#20]
Arguments: [coalesce(i_brand_id#18, 0) ASC NULLS FIRST, isnull(i_brand_id#18) ASC NULLS FIRST, coalesce(i_class_id#19, 0) ASC NULLS FIRST, isnull(i_class_id#19) ASC NULLS FIRST, coalesce(i_category_id#20, 0) ASC NULLS FIRST, isnull(i_category_id#20) ASC NULLS FIRST], false, 0

(432) SortMergeJoin
Left keys [6]: [coalesce(i_brand_id#12, 0), isnull(i_brand_id#12), coalesce(i_class_id#13, 0), isnull(i_class_id#13), coalesce(i_category_id#14, 0), isnull(i_category_id#14)]
Right keys [6]: [coalesce(i_brand_id#18, 0), isnull(i_brand_id#18), coalesce(i_class_id#19, 0), isnull(i_class_id#19), coalesce(i_category_id#20, 0), isnull(i_category_id#20)]
Join type: LeftSemi
Join condition: None

(433) Exchange
Input [4]: [i_item_sk#11, i_brand_id#12, i_class_id#13, i_category_id#14]
Arguments: hashpartitioning(i_item_sk#11, 100), ENSURE_REQUIREMENTS, [plan_id=59]

(434) Sort
Input [4]: [i_item_sk#11, i_brand_id#12, i_class_id#13, i_category_id#14]
Arguments: [i_item_sk#11 ASC NULLS FIRST], false, 0

(435) SortMergeJoin
Left keys [1]: [ss_item_sk#10]
Right keys [1]: [i_item_sk#11]
Join type: Inner
Join condition: None

(436) Project
Output [4]: [ss_sold_date_sk#9, i_brand_id#12, i_class_id#13, i_category_id#14]
Input [6]: [ss_sold_date_sk#9, ss_item_sk#10, i_item_sk#11, i_brand_id#12, i_class_id#13, i_category_id#14]

(437) Exchange
Input [4]: [ss_sold_date_sk#9, i_brand_id#12, i_class_id#13, i_category_id#14]
Arguments: hashpartitioning(ss_sold_date_sk#9, 100), ENSURE_REQUIREMENTS, [plan_id=60]

(438) Sort
Input [4]: [ss_sold_date_sk#9, i_brand_id#12, i_class_id#13, i_category_id#14]
Arguments: [ss_sold_date_sk#9 ASC NULLS FIRST], false, 0

(439) Scan parquet
Output [2]: [d_date_sk#23, d_year#109]
Batched: true
Location: InMemoryFileIndex [file:/<warehouse_dir>]
PushedFilters: [IsNotNull(d_year), GreaterThanOrEqual(d_year,1999), LessThanOrEqual(d_year,2001), IsNotNull(d_date_sk)]
ReadSchema: struct<d_date_sk:int,d_year:int>

(440) Filter
Input [2]: [d_date_sk#23, d_year#109]
Condition : (((isnotnull(d_year#109) AND (d_year#109 >= 1999)) AND (d_year#109 <= 2001)) AND isnotnull(d_date_sk#23))

(441) Project
Output [1]: [d_date_sk#23]
Input [2]: [d_date_sk#23, d_year#109]

(442) Exchange
Input [1]: [d_date_sk#23]
Arguments: hashpartitioning(d_date_sk#23, 100), ENSURE_REQUIREMENTS, [plan_id=61]

(443) Sort
Input [1]: [d_date_sk#23]
Arguments: [d_date_sk#23 ASC NULLS FIRST], false, 0

(444) SortMergeJoin
Left keys [1]: [ss_sold_date_sk#9]
Right keys [1]: [d_date_sk#23]
Join type: Inner
Join condition: None

(445) Project
Output [3]: [i_brand_id#12 AS brand_id#24, i_class_id#13 AS class_id#25, i_category_id#14 AS category_id#26]
Input [5]: [ss_sold_date_sk#9, i_brand_id#12, i_class_id#13, i_category_id#14, d_date_sk#23]

(446) HashAggregate
Input [3]: [brand_id#24, class_id#25, category_id#26]
Keys [3]: [brand_id#24, class_id#25, category_id#26]
Functions: []
Aggregate Attributes: []
Results [3]: [brand_id#24, class_id#25, category_id#26]

(447) Exchange
Input [3]: [brand_id#24, class_id#25, category_id#26]
Arguments: hashpartitioning(brand_id#24, class_id#25, category_id#26, 100), ENSURE_REQUIREMENTS, [plan_id=62]

(448) HashAggregate
Input [3]: [brand_id#24, class_id#25, category_id#26]
Keys [3]: [brand_id#24, class_id#25, category_id#26]
Functions: []
Aggregate Attributes: []
Results [3]: [brand_id#24, class_id#25, category_id#26]

(449) Exchange
Input [3]: [brand_id#24, class_id#25, category_id#26]
Arguments: hashpartitioning(coalesce(brand_id#24, 0), isnull(brand_id#24), coalesce(class_id#25, 0), isnull(class_id#25), coalesce(category_id#26, 0), isnull(category_id#26), 100), ENSURE_REQUIREMENTS, [plan_id=63]

(450) Sort
Input [3]: [brand_id#24, class_id#25, category_id#26]
Arguments: [coalesce(brand_id#24, 0) ASC NULLS FIRST, isnull(brand_id#24) ASC NULLS FIRST, coalesce(class_id#25, 0) ASC NULLS FIRST, isnull(class_id#25) ASC NULLS FIRST, coalesce(category_id#26, 0) ASC NULLS FIRST, isnull(category_id#26) ASC NULLS FIRST], false, 0

(451) Scan parquet
Output [2]: [ws_sold_date_sk#27, ws_item_sk#28]
Batched: true
Location: InMemoryFileIndex [file:/<warehouse_dir>]
PushedFilters: [IsNotNull(ws_item_sk), IsNotNull(ws_sold_date_sk)]
ReadSchema: struct<ws_sold_date_sk:int,ws_item_sk:int>

(452) Filter
Input [2]: [ws_sold_date_sk#27, ws_item_sk#28]
Condition : (isnotnull(ws_item_sk#28) AND isnotnull(ws_sold_date_sk#27))

(453) Exchange
Input [2]: [ws_sold_date_sk#27, ws_item_sk#28]
Arguments: hashpartitioning(ws_item_sk#28, 100), ENSURE_REQUIREMENTS, [plan_id=64]

(454) Sort
Input [2]: [ws_sold_date_sk#27, ws_item_sk#28]
Arguments: [ws_item_sk#28 ASC NULLS FIRST], false, 0

(455) Scan parquet
Output [4]: [i_item_sk#29, i_brand_id#30, i_class_id#31, i_category_id#32]
Batched: true
Location: InMemoryFileIndex [file:/<warehouse_dir>]
PushedFilters: [IsNotNull(i_item_sk)]
ReadSchema: struct<i_item_sk:int,i_brand_id:int,i_class_id:int,i_category_id:int>

(456) Filter
Input [4]: [i_item_sk#29, i_brand_id#30, i_class_id#31, i_category_id#32]
Condition : isnotnull(i_item_sk#29)

(457) Exchange
Input [4]: [i_item_sk#29, i_brand_id#30, i_class_id#31, i_category_id#32]
Arguments: hashpartitioning(i_item_sk#29, 100), ENSURE_REQUIREMENTS, [plan_id=65]

(458) Sort
Input [4]: [i_item_sk#29, i_brand_id#30, i_class_id#31, i_category_id#32]
Arguments: [i_item_sk#29 ASC NULLS FIRST], false, 0

(459) SortMergeJoin
Left keys [1]: [ws_item_sk#28]
Right keys [1]: [i_item_sk#29]
Join type: Inner
Join condition: None

(460) Project
Output [4]: [ws_sold_date_sk#27, i_brand_id#30, i_class_id#31, i_category_id#32]
Input [6]: [ws_sold_date_sk#27, ws_item_sk#28, i_item_sk#29, i_brand_id#30, i_class_id#31, i_category_id#32]

(461) Exchange
Input [4]: [ws_sold_date_sk#27, i_brand_id#30, i_class_id#31, i_category_id#32]
Arguments: hashpartitioning(ws_sold_date_sk#27, 100), ENSURE_REQUIREMENTS, [plan_id=66]

(462) Sort
Input [4]: [ws_sold_date_sk#27, i_brand_id#30, i_class_id#31, i_category_id#32]
Arguments: [ws_sold_date_sk#27 ASC NULLS FIRST], false, 0

(463) Scan parquet
Output [2]: [d_date_sk#33, d_year#110]
Batched: true
Location: InMemoryFileIndex [file:/<warehouse_dir>]
PushedFilters: [IsNotNull(d_year), GreaterThanOrEqual(d_year,1999), LessThanOrEqual(d_year,2001), IsNotNull(d_date_sk)]
ReadSchema: struct<d_date_sk:int,d_year:int>

(464) Filter
Input [2]: [d_date_sk#33, d_year#110]
Condition : (((isnotnull(d_year#110) AND (d_year#110 >= 1999)) AND (d_year#110 <= 2001)) AND isnotnull(d_date_sk#33))

(465) Project
Output [1]: [d_date_sk#33]
Input [2]: [d_date_sk#33, d_year#110]

(466) Exchange
Input [1]: [d_date_sk#33]
Arguments: hashpartitioning(d_date_sk#33, 100), ENSURE_REQUIREMENTS, [plan_id=67]

(467) Sort
Input [1]: [d_date_sk#33]
Arguments: [d_date_sk#33 ASC NULLS FIRST], false, 0

(468) SortMergeJoin
Left keys [1]: [ws_sold_date_sk#27]
Right keys [1]: [d_date_sk#33]
Join type: Inner
Join condition: None

(469) Project
Output [3]: [i_brand_id#30, i_class_id#31, i_category_id#32]
Input [5]: [ws_sold_date_sk#27, i_brand_id#30, i_class_id#31, i_category_id#32, d_date_sk#33]

(470) Exchange
Input [3]: [i_brand_id#30, i_class_id#31, i_category_id#32]
Arguments: hashpartitioning(coalesce(i_brand_id#30, 0), isnull(i_brand_id#30), coalesce(i_class_id#31, 0), isnull(i_class_id#31), coalesce(i_category_id#32, 0), isnull(i_category_id#32), 100), ENSURE_REQUIREMENTS, [plan_id=68]

(471) Sort
Input [3]: [i_brand_id#30, i_class_id#31, i_category_id#32]
Arguments: [coalesce(i_brand_id#30, 0) ASC NULLS FIRST, isnull(i_brand_id#30) ASC NULLS FIRST, coalesce(i_class_id#31, 0) ASC NULLS FIRST, isnull(i_class_id#31) ASC NULLS FIRST, coalesce(i_category_id#32, 0) ASC NULLS FIRST, isnull(i_category_id#32) ASC NULLS FIRST], false, 0

(472) SortMergeJoin
Left keys [6]: [coalesce(brand_id#24, 0), isnull(brand_id#24), coalesce(class_id#25, 0), isnull(class_id#25), coalesce(category_id#26, 0), isnull(category_id#26)]
Right keys [6]: [coalesce(i_brand_id#30, 0), isnull(i_brand_id#30), coalesce(i_class_id#31, 0), isnull(i_class_id#31), coalesce(i_category_id#32, 0), isnull(i_category_id#32)]
Join type: LeftSemi
Join condition: None

(473) Exchange
Input [3]: [brand_id#24, class_id#25, category_id#26]
Arguments: hashpartitioning(brand_id#24, class_id#25, category_id#26, 100), ENSURE_REQUIREMENTS, [plan_id=69]

(474) Sort
Input [3]: [brand_id#24, class_id#25, category_id#26]
Arguments: [brand_id#24 ASC NULLS FIRST, class_id#25 ASC NULLS FIRST, category_id#26 ASC NULLS FIRST], false, 0

(475) SortMergeJoin
Left keys [3]: [i_brand_id#6, i_class_id#7, i_category_id#8]
Right keys [3]: [brand_id#24, class_id#25, category_id#26]
Join type: Inner
Join condition: None

(476) Project
Output [1]: [i_item_sk#5 AS ss_item_sk#34]
Input [7]: [i_item_sk#5, i_brand_id#6, i_class_id#7, i_category_id#8, brand_id#24, class_id#25, category_id#26]

(477) Exchange
Input [1]: [ss_item_sk#34]
Arguments: hashpartitioning(ss_item_sk#34, 100), ENSURE_REQUIREMENTS, [plan_id=70]

(478) Sort
Input [1]: [ss_item_sk#34]
Arguments: [ss_item_sk#34 ASC NULLS FIRST], false, 0

(479) SortMergeJoin
Left keys [1]: [i_item_sk#35]
Right keys [1]: [ss_item_sk#34]
Join type: LeftSemi
Join condition: None

(480) SortMergeJoin
Left keys [1]: [ss_item_sk#2]
Right keys [1]: [i_item_sk#35]
Join type: Inner
Join condition: None

(481) Project
Output [6]: [ss_sold_date_sk#1, ss_quantity#3, ss_list_price#4, i_brand_id#36, i_class_id#37, i_category_id#38]
Input [8]: [ss_sold_date_sk#1, ss_item_sk#2, ss_quantity#3, ss_list_price#4, i_item_sk#35, i_brand_id#36, i_class_id#37, i_category_id#38]

(482) Exchange
Input [6]: [ss_sold_date_sk#1, ss_quantity#3, ss_list_price#4, i_brand_id#36, i_class_id#37, i_category_id#38]
Arguments: hashpartitioning(ss_sold_date_sk#1, 100), ENSURE_REQUIREMENTS, [plan_id=71]

(483) Sort
Input [6]: [ss_sold_date_sk#1, ss_quantity#3, ss_list_price#4, i_brand_id#36, i_class_id#37, i_category_id#38]
Arguments: [ss_sold_date_sk#1 ASC NULLS FIRST], false, 0

(484) Scan parquet
Output [3]: [d_date_sk#39, d_year#40, d_moy#41]
Batched: true
Location: InMemoryFileIndex [file:/<warehouse_dir>]
PushedFilters: [IsNotNull(d_year), IsNotNull(d_moy), EqualTo(d_year,2001), EqualTo(d_moy,11), IsNotNull(d_date_sk)]
ReadSchema: struct<d_date_sk:int,d_year:int,d_moy:int>

(485) Filter
Input [3]: [d_date_sk#39, d_year#40, d_moy#41]
Condition : ((((isnotnull(d_year#40) AND isnotnull(d_moy#41)) AND (d_year#40 = 2001)) AND (d_moy#41 = 11)) AND isnotnull(d_date_sk#39))

(486) Project
Output [1]: [d_date_sk#39]
Input [3]: [d_date_sk#39, d_year#40, d_moy#41]

(487) Exchange
Input [1]: [d_date_sk#39]
Arguments: hashpartitioning(d_date_sk#39, 100), ENSURE_REQUIREMENTS, [plan_id=72]

(488) Sort
Input [1]: [d_date_sk#39]
Arguments: [d_date_sk#39 ASC NULLS FIRST], false, 0

(489) SortMergeJoin
Left keys [1]: [ss_sold_date_sk#1]
Right keys [1]: [d_date_sk#39]
Join type: Inner
Join condition: None

(490) Project
Output [5]: [ss_quantity#3, ss_list_price#4, i_brand_id#36, i_class_id#37, i_category_id#38]
Input [7]: [ss_sold_date_sk#1, ss_quantity#3, ss_list_price#4, i_brand_id#36, i_class_id#37, i_category_id#38, d_date_sk#39]

(491) HashAggregate
Input [5]: [ss_quantity#3, ss_list_price#4, i_brand_id#36, i_class_id#37, i_category_id#38]
Keys [3]: [i_brand_id#36, i_class_id#37, i_category_id#38]
Functions [2]: [partial_sum((cast(ss_quantity#3 as decimal(10,0)) * ss_list_price#4)), partial_count(1)]
Aggregate Attributes [3]: [sum#43, isEmpty#44, count#45]
Results [6]: [i_brand_id#36, i_class_id#37, i_category_id#38, sum#111, isEmpty#112, count#113]

(492) Exchange
Input [6]: [i_brand_id#36, i_class_id#37, i_category_id#38, sum#111, isEmpty#112, count#113]
Arguments: hashpartitioning(i_brand_id#36, i_class_id#37, i_category_id#38, 100), ENSURE_REQUIREMENTS, [plan_id=73]

(493) HashAggregate
Input [6]: [i_brand_id#36, i_class_id#37, i_category_id#38, sum#111, isEmpty#112, count#113]
Keys [3]: [i_brand_id#36, i_class_id#37, i_category_id#38]
Functions [2]: [sum((cast(ss_quantity#3 as decimal(10,0)) * ss_list_price#4)), count(1)]
Aggregate Attributes [2]: [sum((cast(ss_quantity#3 as decimal(10,0)) * ss_list_price#4))#48, count(1)#49]
Results [5]: [i_brand_id#36, i_class_id#37, i_category_id#38, sum((cast(ss_quantity#3 as decimal(10,0)) * ss_list_price#4))#48 AS sales#50, count(1)#49 AS number_sales#51]

(494) Filter
Input [5]: [i_brand_id#36, i_class_id#37, i_category_id#38, sales#50, number_sales#51]
Condition : (isnotnull(sales#50) AND (cast(sales#50 as decimal(32,6)) > cast(Subquery subquery#52, [id=#53] as decimal(32,6))))

(495) Project
Output [6]: [sales#50, number_sales#51, store AS channel#54, i_brand_id#36 AS i_brand_id#55, i_class_id#37 AS i_class_id#56, i_category_id#38 AS i_category_id#57]
Input [5]: [i_brand_id#36, i_class_id#37, i_category_id#38, sales#50, number_sales#51]

(496) Scan parquet
Output [4]: [cs_sold_date_sk#58, cs_item_sk#59, cs_quantity#60, cs_list_price#61]
Batched: true
Location: InMemoryFileIndex [file:/<warehouse_dir>]
PushedFilters: [IsNotNull(cs_item_sk), IsNotNull(cs_sold_date_sk)]
ReadSchema: struct<cs_sold_date_sk:int,cs_item_sk:int,cs_quantity:int,cs_list_price:decimal(7,2)>

(497) Filter
Input [4]: [cs_sold_date_sk#58, cs_item_sk#59, cs_quantity#60, cs_list_price#61]
Condition : (isnotnull(cs_item_sk#59) AND isnotnull(cs_sold_date_sk#58))

(498) Exchange
Input [4]: [cs_sold_date_sk#58, cs_item_sk#59, cs_quantity#60, cs_list_price#61]
Arguments: hashpartitioning(cs_item_sk#59, 100), ENSURE_REQUIREMENTS, [plan_id=74]

(499) Sort
Input [4]: [cs_sold_date_sk#58, cs_item_sk#59, cs_quantity#60, cs_list_price#61]
Arguments: [cs_item_sk#59 ASC NULLS FIRST], false, 0

(500) Scan parquet
Output [4]: [i_item_sk#114, i_brand_id#115, i_class_id#116, i_category_id#117]
Batched: true
Location: InMemoryFileIndex [file:/<warehouse_dir>]
PushedFilters: [IsNotNull(i_brand_id), IsNotNull(i_class_id), IsNotNull(i_category_id)]
ReadSchema: struct<i_item_sk:int,i_brand_id:int,i_class_id:int,i_category_id:int>

(501) Filter
Input [4]: [i_item_sk#114, i_brand_id#115, i_class_id#116, i_category_id#117]
Condition : ((isnotnull(i_brand_id#115) AND isnotnull(i_class_id#116)) AND isnotnull(i_category_id#117))

(502) Exchange
Input [4]: [i_item_sk#114, i_brand_id#115, i_class_id#116, i_category_id#117]
Arguments: hashpartitioning(i_brand_id#115, i_class_id#116, i_category_id#117, 100), ENSURE_REQUIREMENTS, [plan_id=75]

(503) Sort
Input [4]: [i_item_sk#114, i_brand_id#115, i_class_id#116, i_category_id#117]
Arguments: [i_brand_id#115 ASC NULLS FIRST, i_class_id#116 ASC NULLS FIRST, i_category_id#117 ASC NULLS FIRST], false, 0

(504) Scan parquet
Output [2]: [ss_sold_date_sk#118, ss_item_sk#119]
Batched: true
Location: InMemoryFileIndex [file:/<warehouse_dir>]
PushedFilters: [IsNotNull(ss_item_sk), IsNotNull(ss_sold_date_sk)]
ReadSchema: struct<ss_sold_date_sk:int,ss_item_sk:int>

(505) Filter
Input [2]: [ss_sold_date_sk#118, ss_item_sk#119]
Condition : (isnotnull(ss_item_sk#119) AND isnotnull(ss_sold_date_sk#118))

(506) Exchange
Input [2]: [ss_sold_date_sk#118, ss_item_sk#119]
Arguments: hashpartitioning(ss_item_sk#119, 100), ENSURE_REQUIREMENTS, [plan_id=76]

(507) Sort
Input [2]: [ss_sold_date_sk#118, ss_item_sk#119]
Arguments: [ss_item_sk#119 ASC NULLS FIRST], false, 0

(508) Scan parquet
Output [4]: [i_item_sk#120, i_brand_id#121, i_class_id#122, i_category_id#123]
Batched: true
Location: InMemoryFileIndex [file:/<warehouse_dir>]
PushedFilters: [IsNotNull(i_item_sk), IsNotNull(i_brand_id), IsNotNull(i_class_id), IsNotNull(i_category_id)]
ReadSchema: struct<i_item_sk:int,i_brand_id:int,i_class_id:int,i_category_id:int>

(509) Filter
Input [4]: [i_item_sk#120, i_brand_id#121, i_class_id#122, i_category_id#123]
Condition : (((isnotnull(i_item_sk#120) AND isnotnull(i_brand_id#121)) AND isnotnull(i_class_id#122)) AND isnotnull(i_category_id#123))

(510) Exchange
Input [4]: [i_item_sk#120, i_brand_id#121, i_class_id#122, i_category_id#123]
Arguments: hashpartitioning(coalesce(i_brand_id#121, 0), isnull(i_brand_id#121), coalesce(i_class_id#122, 0), isnull(i_class_id#122), coalesce(i_category_id#123, 0), isnull(i_category_id#123), 100), ENSURE_REQUIREMENTS, [plan_id=77]

(511) Sort
Input [4]: [i_item_sk#120, i_brand_id#121, i_class_id#122, i_category_id#123]
Arguments: [coalesce(i_brand_id#121, 0) ASC NULLS FIRST, isnull(i_brand_id#121) ASC NULLS FIRST, coalesce(i_class_id#122, 0) ASC NULLS FIRST, isnull(i_class_id#122) ASC NULLS FIRST, coalesce(i_category_id#123, 0) ASC NULLS FIRST, isnull(i_category_id#123) ASC NULLS FIRST], false, 0

(512) Scan parquet
Output [2]: [cs_sold_date_sk#124, cs_item_sk#125]
Batched: true
Location: InMemoryFileIndex [file:/<warehouse_dir>]
PushedFilters: [IsNotNull(cs_item_sk), IsNotNull(cs_sold_date_sk)]
ReadSchema: struct<cs_sold_date_sk:int,cs_item_sk:int>

(513) Filter
Input [2]: [cs_sold_date_sk#124, cs_item_sk#125]
Condition : (isnotnull(cs_item_sk#125) AND isnotnull(cs_sold_date_sk#124))

(514) Exchange
Input [2]: [cs_sold_date_sk#124, cs_item_sk#125]
Arguments: hashpartitioning(cs_item_sk#125, 100), ENSURE_REQUIREMENTS, [plan_id=78]

(515) Sort
Input [2]: [cs_sold_date_sk#124, cs_item_sk#125]
Arguments: [cs_item_sk#125 ASC NULLS FIRST], false, 0

(516) Scan parquet
Output [4]: [i_item_sk#126, i_brand_id#127, i_class_id#128, i_category_id#129]
Batched: true
Location: InMemoryFileIndex [file:/<warehouse_dir>]
PushedFilters: [IsNotNull(i_item_sk)]
ReadSchema: struct<i_item_sk:int,i_brand_id:int,i_class_id:int,i_category_id:int>

(517) Filter
Input [4]: [i_item_sk#126, i_brand_id#127, i_class_id#128, i_category_id#129]
Condition : isnotnull(i_item_sk#126)

(518) Exchange
Input [4]: [i_item_sk#126, i_brand_id#127, i_class_id#128, i_category_id#129]
Arguments: hashpartitioning(i_item_sk#126, 100), ENSURE_REQUIREMENTS, [plan_id=79]

(519) Sort
Input [4]: [i_item_sk#126, i_brand_id#127, i_class_id#128, i_category_id#129]
Arguments: [i_item_sk#126 ASC NULLS FIRST], false, 0

(520) SortMergeJoin
Left keys [1]: [cs_item_sk#125]
Right keys [1]: [i_item_sk#126]
Join type: Inner
Join condition: None

(521) Project
Output [4]: [cs_sold_date_sk#124, i_brand_id#127, i_class_id#128, i_category_id#129]
Input [6]: [cs_sold_date_sk#124, cs_item_sk#125, i_item_sk#126, i_brand_id#127, i_class_id#128, i_category_id#129]

(522) Exchange
Input [4]: [cs_sold_date_sk#124, i_brand_id#127, i_class_id#128, i_category_id#129]
Arguments: hashpartitioning(cs_sold_date_sk#124, 100), ENSURE_REQUIREMENTS, [plan_id=80]

(523) Sort
Input [4]: [cs_sold_date_sk#124, i_brand_id#127, i_class_id#128, i_category_id#129]
Arguments: [cs_sold_date_sk#124 ASC NULLS FIRST], false, 0

(524) Scan parquet
Output [2]: [d_date_sk#130, d_year#131]
Batched: true
Location: InMemoryFileIndex [file:/<warehouse_dir>]
PushedFilters: [IsNotNull(d_year), GreaterThanOrEqual(d_year,1999), LessThanOrEqual(d_year,2001), IsNotNull(d_date_sk)]
ReadSchema: struct<d_date_sk:int,d_year:int>

(525) Filter
Input [2]: [d_date_sk#130, d_year#131]
Condition : (((isnotnull(d_year#131) AND (d_year#131 >= 1999)) AND (d_year#131 <= 2001)) AND isnotnull(d_date_sk#130))

(526) Project
Output [1]: [d_date_sk#130]
Input [2]: [d_date_sk#130, d_year#131]

(527) Exchange
Input [1]: [d_date_sk#130]
Arguments: hashpartitioning(d_date_sk#130, 100), ENSURE_REQUIREMENTS, [plan_id=81]

(528) Sort
Input [1]: [d_date_sk#130]
Arguments: [d_date_sk#130 ASC NULLS FIRST], false, 0

(529) SortMergeJoin
Left keys [1]: [cs_sold_date_sk#124]
Right keys [1]: [d_date_sk#130]
Join type: Inner
Join condition: None

(530) Project
Output [3]: [i_brand_id#127, i_class_id#128, i_category_id#129]
Input [5]: [cs_sold_date_sk#124, i_brand_id#127, i_class_id#128, i_category_id#129, d_date_sk#130]

(531) Exchange
Input [3]: [i_brand_id#127, i_class_id#128, i_category_id#129]
Arguments: hashpartitioning(coalesce(i_brand_id#127, 0), isnull(i_brand_id#127), coalesce(i_class_id#128, 0), isnull(i_class_id#128), coalesce(i_category_id#129, 0), isnull(i_category_id#129), 100), ENSURE_REQUIREMENTS, [plan_id=82]

(532) Sort
Input [3]: [i_brand_id#127, i_class_id#128, i_category_id#129]
Arguments: [coalesce(i_brand_id#127, 0) ASC NULLS FIRST, isnull(i_brand_id#127) ASC NULLS FIRST, coalesce(i_class_id#128, 0) ASC NULLS FIRST, isnull(i_class_id#128) ASC NULLS FIRST, coalesce(i_category_id#129, 0) ASC NULLS FIRST, isnull(i_category_id#129) ASC NULLS FIRST], false, 0

(533) SortMergeJoin
Left keys [6]: [coalesce(i_brand_id#121, 0), isnull(i_brand_id#121), coalesce(i_class_id#122, 0), isnull(i_class_id#122), coalesce(i_category_id#123, 0), isnull(i_category_id#123)]
Right keys [6]: [coalesce(i_brand_id#127, 0), isnull(i_brand_id#127), coalesce(i_class_id#128, 0), isnull(i_class_id#128), coalesce(i_category_id#129, 0), isnull(i_category_id#129)]
Join type: LeftSemi
Join condition: None

(534) Exchange
Input [4]: [i_item_sk#120, i_brand_id#121, i_class_id#122, i_category_id#123]
Arguments: hashpartitioning(i_item_sk#120, 100), ENSURE_REQUIREMENTS, [plan_id=83]

(535) Sort
Input [4]: [i_item_sk#120, i_brand_id#121, i_class_id#122, i_category_id#123]
Arguments: [i_item_sk#120 ASC NULLS FIRST], false, 0

(536) SortMergeJoin
Left keys [1]: [ss_item_sk#119]
Right keys [1]: [i_item_sk#120]
Join type: Inner
Join condition: None

(537) Project
Output [4]: [ss_sold_date_sk#118, i_brand_id#121, i_class_id#122, i_category_id#123]
Input [6]: [ss_sold_date_sk#118, ss_item_sk#119, i_item_sk#120, i_brand_id#121, i_class_id#122, i_category_id#123]

(538) Exchange
Input [4]: [ss_sold_date_sk#118, i_brand_id#121, i_class_id#122, i_category_id#123]
Arguments: hashpartitioning(ss_sold_date_sk#118, 100), ENSURE_REQUIREMENTS, [plan_id=84]

(539) Sort
Input [4]: [ss_sold_date_sk#118, i_brand_id#121, i_class_id#122, i_category_id#123]
Arguments: [ss_sold_date_sk#118 ASC NULLS FIRST], false, 0

(540) Scan parquet
Output [2]: [d_date_sk#132, d_year#133]
Batched: true
Location: InMemoryFileIndex [file:/<warehouse_dir>]
PushedFilters: [IsNotNull(d_year), GreaterThanOrEqual(d_year,1999), LessThanOrEqual(d_year,2001), IsNotNull(d_date_sk)]
ReadSchema: struct<d_date_sk:int,d_year:int>

(541) Filter
Input [2]: [d_date_sk#132, d_year#133]
Condition : (((isnotnull(d_year#133) AND (d_year#133 >= 1999)) AND (d_year#133 <= 2001)) AND isnotnull(d_date_sk#132))

(542) Project
Output [1]: [d_date_sk#132]
Input [2]: [d_date_sk#132, d_year#133]

(543) Exchange
Input [1]: [d_date_sk#132]
Arguments: hashpartitioning(d_date_sk#132, 100), ENSURE_REQUIREMENTS, [plan_id=85]

(544) Sort
Input [1]: [d_date_sk#132]
Arguments: [d_date_sk#132 ASC NULLS FIRST], false, 0

(545) SortMergeJoin
Left keys [1]: [ss_sold_date_sk#118]
Right keys [1]: [d_date_sk#132]
Join type: Inner
Join condition: None

(546) Project
Output [3]: [i_brand_id#121 AS brand_id#24, i_class_id#122 AS class_id#25, i_category_id#123 AS category_id#26]
Input [5]: [ss_sold_date_sk#118, i_brand_id#121, i_class_id#122, i_category_id#123, d_date_sk#132]

(547) HashAggregate
Input [3]: [brand_id#24, class_id#25, category_id#26]
Keys [3]: [brand_id#24, class_id#25, category_id#26]
Functions: []
Aggregate Attributes: []
Results [3]: [brand_id#24, class_id#25, category_id#26]

(548) Exchange
Input [3]: [brand_id#24, class_id#25, category_id#26]
Arguments: hashpartitioning(brand_id#24, class_id#25, category_id#26, 100), ENSURE_REQUIREMENTS, [plan_id=86]

(549) HashAggregate
Input [3]: [brand_id#24, class_id#25, category_id#26]
Keys [3]: [brand_id#24, class_id#25, category_id#26]
Functions: []
Aggregate Attributes: []
Results [3]: [brand_id#24, class_id#25, category_id#26]

(550) Exchange
Input [3]: [brand_id#24, class_id#25, category_id#26]
Arguments: hashpartitioning(coalesce(brand_id#24, 0), isnull(brand_id#24), coalesce(class_id#25, 0), isnull(class_id#25), coalesce(category_id#26, 0), isnull(category_id#26), 100), ENSURE_REQUIREMENTS, [plan_id=87]

(551) Sort
Input [3]: [brand_id#24, class_id#25, category_id#26]
Arguments: [coalesce(brand_id#24, 0) ASC NULLS FIRST, isnull(brand_id#24) ASC NULLS FIRST, coalesce(class_id#25, 0) ASC NULLS FIRST, isnull(class_id#25) ASC NULLS FIRST, coalesce(category_id#26, 0) ASC NULLS FIRST, isnull(category_id#26) ASC NULLS FIRST], false, 0

(552) Scan parquet
Output [2]: [ws_sold_date_sk#134, ws_item_sk#135]
Batched: true
Location: InMemoryFileIndex [file:/<warehouse_dir>]
PushedFilters: [IsNotNull(ws_item_sk), IsNotNull(ws_sold_date_sk)]
ReadSchema: struct<ws_sold_date_sk:int,ws_item_sk:int>

(553) Filter
Input [2]: [ws_sold_date_sk#134, ws_item_sk#135]
Condition : (isnotnull(ws_item_sk#135) AND isnotnull(ws_sold_date_sk#134))

(554) Exchange
Input [2]: [ws_sold_date_sk#134, ws_item_sk#135]
Arguments: hashpartitioning(ws_item_sk#135, 100), ENSURE_REQUIREMENTS, [plan_id=88]

(555) Sort
Input [2]: [ws_sold_date_sk#134, ws_item_sk#135]
Arguments: [ws_item_sk#135 ASC NULLS FIRST], false, 0

(556) Scan parquet
Output [4]: [i_item_sk#136, i_brand_id#137, i_class_id#138, i_category_id#139]
Batched: true
Location: InMemoryFileIndex [file:/<warehouse_dir>]
PushedFilters: [IsNotNull(i_item_sk)]
ReadSchema: struct<i_item_sk:int,i_brand_id:int,i_class_id:int,i_category_id:int>

(557) Filter
Input [4]: [i_item_sk#136, i_brand_id#137, i_class_id#138, i_category_id#139]
Condition : isnotnull(i_item_sk#136)

(558) Exchange
Input [4]: [i_item_sk#136, i_brand_id#137, i_class_id#138, i_category_id#139]
Arguments: hashpartitioning(i_item_sk#136, 100), ENSURE_REQUIREMENTS, [plan_id=89]

(559) Sort
Input [4]: [i_item_sk#136, i_brand_id#137, i_class_id#138, i_category_id#139]
Arguments: [i_item_sk#136 ASC NULLS FIRST], false, 0

(560) SortMergeJoin
Left keys [1]: [ws_item_sk#135]
Right keys [1]: [i_item_sk#136]
Join type: Inner
Join condition: None

(561) Project
Output [4]: [ws_sold_date_sk#134, i_brand_id#137, i_class_id#138, i_category_id#139]
Input [6]: [ws_sold_date_sk#134, ws_item_sk#135, i_item_sk#136, i_brand_id#137, i_class_id#138, i_category_id#139]

(562) Exchange
Input [4]: [ws_sold_date_sk#134, i_brand_id#137, i_class_id#138, i_category_id#139]
Arguments: hashpartitioning(ws_sold_date_sk#134, 100), ENSURE_REQUIREMENTS, [plan_id=90]

(563) Sort
Input [4]: [ws_sold_date_sk#134, i_brand_id#137, i_class_id#138, i_category_id#139]
Arguments: [ws_sold_date_sk#134 ASC NULLS FIRST], false, 0

(564) Scan parquet
Output [2]: [d_date_sk#140, d_year#141]
Batched: true
Location: InMemoryFileIndex [file:/<warehouse_dir>]
PushedFilters: [IsNotNull(d_year), GreaterThanOrEqual(d_year,1999), LessThanOrEqual(d_year,2001), IsNotNull(d_date_sk)]
ReadSchema: struct<d_date_sk:int,d_year:int>

(565) Filter
Input [2]: [d_date_sk#140, d_year#141]
Condition : (((isnotnull(d_year#141) AND (d_year#141 >= 1999)) AND (d_year#141 <= 2001)) AND isnotnull(d_date_sk#140))

(566) Project
Output [1]: [d_date_sk#140]
Input [2]: [d_date_sk#140, d_year#141]

(567) Exchange
Input [1]: [d_date_sk#140]
Arguments: hashpartitioning(d_date_sk#140, 100), ENSURE_REQUIREMENTS, [plan_id=91]

(568) Sort
Input [1]: [d_date_sk#140]
Arguments: [d_date_sk#140 ASC NULLS FIRST], false, 0

(569) SortMergeJoin
Left keys [1]: [ws_sold_date_sk#134]
Right keys [1]: [d_date_sk#140]
Join type: Inner
Join condition: None

(570) Project
Output [3]: [i_brand_id#137, i_class_id#138, i_category_id#139]
Input [5]: [ws_sold_date_sk#134, i_brand_id#137, i_class_id#138, i_category_id#139, d_date_sk#140]

(571) Exchange
Input [3]: [i_brand_id#137, i_class_id#138, i_category_id#139]
Arguments: hashpartitioning(coalesce(i_brand_id#137, 0), isnull(i_brand_id#137), coalesce(i_class_id#138, 0), isnull(i_class_id#138), coalesce(i_category_id#139, 0), isnull(i_category_id#139), 100), ENSURE_REQUIREMENTS, [plan_id=92]

(572) Sort
Input [3]: [i_brand_id#137, i_class_id#138, i_category_id#139]
Arguments: [coalesce(i_brand_id#137, 0) ASC NULLS FIRST, isnull(i_brand_id#137) ASC NULLS FIRST, coalesce(i_class_id#138, 0) ASC NULLS FIRST, isnull(i_class_id#138) ASC NULLS FIRST, coalesce(i_category_id#139, 0) ASC NULLS FIRST, isnull(i_category_id#139) ASC NULLS FIRST], false, 0

(573) SortMergeJoin
Left keys [6]: [coalesce(brand_id#24, 0), isnull(brand_id#24), coalesce(class_id#25, 0), isnull(class_id#25), coalesce(category_id#26, 0), isnull(category_id#26)]
Right keys [6]: [coalesce(i_brand_id#137, 0), isnull(i_brand_id#137), coalesce(i_class_id#138, 0), isnull(i_class_id#138), coalesce(i_category_id#139, 0), isnull(i_category_id#139)]
Join type: LeftSemi
Join condition: None

(574) Exchange
Input [3]: [brand_id#24, class_id#25, category_id#26]
Arguments: hashpartitioning(brand_id#24, class_id#25, category_id#26, 100), ENSURE_REQUIREMENTS, [plan_id=93]

(575) Sort
Input [3]: [brand_id#24, class_id#25, category_id#26]
Arguments: [brand_id#24 ASC NULLS FIRST, class_id#25 ASC NULLS FIRST, category_id#26 ASC NULLS FIRST], false, 0

(576) SortMergeJoin
Left keys [3]: [i_brand_id#115, i_class_id#116, i_category_id#117]
Right keys [3]: [brand_id#24, class_id#25, category_id#26]
Join type: Inner
Join condition: None

(577) Project
Output [1]: [i_item_sk#114 AS ss_item_sk#62]
Input [7]: [i_item_sk#114, i_brand_id#115, i_class_id#116, i_category_id#117, brand_id#24, class_id#25, category_id#26]

(578) Exchange
Input [1]: [ss_item_sk#62]
Arguments: hashpartitioning(ss_item_sk#62, 100), ENSURE_REQUIREMENTS, [plan_id=94]

(579) Sort
Input [1]: [ss_item_sk#62]
Arguments: [ss_item_sk#62 ASC NULLS FIRST], false, 0

(580) SortMergeJoin
Left keys [1]: [cs_item_sk#59]
Right keys [1]: [ss_item_sk#62]
Join type: LeftSemi
Join condition: None

(581) Scan parquet
Output [4]: [i_item_sk#63, i_brand_id#64, i_class_id#65, i_category_id#66]
Batched: true
Location: InMemoryFileIndex [file:/<warehouse_dir>]
PushedFilters: [IsNotNull(i_item_sk)]
ReadSchema: struct<i_item_sk:int,i_brand_id:int,i_class_id:int,i_category_id:int>

(582) Filter
Input [4]: [i_item_sk#63, i_brand_id#64, i_class_id#65, i_category_id#66]
Condition : isnotnull(i_item_sk#63)

(583) Exchange
Input [4]: [i_item_sk#63, i_brand_id#64, i_class_id#65, i_category_id#66]
Arguments: hashpartitioning(i_item_sk#63, 100), ENSURE_REQUIREMENTS, [plan_id=95]

(584) Sort
Input [4]: [i_item_sk#63, i_brand_id#64, i_class_id#65, i_category_id#66]
Arguments: [i_item_sk#63 ASC NULLS FIRST], false, 0

(585) Scan parquet
Output [4]: [i_item_sk#114, i_brand_id#115, i_class_id#116, i_category_id#117]
Batched: true
Location: InMemoryFileIndex [file:/<warehouse_dir>]
PushedFilters: [IsNotNull(i_brand_id), IsNotNull(i_class_id), IsNotNull(i_category_id)]
ReadSchema: struct<i_item_sk:int,i_brand_id:int,i_class_id:int,i_category_id:int>

(586) Filter
Input [4]: [i_item_sk#114, i_brand_id#115, i_class_id#116, i_category_id#117]
Condition : ((isnotnull(i_brand_id#115) AND isnotnull(i_class_id#116)) AND isnotnull(i_category_id#117))

(587) Exchange
Input [4]: [i_item_sk#114, i_brand_id#115, i_class_id#116, i_category_id#117]
Arguments: hashpartitioning(i_brand_id#115, i_class_id#116, i_category_id#117, 100), ENSURE_REQUIREMENTS, [plan_id=96]

(588) Sort
Input [4]: [i_item_sk#114, i_brand_id#115, i_class_id#116, i_category_id#117]
Arguments: [i_brand_id#115 ASC NULLS FIRST, i_class_id#116 ASC NULLS FIRST, i_category_id#117 ASC NULLS FIRST], false, 0

(589) Scan parquet
Output [2]: [ss_sold_date_sk#118, ss_item_sk#119]
Batched: true
Location: InMemoryFileIndex [file:/<warehouse_dir>]
PushedFilters: [IsNotNull(ss_item_sk), IsNotNull(ss_sold_date_sk)]
ReadSchema: struct<ss_sold_date_sk:int,ss_item_sk:int>

(590) Filter
Input [2]: [ss_sold_date_sk#118, ss_item_sk#119]
Condition : (isnotnull(ss_item_sk#119) AND isnotnull(ss_sold_date_sk#118))

(591) Exchange
Input [2]: [ss_sold_date_sk#118, ss_item_sk#119]
Arguments: hashpartitioning(ss_item_sk#119, 100), ENSURE_REQUIREMENTS, [plan_id=97]

(592) Sort
Input [2]: [ss_sold_date_sk#118, ss_item_sk#119]
Arguments: [ss_item_sk#119 ASC NULLS FIRST], false, 0

(593) Scan parquet
Output [4]: [i_item_sk#120, i_brand_id#121, i_class_id#122, i_category_id#123]
Batched: true
Location: InMemoryFileIndex [file:/<warehouse_dir>]
PushedFilters: [IsNotNull(i_item_sk), IsNotNull(i_brand_id), IsNotNull(i_class_id), IsNotNull(i_category_id)]
ReadSchema: struct<i_item_sk:int,i_brand_id:int,i_class_id:int,i_category_id:int>

(594) Filter
Input [4]: [i_item_sk#120, i_brand_id#121, i_class_id#122, i_category_id#123]
Condition : (((isnotnull(i_item_sk#120) AND isnotnull(i_brand_id#121)) AND isnotnull(i_class_id#122)) AND isnotnull(i_category_id#123))

(595) Exchange
Input [4]: [i_item_sk#120, i_brand_id#121, i_class_id#122, i_category_id#123]
Arguments: hashpartitioning(coalesce(i_brand_id#121, 0), isnull(i_brand_id#121), coalesce(i_class_id#122, 0), isnull(i_class_id#122), coalesce(i_category_id#123, 0), isnull(i_category_id#123), 100), ENSURE_REQUIREMENTS, [plan_id=98]

(596) Sort
Input [4]: [i_item_sk#120, i_brand_id#121, i_class_id#122, i_category_id#123]
Arguments: [coalesce(i_brand_id#121, 0) ASC NULLS FIRST, isnull(i_brand_id#121) ASC NULLS FIRST, coalesce(i_class_id#122, 0) ASC NULLS FIRST, isnull(i_class_id#122) ASC NULLS FIRST, coalesce(i_category_id#123, 0) ASC NULLS FIRST, isnull(i_category_id#123) ASC NULLS FIRST], false, 0

(597) Scan parquet
Output [2]: [cs_sold_date_sk#124, cs_item_sk#125]
Batched: true
Location: InMemoryFileIndex [file:/<warehouse_dir>]
PushedFilters: [IsNotNull(cs_item_sk), IsNotNull(cs_sold_date_sk)]
ReadSchema: struct<cs_sold_date_sk:int,cs_item_sk:int>

(598) Filter
Input [2]: [cs_sold_date_sk#124, cs_item_sk#125]
Condition : (isnotnull(cs_item_sk#125) AND isnotnull(cs_sold_date_sk#124))

(599) Exchange
Input [2]: [cs_sold_date_sk#124, cs_item_sk#125]
Arguments: hashpartitioning(cs_item_sk#125, 100), ENSURE_REQUIREMENTS, [plan_id=99]

(600) Sort
Input [2]: [cs_sold_date_sk#124, cs_item_sk#125]
Arguments: [cs_item_sk#125 ASC NULLS FIRST], false, 0

(601) Scan parquet
Output [4]: [i_item_sk#126, i_brand_id#127, i_class_id#128, i_category_id#129]
Batched: true
Location: InMemoryFileIndex [file:/<warehouse_dir>]
PushedFilters: [IsNotNull(i_item_sk)]
ReadSchema: struct<i_item_sk:int,i_brand_id:int,i_class_id:int,i_category_id:int>

(602) Filter
Input [4]: [i_item_sk#126, i_brand_id#127, i_class_id#128, i_category_id#129]
Condition : isnotnull(i_item_sk#126)

(603) Exchange
Input [4]: [i_item_sk#126, i_brand_id#127, i_class_id#128, i_category_id#129]
Arguments: hashpartitioning(i_item_sk#126, 100), ENSURE_REQUIREMENTS, [plan_id=100]

(604) Sort
Input [4]: [i_item_sk#126, i_brand_id#127, i_class_id#128, i_category_id#129]
Arguments: [i_item_sk#126 ASC NULLS FIRST], false, 0

(605) SortMergeJoin
Left keys [1]: [cs_item_sk#125]
Right keys [1]: [i_item_sk#126]
Join type: Inner
Join condition: None

(606) Project
Output [4]: [cs_sold_date_sk#124, i_brand_id#127, i_class_id#128, i_category_id#129]
Input [6]: [cs_sold_date_sk#124, cs_item_sk#125, i_item_sk#126, i_brand_id#127, i_class_id#128, i_category_id#129]

(607) Exchange
Input [4]: [cs_sold_date_sk#124, i_brand_id#127, i_class_id#128, i_category_id#129]
Arguments: hashpartitioning(cs_sold_date_sk#124, 100), ENSURE_REQUIREMENTS, [plan_id=101]

(608) Sort
Input [4]: [cs_sold_date_sk#124, i_brand_id#127, i_class_id#128, i_category_id#129]
Arguments: [cs_sold_date_sk#124 ASC NULLS FIRST], false, 0

(609) Scan parquet
Output [2]: [d_date_sk#130, d_year#131]
Batched: true
Location: InMemoryFileIndex [file:/<warehouse_dir>]
PushedFilters: [IsNotNull(d_year), GreaterThanOrEqual(d_year,1999), LessThanOrEqual(d_year,2001), IsNotNull(d_date_sk)]
ReadSchema: struct<d_date_sk:int,d_year:int>

(610) Filter
Input [2]: [d_date_sk#130, d_year#131]
Condition : (((isnotnull(d_year#131) AND (d_year#131 >= 1999)) AND (d_year#131 <= 2001)) AND isnotnull(d_date_sk#130))

(611) Project
Output [1]: [d_date_sk#130]
Input [2]: [d_date_sk#130, d_year#131]

(612) Exchange
Input [1]: [d_date_sk#130]
Arguments: hashpartitioning(d_date_sk#130, 100), ENSURE_REQUIREMENTS, [plan_id=102]

(613) Sort
Input [1]: [d_date_sk#130]
Arguments: [d_date_sk#130 ASC NULLS FIRST], false, 0

(614) SortMergeJoin
Left keys [1]: [cs_sold_date_sk#124]
Right keys [1]: [d_date_sk#130]
Join type: Inner
Join condition: None

(615) Project
Output [3]: [i_brand_id#127, i_class_id#128, i_category_id#129]
Input [5]: [cs_sold_date_sk#124, i_brand_id#127, i_class_id#128, i_category_id#129, d_date_sk#130]

(616) Exchange
Input [3]: [i_brand_id#127, i_class_id#128, i_category_id#129]
Arguments: hashpartitioning(coalesce(i_brand_id#127, 0), isnull(i_brand_id#127), coalesce(i_class_id#128, 0), isnull(i_class_id#128), coalesce(i_category_id#129, 0), isnull(i_category_id#129), 100), ENSURE_REQUIREMENTS, [plan_id=103]

(617) Sort
Input [3]: [i_brand_id#127, i_class_id#128, i_category_id#129]
Arguments: [coalesce(i_brand_id#127, 0) ASC NULLS FIRST, isnull(i_brand_id#127) ASC NULLS FIRST, coalesce(i_class_id#128, 0) ASC NULLS FIRST, isnull(i_class_id#128) ASC NULLS FIRST, coalesce(i_category_id#129, 0) ASC NULLS FIRST, isnull(i_category_id#129) ASC NULLS FIRST], false, 0

(618) SortMergeJoin
Left keys [6]: [coalesce(i_brand_id#121, 0), isnull(i_brand_id#121), coalesce(i_class_id#122, 0), isnull(i_class_id#122), coalesce(i_category_id#123, 0), isnull(i_category_id#123)]
Right keys [6]: [coalesce(i_brand_id#127, 0), isnull(i_brand_id#127), coalesce(i_class_id#128, 0), isnull(i_class_id#128), coalesce(i_category_id#129, 0), isnull(i_category_id#129)]
Join type: LeftSemi
Join condition: None

(619) Exchange
Input [4]: [i_item_sk#120, i_brand_id#121, i_class_id#122, i_category_id#123]
Arguments: hashpartitioning(i_item_sk#120, 100), ENSURE_REQUIREMENTS, [plan_id=104]

(620) Sort
Input [4]: [i_item_sk#120, i_brand_id#121, i_class_id#122, i_category_id#123]
Arguments: [i_item_sk#120 ASC NULLS FIRST], false, 0

(621) SortMergeJoin
Left keys [1]: [ss_item_sk#119]
Right keys [1]: [i_item_sk#120]
Join type: Inner
Join condition: None

(622) Project
Output [4]: [ss_sold_date_sk#118, i_brand_id#121, i_class_id#122, i_category_id#123]
Input [6]: [ss_sold_date_sk#118, ss_item_sk#119, i_item_sk#120, i_brand_id#121, i_class_id#122, i_category_id#123]

(623) Exchange
Input [4]: [ss_sold_date_sk#118, i_brand_id#121, i_class_id#122, i_category_id#123]
Arguments: hashpartitioning(ss_sold_date_sk#118, 100), ENSURE_REQUIREMENTS, [plan_id=105]

(624) Sort
Input [4]: [ss_sold_date_sk#118, i_brand_id#121, i_class_id#122, i_category_id#123]
Arguments: [ss_sold_date_sk#118 ASC NULLS FIRST], false, 0

(625) Scan parquet
Output [2]: [d_date_sk#132, d_year#133]
Batched: true
Location: InMemoryFileIndex [file:/<warehouse_dir>]
PushedFilters: [IsNotNull(d_year), GreaterThanOrEqual(d_year,1999), LessThanOrEqual(d_year,2001), IsNotNull(d_date_sk)]
ReadSchema: struct<d_date_sk:int,d_year:int>

(626) Filter
Input [2]: [d_date_sk#132, d_year#133]
Condition : (((isnotnull(d_year#133) AND (d_year#133 >= 1999)) AND (d_year#133 <= 2001)) AND isnotnull(d_date_sk#132))

(627) Project
Output [1]: [d_date_sk#132]
Input [2]: [d_date_sk#132, d_year#133]

(628) Exchange
Input [1]: [d_date_sk#132]
Arguments: hashpartitioning(d_date_sk#132, 100), ENSURE_REQUIREMENTS, [plan_id=106]

(629) Sort
Input [1]: [d_date_sk#132]
Arguments: [d_date_sk#132 ASC NULLS FIRST], false, 0

(630) SortMergeJoin
Left keys [1]: [ss_sold_date_sk#118]
Right keys [1]: [d_date_sk#132]
Join type: Inner
Join condition: None

(631) Project
Output [3]: [i_brand_id#121 AS brand_id#24, i_class_id#122 AS class_id#25, i_category_id#123 AS category_id#26]
Input [5]: [ss_sold_date_sk#118, i_brand_id#121, i_class_id#122, i_category_id#123, d_date_sk#132]

(632) HashAggregate
Input [3]: [brand_id#24, class_id#25, category_id#26]
Keys [3]: [brand_id#24, class_id#25, category_id#26]
Functions: []
Aggregate Attributes: []
Results [3]: [brand_id#24, class_id#25, category_id#26]

(633) Exchange
Input [3]: [brand_id#24, class_id#25, category_id#26]
Arguments: hashpartitioning(brand_id#24, class_id#25, category_id#26, 100), ENSURE_REQUIREMENTS, [plan_id=107]

(634) HashAggregate
Input [3]: [brand_id#24, class_id#25, category_id#26]
Keys [3]: [brand_id#24, class_id#25, category_id#26]
Functions: []
Aggregate Attributes: []
Results [3]: [brand_id#24, class_id#25, category_id#26]

(635) Exchange
Input [3]: [brand_id#24, class_id#25, category_id#26]
Arguments: hashpartitioning(coalesce(brand_id#24, 0), isnull(brand_id#24), coalesce(class_id#25, 0), isnull(class_id#25), coalesce(category_id#26, 0), isnull(category_id#26), 100), ENSURE_REQUIREMENTS, [plan_id=108]

(636) Sort
Input [3]: [brand_id#24, class_id#25, category_id#26]
Arguments: [coalesce(brand_id#24, 0) ASC NULLS FIRST, isnull(brand_id#24) ASC NULLS FIRST, coalesce(class_id#25, 0) ASC NULLS FIRST, isnull(class_id#25) ASC NULLS FIRST, coalesce(category_id#26, 0) ASC NULLS FIRST, isnull(category_id#26) ASC NULLS FIRST], false, 0

(637) Scan parquet
Output [2]: [ws_sold_date_sk#134, ws_item_sk#135]
Batched: true
Location: InMemoryFileIndex [file:/<warehouse_dir>]
PushedFilters: [IsNotNull(ws_item_sk), IsNotNull(ws_sold_date_sk)]
ReadSchema: struct<ws_sold_date_sk:int,ws_item_sk:int>

(638) Filter
Input [2]: [ws_sold_date_sk#134, ws_item_sk#135]
Condition : (isnotnull(ws_item_sk#135) AND isnotnull(ws_sold_date_sk#134))

(639) Exchange
Input [2]: [ws_sold_date_sk#134, ws_item_sk#135]
Arguments: hashpartitioning(ws_item_sk#135, 100), ENSURE_REQUIREMENTS, [plan_id=109]

(640) Sort
Input [2]: [ws_sold_date_sk#134, ws_item_sk#135]
Arguments: [ws_item_sk#135 ASC NULLS FIRST], false, 0

(641) Scan parquet
Output [4]: [i_item_sk#136, i_brand_id#137, i_class_id#138, i_category_id#139]
Batched: true
Location: InMemoryFileIndex [file:/<warehouse_dir>]
PushedFilters: [IsNotNull(i_item_sk)]
ReadSchema: struct<i_item_sk:int,i_brand_id:int,i_class_id:int,i_category_id:int>

(642) Filter
Input [4]: [i_item_sk#136, i_brand_id#137, i_class_id#138, i_category_id#139]
Condition : isnotnull(i_item_sk#136)

(643) Exchange
Input [4]: [i_item_sk#136, i_brand_id#137, i_class_id#138, i_category_id#139]
Arguments: hashpartitioning(i_item_sk#136, 100), ENSURE_REQUIREMENTS, [plan_id=110]

(644) Sort
Input [4]: [i_item_sk#136, i_brand_id#137, i_class_id#138, i_category_id#139]
Arguments: [i_item_sk#136 ASC NULLS FIRST], false, 0

(645) SortMergeJoin
Left keys [1]: [ws_item_sk#135]
Right keys [1]: [i_item_sk#136]
Join type: Inner
Join condition: None

(646) Project
Output [4]: [ws_sold_date_sk#134, i_brand_id#137, i_class_id#138, i_category_id#139]
Input [6]: [ws_sold_date_sk#134, ws_item_sk#135, i_item_sk#136, i_brand_id#137, i_class_id#138, i_category_id#139]

(647) Exchange
Input [4]: [ws_sold_date_sk#134, i_brand_id#137, i_class_id#138, i_category_id#139]
Arguments: hashpartitioning(ws_sold_date_sk#134, 100), ENSURE_REQUIREMENTS, [plan_id=111]

(648) Sort
Input [4]: [ws_sold_date_sk#134, i_brand_id#137, i_class_id#138, i_category_id#139]
Arguments: [ws_sold_date_sk#134 ASC NULLS FIRST], false, 0

(649) Scan parquet
Output [2]: [d_date_sk#140, d_year#141]
Batched: true
Location: InMemoryFileIndex [file:/<warehouse_dir>]
PushedFilters: [IsNotNull(d_year), GreaterThanOrEqual(d_year,1999), LessThanOrEqual(d_year,2001), IsNotNull(d_date_sk)]
ReadSchema: struct<d_date_sk:int,d_year:int>

(650) Filter
Input [2]: [d_date_sk#140, d_year#141]
Condition : (((isnotnull(d_year#141) AND (d_year#141 >= 1999)) AND (d_year#141 <= 2001)) AND isnotnull(d_date_sk#140))

(651) Project
Output [1]: [d_date_sk#140]
Input [2]: [d_date_sk#140, d_year#141]

(652) Exchange
Input [1]: [d_date_sk#140]
Arguments: hashpartitioning(d_date_sk#140, 100), ENSURE_REQUIREMENTS, [plan_id=112]

(653) Sort
Input [1]: [d_date_sk#140]
Arguments: [d_date_sk#140 ASC NULLS FIRST], false, 0

(654) SortMergeJoin
Left keys [1]: [ws_sold_date_sk#134]
Right keys [1]: [d_date_sk#140]
Join type: Inner
Join condition: None

(655) Project
Output [3]: [i_brand_id#137, i_class_id#138, i_category_id#139]
Input [5]: [ws_sold_date_sk#134, i_brand_id#137, i_class_id#138, i_category_id#139, d_date_sk#140]

(656) Exchange
Input [3]: [i_brand_id#137, i_class_id#138, i_category_id#139]
Arguments: hashpartitioning(coalesce(i_brand_id#137, 0), isnull(i_brand_id#137), coalesce(i_class_id#138, 0), isnull(i_class_id#138), coalesce(i_category_id#139, 0), isnull(i_category_id#139), 100), ENSURE_REQUIREMENTS, [plan_id=113]

(657) Sort
Input [3]: [i_brand_id#137, i_class_id#138, i_category_id#139]
Arguments: [coalesce(i_brand_id#137, 0) ASC NULLS FIRST, isnull(i_brand_id#137) ASC NULLS FIRST, coalesce(i_class_id#138, 0) ASC NULLS FIRST, isnull(i_class_id#138) ASC NULLS FIRST, coalesce(i_category_id#139, 0) ASC NULLS FIRST, isnull(i_category_id#139) ASC NULLS FIRST], false, 0

(658) SortMergeJoin
Left keys [6]: [coalesce(brand_id#24, 0), isnull(brand_id#24), coalesce(class_id#25, 0), isnull(class_id#25), coalesce(category_id#26, 0), isnull(category_id#26)]
Right keys [6]: [coalesce(i_brand_id#137, 0), isnull(i_brand_id#137), coalesce(i_class_id#138, 0), isnull(i_class_id#138), coalesce(i_category_id#139, 0), isnull(i_category_id#139)]
Join type: LeftSemi
Join condition: None

(659) Exchange
Input [3]: [brand_id#24, class_id#25, category_id#26]
Arguments: hashpartitioning(brand_id#24, class_id#25, category_id#26, 100), ENSURE_REQUIREMENTS, [plan_id=114]

(660) Sort
Input [3]: [brand_id#24, class_id#25, category_id#26]
Arguments: [brand_id#24 ASC NULLS FIRST, class_id#25 ASC NULLS FIRST, category_id#26 ASC NULLS FIRST], false, 0

(661) SortMergeJoin
Left keys [3]: [i_brand_id#115, i_class_id#116, i_category_id#117]
Right keys [3]: [brand_id#24, class_id#25, category_id#26]
Join type: Inner
Join condition: None

(662) Project
Output [1]: [i_item_sk#114 AS ss_item_sk#62]
Input [7]: [i_item_sk#114, i_brand_id#115, i_class_id#116, i_category_id#117, brand_id#24, class_id#25, category_id#26]

(663) Exchange
Input [1]: [ss_item_sk#62]
Arguments: hashpartitioning(ss_item_sk#62, 100), ENSURE_REQUIREMENTS, [plan_id=115]

(664) Sort
Input [1]: [ss_item_sk#62]
Arguments: [ss_item_sk#62 ASC NULLS FIRST], false, 0

(665) SortMergeJoin
Left keys [1]: [i_item_sk#63]
Right keys [1]: [ss_item_sk#62]
Join type: LeftSemi
Join condition: None

(666) SortMergeJoin
Left keys [1]: [cs_item_sk#59]
Right keys [1]: [i_item_sk#63]
Join type: Inner
Join condition: None

(667) Project
Output [6]: [cs_sold_date_sk#58, cs_quantity#60, cs_list_price#61, i_brand_id#64, i_class_id#65, i_category_id#66]
Input [8]: [cs_sold_date_sk#58, cs_item_sk#59, cs_quantity#60, cs_list_price#61, i_item_sk#63, i_brand_id#64, i_class_id#65, i_category_id#66]

(668) Exchange
Input [6]: [cs_sold_date_sk#58, cs_quantity#60, cs_list_price#61, i_brand_id#64, i_class_id#65, i_category_id#66]
Arguments: hashpartitioning(cs_sold_date_sk#58, 100), ENSURE_REQUIREMENTS, [plan_id=116]

(669) Sort
Input [6]: [cs_sold_date_sk#58, cs_quantity#60, cs_list_price#61, i_brand_id#64, i_class_id#65, i_category_id#66]
Arguments: [cs_sold_date_sk#58 ASC NULLS FIRST], false, 0

(670) Scan parquet
Output [3]: [d_date_sk#67, d_year#142, d_moy#143]
Batched: true
Location: InMemoryFileIndex [file:/<warehouse_dir>]
PushedFilters: [IsNotNull(d_year), IsNotNull(d_moy), EqualTo(d_year,2001), EqualTo(d_moy,11), IsNotNull(d_date_sk)]
ReadSchema: struct<d_date_sk:int,d_year:int,d_moy:int>

(671) Filter
Input [3]: [d_date_sk#67, d_year#142, d_moy#143]
Condition : ((((isnotnull(d_year#142) AND isnotnull(d_moy#143)) AND (d_year#142 = 2001)) AND (d_moy#143 = 11)) AND isnotnull(d_date_sk#67))

(672) Project
Output [1]: [d_date_sk#67]
Input [3]: [d_date_sk#67, d_year#142, d_moy#143]

(673) Exchange
Input [1]: [d_date_sk#67]
Arguments: hashpartitioning(d_date_sk#67, 100), ENSURE_REQUIREMENTS, [plan_id=117]

(674) Sort
Input [1]: [d_date_sk#67]
Arguments: [d_date_sk#67 ASC NULLS FIRST], false, 0

(675) SortMergeJoin
Left keys [1]: [cs_sold_date_sk#58]
Right keys [1]: [d_date_sk#67]
Join type: Inner
Join condition: None

(676) Project
Output [5]: [cs_quantity#60, cs_list_price#61, i_brand_id#64, i_class_id#65, i_category_id#66]
Input [7]: [cs_sold_date_sk#58, cs_quantity#60, cs_list_price#61, i_brand_id#64, i_class_id#65, i_category_id#66, d_date_sk#67]

(677) HashAggregate
Input [5]: [cs_quantity#60, cs_list_price#61, i_brand_id#64, i_class_id#65, i_category_id#66]
Keys [3]: [i_brand_id#64, i_class_id#65, i_category_id#66]
Functions [2]: [partial_sum((cast(cs_quantity#60 as decimal(10,0)) * cs_list_price#61)), partial_count(1)]
Aggregate Attributes [3]: [sum#69, isEmpty#70, count#71]
Results [6]: [i_brand_id#64, i_class_id#65, i_category_id#66, sum#144, isEmpty#145, count#146]

(678) Exchange
Input [6]: [i_brand_id#64, i_class_id#65, i_category_id#66, sum#144, isEmpty#145, count#146]
Arguments: hashpartitioning(i_brand_id#64, i_class_id#65, i_category_id#66, 100), ENSURE_REQUIREMENTS, [plan_id=118]

(679) HashAggregate
Input [6]: [i_brand_id#64, i_class_id#65, i_category_id#66, sum#144, isEmpty#145, count#146]
Keys [3]: [i_brand_id#64, i_class_id#65, i_category_id#66]
Functions [2]: [sum((cast(cs_quantity#60 as decimal(10,0)) * cs_list_price#61)), count(1)]
Aggregate Attributes [2]: [sum((cast(cs_quantity#60 as decimal(10,0)) * cs_list_price#61))#72, count(1)#73]
Results [5]: [i_brand_id#64, i_class_id#65, i_category_id#66, sum((cast(cs_quantity#60 as decimal(10,0)) * cs_list_price#61))#72 AS sales#74, count(1)#73 AS number_sales#75]

(680) Filter
Input [5]: [i_brand_id#64, i_class_id#65, i_category_id#66, sales#74, number_sales#75]
Condition : (isnotnull(sales#74) AND (cast(sales#74 as decimal(32,6)) > cast(Subquery subquery#147, [id=#148] as decimal(32,6))))

(681) Project
Output [6]: [sales#74, number_sales#75, catalog AS channel#76, i_brand_id#64, i_class_id#65, i_category_id#66]
Input [5]: [i_brand_id#64, i_class_id#65, i_category_id#66, sales#74, number_sales#75]

(682) Scan parquet
Output [4]: [ws_sold_date_sk#77, ws_item_sk#78, ws_quantity#79, ws_list_price#80]
Batched: true
Location: InMemoryFileIndex [file:/<warehouse_dir>]
PushedFilters: [IsNotNull(ws_item_sk), IsNotNull(ws_sold_date_sk)]
ReadSchema: struct<ws_sold_date_sk:int,ws_item_sk:int,ws_quantity:int,ws_list_price:decimal(7,2)>

(683) Filter
Input [4]: [ws_sold_date_sk#77, ws_item_sk#78, ws_quantity#79, ws_list_price#80]
Condition : (isnotnull(ws_item_sk#78) AND isnotnull(ws_sold_date_sk#77))

(684) Exchange
Input [4]: [ws_sold_date_sk#77, ws_item_sk#78, ws_quantity#79, ws_list_price#80]
Arguments: hashpartitioning(ws_item_sk#78, 100), ENSURE_REQUIREMENTS, [plan_id=119]

(685) Sort
Input [4]: [ws_sold_date_sk#77, ws_item_sk#78, ws_quantity#79, ws_list_price#80]
Arguments: [ws_item_sk#78 ASC NULLS FIRST], false, 0

(686) Scan parquet
Output [4]: [i_item_sk#149, i_brand_id#150, i_class_id#151, i_category_id#152]
Batched: true
Location: InMemoryFileIndex [file:/<warehouse_dir>]
PushedFilters: [IsNotNull(i_brand_id), IsNotNull(i_class_id), IsNotNull(i_category_id)]
ReadSchema: struct<i_item_sk:int,i_brand_id:int,i_class_id:int,i_category_id:int>

(687) Filter
Input [4]: [i_item_sk#149, i_brand_id#150, i_class_id#151, i_category_id#152]
Condition : ((isnotnull(i_brand_id#150) AND isnotnull(i_class_id#151)) AND isnotnull(i_category_id#152))

(688) Exchange
Input [4]: [i_item_sk#149, i_brand_id#150, i_class_id#151, i_category_id#152]
Arguments: hashpartitioning(i_brand_id#150, i_class_id#151, i_category_id#152, 100), ENSURE_REQUIREMENTS, [plan_id=120]

(689) Sort
Input [4]: [i_item_sk#149, i_brand_id#150, i_class_id#151, i_category_id#152]
Arguments: [i_brand_id#150 ASC NULLS FIRST, i_class_id#151 ASC NULLS FIRST, i_category_id#152 ASC NULLS FIRST], false, 0

(690) Scan parquet
Output [2]: [ss_sold_date_sk#153, ss_item_sk#154]
Batched: true
Location: InMemoryFileIndex [file:/<warehouse_dir>]
PushedFilters: [IsNotNull(ss_item_sk), IsNotNull(ss_sold_date_sk)]
ReadSchema: struct<ss_sold_date_sk:int,ss_item_sk:int>

(691) Filter
Input [2]: [ss_sold_date_sk#153, ss_item_sk#154]
Condition : (isnotnull(ss_item_sk#154) AND isnotnull(ss_sold_date_sk#153))

(692) Exchange
Input [2]: [ss_sold_date_sk#153, ss_item_sk#154]
Arguments: hashpartitioning(ss_item_sk#154, 100), ENSURE_REQUIREMENTS, [plan_id=121]

(693) Sort
Input [2]: [ss_sold_date_sk#153, ss_item_sk#154]
Arguments: [ss_item_sk#154 ASC NULLS FIRST], false, 0

(694) Scan parquet
Output [4]: [i_item_sk#155, i_brand_id#156, i_class_id#157, i_category_id#158]
Batched: true
Location: InMemoryFileIndex [file:/<warehouse_dir>]
PushedFilters: [IsNotNull(i_item_sk), IsNotNull(i_brand_id), IsNotNull(i_class_id), IsNotNull(i_category_id)]
ReadSchema: struct<i_item_sk:int,i_brand_id:int,i_class_id:int,i_category_id:int>

(695) Filter
Input [4]: [i_item_sk#155, i_brand_id#156, i_class_id#157, i_category_id#158]
Condition : (((isnotnull(i_item_sk#155) AND isnotnull(i_brand_id#156)) AND isnotnull(i_class_id#157)) AND isnotnull(i_category_id#158))

(696) Exchange
Input [4]: [i_item_sk#155, i_brand_id#156, i_class_id#157, i_category_id#158]
Arguments: hashpartitioning(coalesce(i_brand_id#156, 0), isnull(i_brand_id#156), coalesce(i_class_id#157, 0), isnull(i_class_id#157), coalesce(i_category_id#158, 0), isnull(i_category_id#158), 100), ENSURE_REQUIREMENTS, [plan_id=122]

(697) Sort
Input [4]: [i_item_sk#155, i_brand_id#156, i_class_id#157, i_category_id#158]
Arguments: [coalesce(i_brand_id#156, 0) ASC NULLS FIRST, isnull(i_brand_id#156) ASC NULLS FIRST, coalesce(i_class_id#157, 0) ASC NULLS FIRST, isnull(i_class_id#157) ASC NULLS FIRST, coalesce(i_category_id#158, 0) ASC NULLS FIRST, isnull(i_category_id#158) ASC NULLS FIRST], false, 0

(698) Scan parquet
Output [2]: [cs_sold_date_sk#159, cs_item_sk#160]
Batched: true
Location: InMemoryFileIndex [file:/<warehouse_dir>]
PushedFilters: [IsNotNull(cs_item_sk), IsNotNull(cs_sold_date_sk)]
ReadSchema: struct<cs_sold_date_sk:int,cs_item_sk:int>

(699) Filter
Input [2]: [cs_sold_date_sk#159, cs_item_sk#160]
Condition : (isnotnull(cs_item_sk#160) AND isnotnull(cs_sold_date_sk#159))

(700) Exchange
Input [2]: [cs_sold_date_sk#159, cs_item_sk#160]
Arguments: hashpartitioning(cs_item_sk#160, 100), ENSURE_REQUIREMENTS, [plan_id=123]

(701) Sort
Input [2]: [cs_sold_date_sk#159, cs_item_sk#160]
Arguments: [cs_item_sk#160 ASC NULLS FIRST], false, 0

(702) Scan parquet
Output [4]: [i_item_sk#161, i_brand_id#162, i_class_id#163, i_category_id#164]
Batched: true
Location: InMemoryFileIndex [file:/<warehouse_dir>]
PushedFilters: [IsNotNull(i_item_sk)]
ReadSchema: struct<i_item_sk:int,i_brand_id:int,i_class_id:int,i_category_id:int>

(703) Filter
Input [4]: [i_item_sk#161, i_brand_id#162, i_class_id#163, i_category_id#164]
Condition : isnotnull(i_item_sk#161)

(704) Exchange
Input [4]: [i_item_sk#161, i_brand_id#162, i_class_id#163, i_category_id#164]
Arguments: hashpartitioning(i_item_sk#161, 100), ENSURE_REQUIREMENTS, [plan_id=124]

(705) Sort
Input [4]: [i_item_sk#161, i_brand_id#162, i_class_id#163, i_category_id#164]
Arguments: [i_item_sk#161 ASC NULLS FIRST], false, 0

(706) SortMergeJoin
Left keys [1]: [cs_item_sk#160]
Right keys [1]: [i_item_sk#161]
Join type: Inner
Join condition: None

(707) Project
Output [4]: [cs_sold_date_sk#159, i_brand_id#162, i_class_id#163, i_category_id#164]
Input [6]: [cs_sold_date_sk#159, cs_item_sk#160, i_item_sk#161, i_brand_id#162, i_class_id#163, i_category_id#164]

(708) Exchange
Input [4]: [cs_sold_date_sk#159, i_brand_id#162, i_class_id#163, i_category_id#164]
Arguments: hashpartitioning(cs_sold_date_sk#159, 100), ENSURE_REQUIREMENTS, [plan_id=125]

(709) Sort
Input [4]: [cs_sold_date_sk#159, i_brand_id#162, i_class_id#163, i_category_id#164]
Arguments: [cs_sold_date_sk#159 ASC NULLS FIRST], false, 0

(710) Scan parquet
Output [2]: [d_date_sk#165, d_year#166]
Batched: true
Location: InMemoryFileIndex [file:/<warehouse_dir>]
PushedFilters: [IsNotNull(d_year), GreaterThanOrEqual(d_year,1999), LessThanOrEqual(d_year,2001), IsNotNull(d_date_sk)]
ReadSchema: struct<d_date_sk:int,d_year:int>

(711) Filter
Input [2]: [d_date_sk#165, d_year#166]
Condition : (((isnotnull(d_year#166) AND (d_year#166 >= 1999)) AND (d_year#166 <= 2001)) AND isnotnull(d_date_sk#165))

(712) Project
Output [1]: [d_date_sk#165]
Input [2]: [d_date_sk#165, d_year#166]

(713) Exchange
Input [1]: [d_date_sk#165]
Arguments: hashpartitioning(d_date_sk#165, 100), ENSURE_REQUIREMENTS, [plan_id=126]

(714) Sort
Input [1]: [d_date_sk#165]
Arguments: [d_date_sk#165 ASC NULLS FIRST], false, 0

(715) SortMergeJoin
Left keys [1]: [cs_sold_date_sk#159]
Right keys [1]: [d_date_sk#165]
Join type: Inner
Join condition: None

(716) Project
Output [3]: [i_brand_id#162, i_class_id#163, i_category_id#164]
Input [5]: [cs_sold_date_sk#159, i_brand_id#162, i_class_id#163, i_category_id#164, d_date_sk#165]

(717) Exchange
Input [3]: [i_brand_id#162, i_class_id#163, i_category_id#164]
Arguments: hashpartitioning(coalesce(i_brand_id#162, 0), isnull(i_brand_id#162), coalesce(i_class_id#163, 0), isnull(i_class_id#163), coalesce(i_category_id#164, 0), isnull(i_category_id#164), 100), ENSURE_REQUIREMENTS, [plan_id=127]

(718) Sort
Input [3]: [i_brand_id#162, i_class_id#163, i_category_id#164]
Arguments: [coalesce(i_brand_id#162, 0) ASC NULLS FIRST, isnull(i_brand_id#162) ASC NULLS FIRST, coalesce(i_class_id#163, 0) ASC NULLS FIRST, isnull(i_class_id#163) ASC NULLS FIRST, coalesce(i_category_id#164, 0) ASC NULLS FIRST, isnull(i_category_id#164) ASC NULLS FIRST], false, 0

(719) SortMergeJoin
Left keys [6]: [coalesce(i_brand_id#156, 0), isnull(i_brand_id#156), coalesce(i_class_id#157, 0), isnull(i_class_id#157), coalesce(i_category_id#158, 0), isnull(i_category_id#158)]
Right keys [6]: [coalesce(i_brand_id#162, 0), isnull(i_brand_id#162), coalesce(i_class_id#163, 0), isnull(i_class_id#163), coalesce(i_category_id#164, 0), isnull(i_category_id#164)]
Join type: LeftSemi
Join condition: None

(720) Exchange
Input [4]: [i_item_sk#155, i_brand_id#156, i_class_id#157, i_category_id#158]
Arguments: hashpartitioning(i_item_sk#155, 100), ENSURE_REQUIREMENTS, [plan_id=128]

(721) Sort
Input [4]: [i_item_sk#155, i_brand_id#156, i_class_id#157, i_category_id#158]
Arguments: [i_item_sk#155 ASC NULLS FIRST], false, 0

(722) SortMergeJoin
Left keys [1]: [ss_item_sk#154]
Right keys [1]: [i_item_sk#155]
Join type: Inner
Join condition: None

(723) Project
Output [4]: [ss_sold_date_sk#153, i_brand_id#156, i_class_id#157, i_category_id#158]
Input [6]: [ss_sold_date_sk#153, ss_item_sk#154, i_item_sk#155, i_brand_id#156, i_class_id#157, i_category_id#158]

(724) Exchange
Input [4]: [ss_sold_date_sk#153, i_brand_id#156, i_class_id#157, i_category_id#158]
Arguments: hashpartitioning(ss_sold_date_sk#153, 100), ENSURE_REQUIREMENTS, [plan_id=129]

(725) Sort
Input [4]: [ss_sold_date_sk#153, i_brand_id#156, i_class_id#157, i_category_id#158]
Arguments: [ss_sold_date_sk#153 ASC NULLS FIRST], false, 0

(726) Scan parquet
Output [2]: [d_date_sk#167, d_year#168]
Batched: true
Location: InMemoryFileIndex [file:/<warehouse_dir>]
PushedFilters: [IsNotNull(d_year), GreaterThanOrEqual(d_year,1999), LessThanOrEqual(d_year,2001), IsNotNull(d_date_sk)]
ReadSchema: struct<d_date_sk:int,d_year:int>

(727) Filter
Input [2]: [d_date_sk#167, d_year#168]
Condition : (((isnotnull(d_year#168) AND (d_year#168 >= 1999)) AND (d_year#168 <= 2001)) AND isnotnull(d_date_sk#167))

(728) Project
Output [1]: [d_date_sk#167]
Input [2]: [d_date_sk#167, d_year#168]

(729) Exchange
Input [1]: [d_date_sk#167]
Arguments: hashpartitioning(d_date_sk#167, 100), ENSURE_REQUIREMENTS, [plan_id=130]

(730) Sort
Input [1]: [d_date_sk#167]
Arguments: [d_date_sk#167 ASC NULLS FIRST], false, 0

(731) SortMergeJoin
Left keys [1]: [ss_sold_date_sk#153]
Right keys [1]: [d_date_sk#167]
Join type: Inner
Join condition: None

(732) Project
Output [3]: [i_brand_id#156 AS brand_id#24, i_class_id#157 AS class_id#25, i_category_id#158 AS category_id#26]
Input [5]: [ss_sold_date_sk#153, i_brand_id#156, i_class_id#157, i_category_id#158, d_date_sk#167]

(733) HashAggregate
Input [3]: [brand_id#24, class_id#25, category_id#26]
Keys [3]: [brand_id#24, class_id#25, category_id#26]
Functions: []
Aggregate Attributes: []
Results [3]: [brand_id#24, class_id#25, category_id#26]

(734) Exchange
Input [3]: [brand_id#24, class_id#25, category_id#26]
Arguments: hashpartitioning(brand_id#24, class_id#25, category_id#26, 100), ENSURE_REQUIREMENTS, [plan_id=131]

(735) HashAggregate
Input [3]: [brand_id#24, class_id#25, category_id#26]
Keys [3]: [brand_id#24, class_id#25, category_id#26]
Functions: []
Aggregate Attributes: []
Results [3]: [brand_id#24, class_id#25, category_id#26]

(736) Exchange
Input [3]: [brand_id#24, class_id#25, category_id#26]
Arguments: hashpartitioning(coalesce(brand_id#24, 0), isnull(brand_id#24), coalesce(class_id#25, 0), isnull(class_id#25), coalesce(category_id#26, 0), isnull(category_id#26), 100), ENSURE_REQUIREMENTS, [plan_id=132]

(737) Sort
Input [3]: [brand_id#24, class_id#25, category_id#26]
Arguments: [coalesce(brand_id#24, 0) ASC NULLS FIRST, isnull(brand_id#24) ASC NULLS FIRST, coalesce(class_id#25, 0) ASC NULLS FIRST, isnull(class_id#25) ASC NULLS FIRST, coalesce(category_id#26, 0) ASC NULLS FIRST, isnull(category_id#26) ASC NULLS FIRST], false, 0

(738) Scan parquet
Output [2]: [ws_sold_date_sk#169, ws_item_sk#170]
Batched: true
Location: InMemoryFileIndex [file:/<warehouse_dir>]
PushedFilters: [IsNotNull(ws_item_sk), IsNotNull(ws_sold_date_sk)]
ReadSchema: struct<ws_sold_date_sk:int,ws_item_sk:int>

(739) Filter
Input [2]: [ws_sold_date_sk#169, ws_item_sk#170]
Condition : (isnotnull(ws_item_sk#170) AND isnotnull(ws_sold_date_sk#169))

(740) Exchange
Input [2]: [ws_sold_date_sk#169, ws_item_sk#170]
Arguments: hashpartitioning(ws_item_sk#170, 100), ENSURE_REQUIREMENTS, [plan_id=133]

(741) Sort
Input [2]: [ws_sold_date_sk#169, ws_item_sk#170]
Arguments: [ws_item_sk#170 ASC NULLS FIRST], false, 0

(742) Scan parquet
Output [4]: [i_item_sk#171, i_brand_id#172, i_class_id#173, i_category_id#174]
Batched: true
Location: InMemoryFileIndex [file:/<warehouse_dir>]
PushedFilters: [IsNotNull(i_item_sk)]
ReadSchema: struct<i_item_sk:int,i_brand_id:int,i_class_id:int,i_category_id:int>

(743) Filter
Input [4]: [i_item_sk#171, i_brand_id#172, i_class_id#173, i_category_id#174]
Condition : isnotnull(i_item_sk#171)

(744) Exchange
Input [4]: [i_item_sk#171, i_brand_id#172, i_class_id#173, i_category_id#174]
Arguments: hashpartitioning(i_item_sk#171, 100), ENSURE_REQUIREMENTS, [plan_id=134]

(745) Sort
Input [4]: [i_item_sk#171, i_brand_id#172, i_class_id#173, i_category_id#174]
Arguments: [i_item_sk#171 ASC NULLS FIRST], false, 0

(746) SortMergeJoin
Left keys [1]: [ws_item_sk#170]
Right keys [1]: [i_item_sk#171]
Join type: Inner
Join condition: None

(747) Project
Output [4]: [ws_sold_date_sk#169, i_brand_id#172, i_class_id#173, i_category_id#174]
Input [6]: [ws_sold_date_sk#169, ws_item_sk#170, i_item_sk#171, i_brand_id#172, i_class_id#173, i_category_id#174]

(748) Exchange
Input [4]: [ws_sold_date_sk#169, i_brand_id#172, i_class_id#173, i_category_id#174]
Arguments: hashpartitioning(ws_sold_date_sk#169, 100), ENSURE_REQUIREMENTS, [plan_id=135]

(749) Sort
Input [4]: [ws_sold_date_sk#169, i_brand_id#172, i_class_id#173, i_category_id#174]
Arguments: [ws_sold_date_sk#169 ASC NULLS FIRST], false, 0

(750) Scan parquet
Output [2]: [d_date_sk#175, d_year#176]
Batched: true
Location: InMemoryFileIndex [file:/<warehouse_dir>]
PushedFilters: [IsNotNull(d_year), GreaterThanOrEqual(d_year,1999), LessThanOrEqual(d_year,2001), IsNotNull(d_date_sk)]
ReadSchema: struct<d_date_sk:int,d_year:int>

(751) Filter
Input [2]: [d_date_sk#175, d_year#176]
Condition : (((isnotnull(d_year#176) AND (d_year#176 >= 1999)) AND (d_year#176 <= 2001)) AND isnotnull(d_date_sk#175))

(752) Project
Output [1]: [d_date_sk#175]
Input [2]: [d_date_sk#175, d_year#176]

(753) Exchange
Input [1]: [d_date_sk#175]
Arguments: hashpartitioning(d_date_sk#175, 100), ENSURE_REQUIREMENTS, [plan_id=136]

(754) Sort
Input [1]: [d_date_sk#175]
Arguments: [d_date_sk#175 ASC NULLS FIRST], false, 0

(755) SortMergeJoin
Left keys [1]: [ws_sold_date_sk#169]
Right keys [1]: [d_date_sk#175]
Join type: Inner
Join condition: None

(756) Project
Output [3]: [i_brand_id#172, i_class_id#173, i_category_id#174]
Input [5]: [ws_sold_date_sk#169, i_brand_id#172, i_class_id#173, i_category_id#174, d_date_sk#175]

(757) Exchange
Input [3]: [i_brand_id#172, i_class_id#173, i_category_id#174]
Arguments: hashpartitioning(coalesce(i_brand_id#172, 0), isnull(i_brand_id#172), coalesce(i_class_id#173, 0), isnull(i_class_id#173), coalesce(i_category_id#174, 0), isnull(i_category_id#174), 100), ENSURE_REQUIREMENTS, [plan_id=137]

(758) Sort
Input [3]: [i_brand_id#172, i_class_id#173, i_category_id#174]
Arguments: [coalesce(i_brand_id#172, 0) ASC NULLS FIRST, isnull(i_brand_id#172) ASC NULLS FIRST, coalesce(i_class_id#173, 0) ASC NULLS FIRST, isnull(i_class_id#173) ASC NULLS FIRST, coalesce(i_category_id#174, 0) ASC NULLS FIRST, isnull(i_category_id#174) ASC NULLS FIRST], false, 0

(759) SortMergeJoin
Left keys [6]: [coalesce(brand_id#24, 0), isnull(brand_id#24), coalesce(class_id#25, 0), isnull(class_id#25), coalesce(category_id#26, 0), isnull(category_id#26)]
Right keys [6]: [coalesce(i_brand_id#172, 0), isnull(i_brand_id#172), coalesce(i_class_id#173, 0), isnull(i_class_id#173), coalesce(i_category_id#174, 0), isnull(i_category_id#174)]
Join type: LeftSemi
Join condition: None

(760) Exchange
Input [3]: [brand_id#24, class_id#25, category_id#26]
Arguments: hashpartitioning(brand_id#24, class_id#25, category_id#26, 100), ENSURE_REQUIREMENTS, [plan_id=138]

(761) Sort
Input [3]: [brand_id#24, class_id#25, category_id#26]
Arguments: [brand_id#24 ASC NULLS FIRST, class_id#25 ASC NULLS FIRST, category_id#26 ASC NULLS FIRST], false, 0

(762) SortMergeJoin
Left keys [3]: [i_brand_id#150, i_class_id#151, i_category_id#152]
Right keys [3]: [brand_id#24, class_id#25, category_id#26]
Join type: Inner
Join condition: None

(763) Project
Output [1]: [i_item_sk#149 AS ss_item_sk#81]
Input [7]: [i_item_sk#149, i_brand_id#150, i_class_id#151, i_category_id#152, brand_id#24, class_id#25, category_id#26]

(764) Exchange
Input [1]: [ss_item_sk#81]
Arguments: hashpartitioning(ss_item_sk#81, 100), ENSURE_REQUIREMENTS, [plan_id=139]

(765) Sort
Input [1]: [ss_item_sk#81]
Arguments: [ss_item_sk#81 ASC NULLS FIRST], false, 0

(766) SortMergeJoin
Left keys [1]: [ws_item_sk#78]
Right keys [1]: [ss_item_sk#81]
Join type: LeftSemi
Join condition: None

(767) Scan parquet
Output [4]: [i_item_sk#82, i_brand_id#83, i_class_id#84, i_category_id#85]
Batched: true
Location: InMemoryFileIndex [file:/<warehouse_dir>]
PushedFilters: [IsNotNull(i_item_sk)]
ReadSchema: struct<i_item_sk:int,i_brand_id:int,i_class_id:int,i_category_id:int>

(768) Filter
Input [4]: [i_item_sk#82, i_brand_id#83, i_class_id#84, i_category_id#85]
Condition : isnotnull(i_item_sk#82)

(769) Exchange
Input [4]: [i_item_sk#82, i_brand_id#83, i_class_id#84, i_category_id#85]
Arguments: hashpartitioning(i_item_sk#82, 100), ENSURE_REQUIREMENTS, [plan_id=140]

(770) Sort
Input [4]: [i_item_sk#82, i_brand_id#83, i_class_id#84, i_category_id#85]
Arguments: [i_item_sk#82 ASC NULLS FIRST], false, 0

(771) Scan parquet
Output [4]: [i_item_sk#149, i_brand_id#150, i_class_id#151, i_category_id#152]
Batched: true
Location: InMemoryFileIndex [file:/<warehouse_dir>]
PushedFilters: [IsNotNull(i_brand_id), IsNotNull(i_class_id), IsNotNull(i_category_id)]
ReadSchema: struct<i_item_sk:int,i_brand_id:int,i_class_id:int,i_category_id:int>

(772) Filter
Input [4]: [i_item_sk#149, i_brand_id#150, i_class_id#151, i_category_id#152]
Condition : ((isnotnull(i_brand_id#150) AND isnotnull(i_class_id#151)) AND isnotnull(i_category_id#152))

(773) Exchange
Input [4]: [i_item_sk#149, i_brand_id#150, i_class_id#151, i_category_id#152]
Arguments: hashpartitioning(i_brand_id#150, i_class_id#151, i_category_id#152, 100), ENSURE_REQUIREMENTS, [plan_id=141]

(774) Sort
Input [4]: [i_item_sk#149, i_brand_id#150, i_class_id#151, i_category_id#152]
Arguments: [i_brand_id#150 ASC NULLS FIRST, i_class_id#151 ASC NULLS FIRST, i_category_id#152 ASC NULLS FIRST], false, 0

(775) Scan parquet
Output [2]: [ss_sold_date_sk#153, ss_item_sk#154]
Batched: true
Location: InMemoryFileIndex [file:/<warehouse_dir>]
PushedFilters: [IsNotNull(ss_item_sk), IsNotNull(ss_sold_date_sk)]
ReadSchema: struct<ss_sold_date_sk:int,ss_item_sk:int>

(776) Filter
Input [2]: [ss_sold_date_sk#153, ss_item_sk#154]
Condition : (isnotnull(ss_item_sk#154) AND isnotnull(ss_sold_date_sk#153))

(777) Exchange
Input [2]: [ss_sold_date_sk#153, ss_item_sk#154]
Arguments: hashpartitioning(ss_item_sk#154, 100), ENSURE_REQUIREMENTS, [plan_id=142]

(778) Sort
Input [2]: [ss_sold_date_sk#153, ss_item_sk#154]
Arguments: [ss_item_sk#154 ASC NULLS FIRST], false, 0

(779) Scan parquet
Output [4]: [i_item_sk#155, i_brand_id#156, i_class_id#157, i_category_id#158]
Batched: true
Location: InMemoryFileIndex [file:/<warehouse_dir>]
PushedFilters: [IsNotNull(i_item_sk), IsNotNull(i_brand_id), IsNotNull(i_class_id), IsNotNull(i_category_id)]
ReadSchema: struct<i_item_sk:int,i_brand_id:int,i_class_id:int,i_category_id:int>

(780) Filter
Input [4]: [i_item_sk#155, i_brand_id#156, i_class_id#157, i_category_id#158]
Condition : (((isnotnull(i_item_sk#155) AND isnotnull(i_brand_id#156)) AND isnotnull(i_class_id#157)) AND isnotnull(i_category_id#158))

(781) Exchange
Input [4]: [i_item_sk#155, i_brand_id#156, i_class_id#157, i_category_id#158]
Arguments: hashpartitioning(coalesce(i_brand_id#156, 0), isnull(i_brand_id#156), coalesce(i_class_id#157, 0), isnull(i_class_id#157), coalesce(i_category_id#158, 0), isnull(i_category_id#158), 100), ENSURE_REQUIREMENTS, [plan_id=143]

(782) Sort
Input [4]: [i_item_sk#155, i_brand_id#156, i_class_id#157, i_category_id#158]
Arguments: [coalesce(i_brand_id#156, 0) ASC NULLS FIRST, isnull(i_brand_id#156) ASC NULLS FIRST, coalesce(i_class_id#157, 0) ASC NULLS FIRST, isnull(i_class_id#157) ASC NULLS FIRST, coalesce(i_category_id#158, 0) ASC NULLS FIRST, isnull(i_category_id#158) ASC NULLS FIRST], false, 0

(783) Scan parquet
Output [2]: [cs_sold_date_sk#159, cs_item_sk#160]
Batched: true
Location: InMemoryFileIndex [file:/<warehouse_dir>]
PushedFilters: [IsNotNull(cs_item_sk), IsNotNull(cs_sold_date_sk)]
ReadSchema: struct<cs_sold_date_sk:int,cs_item_sk:int>

(784) Filter
Input [2]: [cs_sold_date_sk#159, cs_item_sk#160]
Condition : (isnotnull(cs_item_sk#160) AND isnotnull(cs_sold_date_sk#159))

(785) Exchange
Input [2]: [cs_sold_date_sk#159, cs_item_sk#160]
Arguments: hashpartitioning(cs_item_sk#160, 100), ENSURE_REQUIREMENTS, [plan_id=144]

(786) Sort
Input [2]: [cs_sold_date_sk#159, cs_item_sk#160]
Arguments: [cs_item_sk#160 ASC NULLS FIRST], false, 0

(787) Scan parquet
Output [4]: [i_item_sk#161, i_brand_id#162, i_class_id#163, i_category_id#164]
Batched: true
Location: InMemoryFileIndex [file:/<warehouse_dir>]
PushedFilters: [IsNotNull(i_item_sk)]
ReadSchema: struct<i_item_sk:int,i_brand_id:int,i_class_id:int,i_category_id:int>

(788) Filter
Input [4]: [i_item_sk#161, i_brand_id#162, i_class_id#163, i_category_id#164]
Condition : isnotnull(i_item_sk#161)

(789) Exchange
Input [4]: [i_item_sk#161, i_brand_id#162, i_class_id#163, i_category_id#164]
Arguments: hashpartitioning(i_item_sk#161, 100), ENSURE_REQUIREMENTS, [plan_id=145]

(790) Sort
Input [4]: [i_item_sk#161, i_brand_id#162, i_class_id#163, i_category_id#164]
Arguments: [i_item_sk#161 ASC NULLS FIRST], false, 0

(791) SortMergeJoin
Left keys [1]: [cs_item_sk#160]
Right keys [1]: [i_item_sk#161]
Join type: Inner
Join condition: None

(792) Project
Output [4]: [cs_sold_date_sk#159, i_brand_id#162, i_class_id#163, i_category_id#164]
Input [6]: [cs_sold_date_sk#159, cs_item_sk#160, i_item_sk#161, i_brand_id#162, i_class_id#163, i_category_id#164]

(793) Exchange
Input [4]: [cs_sold_date_sk#159, i_brand_id#162, i_class_id#163, i_category_id#164]
Arguments: hashpartitioning(cs_sold_date_sk#159, 100), ENSURE_REQUIREMENTS, [plan_id=146]

(794) Sort
Input [4]: [cs_sold_date_sk#159, i_brand_id#162, i_class_id#163, i_category_id#164]
Arguments: [cs_sold_date_sk#159 ASC NULLS FIRST], false, 0

(795) Scan parquet
Output [2]: [d_date_sk#165, d_year#166]
Batched: true
Location: InMemoryFileIndex [file:/<warehouse_dir>]
PushedFilters: [IsNotNull(d_year), GreaterThanOrEqual(d_year,1999), LessThanOrEqual(d_year,2001), IsNotNull(d_date_sk)]
ReadSchema: struct<d_date_sk:int,d_year:int>

(796) Filter
Input [2]: [d_date_sk#165, d_year#166]
Condition : (((isnotnull(d_year#166) AND (d_year#166 >= 1999)) AND (d_year#166 <= 2001)) AND isnotnull(d_date_sk#165))

(797) Project
Output [1]: [d_date_sk#165]
Input [2]: [d_date_sk#165, d_year#166]

(798) Exchange
Input [1]: [d_date_sk#165]
Arguments: hashpartitioning(d_date_sk#165, 100), ENSURE_REQUIREMENTS, [plan_id=147]

(799) Sort
Input [1]: [d_date_sk#165]
Arguments: [d_date_sk#165 ASC NULLS FIRST], false, 0

(800) SortMergeJoin
Left keys [1]: [cs_sold_date_sk#159]
Right keys [1]: [d_date_sk#165]
Join type: Inner
Join condition: None

(801) Project
Output [3]: [i_brand_id#162, i_class_id#163, i_category_id#164]
Input [5]: [cs_sold_date_sk#159, i_brand_id#162, i_class_id#163, i_category_id#164, d_date_sk#165]

(802) Exchange
Input [3]: [i_brand_id#162, i_class_id#163, i_category_id#164]
Arguments: hashpartitioning(coalesce(i_brand_id#162, 0), isnull(i_brand_id#162), coalesce(i_class_id#163, 0), isnull(i_class_id#163), coalesce(i_category_id#164, 0), isnull(i_category_id#164), 100), ENSURE_REQUIREMENTS, [plan_id=148]

(803) Sort
Input [3]: [i_brand_id#162, i_class_id#163, i_category_id#164]
Arguments: [coalesce(i_brand_id#162, 0) ASC NULLS FIRST, isnull(i_brand_id#162) ASC NULLS FIRST, coalesce(i_class_id#163, 0) ASC NULLS FIRST, isnull(i_class_id#163) ASC NULLS FIRST, coalesce(i_category_id#164, 0) ASC NULLS FIRST, isnull(i_category_id#164) ASC NULLS FIRST], false, 0

(804) SortMergeJoin
Left keys [6]: [coalesce(i_brand_id#156, 0), isnull(i_brand_id#156), coalesce(i_class_id#157, 0), isnull(i_class_id#157), coalesce(i_category_id#158, 0), isnull(i_category_id#158)]
Right keys [6]: [coalesce(i_brand_id#162, 0), isnull(i_brand_id#162), coalesce(i_class_id#163, 0), isnull(i_class_id#163), coalesce(i_category_id#164, 0), isnull(i_category_id#164)]
Join type: LeftSemi
Join condition: None

(805) Exchange
Input [4]: [i_item_sk#155, i_brand_id#156, i_class_id#157, i_category_id#158]
Arguments: hashpartitioning(i_item_sk#155, 100), ENSURE_REQUIREMENTS, [plan_id=149]

(806) Sort
Input [4]: [i_item_sk#155, i_brand_id#156, i_class_id#157, i_category_id#158]
Arguments: [i_item_sk#155 ASC NULLS FIRST], false, 0

(807) SortMergeJoin
Left keys [1]: [ss_item_sk#154]
Right keys [1]: [i_item_sk#155]
Join type: Inner
Join condition: None

(808) Project
Output [4]: [ss_sold_date_sk#153, i_brand_id#156, i_class_id#157, i_category_id#158]
Input [6]: [ss_sold_date_sk#153, ss_item_sk#154, i_item_sk#155, i_brand_id#156, i_class_id#157, i_category_id#158]

(809) Exchange
Input [4]: [ss_sold_date_sk#153, i_brand_id#156, i_class_id#157, i_category_id#158]
Arguments: hashpartitioning(ss_sold_date_sk#153, 100), ENSURE_REQUIREMENTS, [plan_id=150]

(810) Sort
Input [4]: [ss_sold_date_sk#153, i_brand_id#156, i_class_id#157, i_category_id#158]
Arguments: [ss_sold_date_sk#153 ASC NULLS FIRST], false, 0

(811) Scan parquet
Output [2]: [d_date_sk#167, d_year#168]
Batched: true
Location: InMemoryFileIndex [file:/<warehouse_dir>]
PushedFilters: [IsNotNull(d_year), GreaterThanOrEqual(d_year,1999), LessThanOrEqual(d_year,2001), IsNotNull(d_date_sk)]
ReadSchema: struct<d_date_sk:int,d_year:int>

(812) Filter
Input [2]: [d_date_sk#167, d_year#168]
Condition : (((isnotnull(d_year#168) AND (d_year#168 >= 1999)) AND (d_year#168 <= 2001)) AND isnotnull(d_date_sk#167))

(813) Project
Output [1]: [d_date_sk#167]
Input [2]: [d_date_sk#167, d_year#168]

(814) Exchange
Input [1]: [d_date_sk#167]
Arguments: hashpartitioning(d_date_sk#167, 100), ENSURE_REQUIREMENTS, [plan_id=151]

(815) Sort
Input [1]: [d_date_sk#167]
Arguments: [d_date_sk#167 ASC NULLS FIRST], false, 0

(816) SortMergeJoin
Left keys [1]: [ss_sold_date_sk#153]
Right keys [1]: [d_date_sk#167]
Join type: Inner
Join condition: None

(817) Project
Output [3]: [i_brand_id#156 AS brand_id#24, i_class_id#157 AS class_id#25, i_category_id#158 AS category_id#26]
Input [5]: [ss_sold_date_sk#153, i_brand_id#156, i_class_id#157, i_category_id#158, d_date_sk#167]

(818) HashAggregate
Input [3]: [brand_id#24, class_id#25, category_id#26]
Keys [3]: [brand_id#24, class_id#25, category_id#26]
Functions: []
Aggregate Attributes: []
Results [3]: [brand_id#24, class_id#25, category_id#26]

(819) Exchange
Input [3]: [brand_id#24, class_id#25, category_id#26]
Arguments: hashpartitioning(brand_id#24, class_id#25, category_id#26, 100), ENSURE_REQUIREMENTS, [plan_id=152]

(820) HashAggregate
Input [3]: [brand_id#24, class_id#25, category_id#26]
Keys [3]: [brand_id#24, class_id#25, category_id#26]
Functions: []
Aggregate Attributes: []
Results [3]: [brand_id#24, class_id#25, category_id#26]

(821) Exchange
Input [3]: [brand_id#24, class_id#25, category_id#26]
Arguments: hashpartitioning(coalesce(brand_id#24, 0), isnull(brand_id#24), coalesce(class_id#25, 0), isnull(class_id#25), coalesce(category_id#26, 0), isnull(category_id#26), 100), ENSURE_REQUIREMENTS, [plan_id=153]

(822) Sort
Input [3]: [brand_id#24, class_id#25, category_id#26]
Arguments: [coalesce(brand_id#24, 0) ASC NULLS FIRST, isnull(brand_id#24) ASC NULLS FIRST, coalesce(class_id#25, 0) ASC NULLS FIRST, isnull(class_id#25) ASC NULLS FIRST, coalesce(category_id#26, 0) ASC NULLS FIRST, isnull(category_id#26) ASC NULLS FIRST], false, 0

(823) Scan parquet
Output [2]: [ws_sold_date_sk#169, ws_item_sk#170]
Batched: true
Location: InMemoryFileIndex [file:/<warehouse_dir>]
PushedFilters: [IsNotNull(ws_item_sk), IsNotNull(ws_sold_date_sk)]
ReadSchema: struct<ws_sold_date_sk:int,ws_item_sk:int>

(824) Filter
Input [2]: [ws_sold_date_sk#169, ws_item_sk#170]
Condition : (isnotnull(ws_item_sk#170) AND isnotnull(ws_sold_date_sk#169))

(825) Exchange
Input [2]: [ws_sold_date_sk#169, ws_item_sk#170]
Arguments: hashpartitioning(ws_item_sk#170, 100), ENSURE_REQUIREMENTS, [plan_id=154]

(826) Sort
Input [2]: [ws_sold_date_sk#169, ws_item_sk#170]
Arguments: [ws_item_sk#170 ASC NULLS FIRST], false, 0

(827) Scan parquet
Output [4]: [i_item_sk#171, i_brand_id#172, i_class_id#173, i_category_id#174]
Batched: true
Location: InMemoryFileIndex [file:/<warehouse_dir>]
PushedFilters: [IsNotNull(i_item_sk)]
ReadSchema: struct<i_item_sk:int,i_brand_id:int,i_class_id:int,i_category_id:int>

(828) Filter
Input [4]: [i_item_sk#171, i_brand_id#172, i_class_id#173, i_category_id#174]
Condition : isnotnull(i_item_sk#171)

(829) Exchange
Input [4]: [i_item_sk#171, i_brand_id#172, i_class_id#173, i_category_id#174]
Arguments: hashpartitioning(i_item_sk#171, 100), ENSURE_REQUIREMENTS, [plan_id=155]

(830) Sort
Input [4]: [i_item_sk#171, i_brand_id#172, i_class_id#173, i_category_id#174]
Arguments: [i_item_sk#171 ASC NULLS FIRST], false, 0

(831) SortMergeJoin
Left keys [1]: [ws_item_sk#170]
Right keys [1]: [i_item_sk#171]
Join type: Inner
Join condition: None

(832) Project
Output [4]: [ws_sold_date_sk#169, i_brand_id#172, i_class_id#173, i_category_id#174]
Input [6]: [ws_sold_date_sk#169, ws_item_sk#170, i_item_sk#171, i_brand_id#172, i_class_id#173, i_category_id#174]

(833) Exchange
Input [4]: [ws_sold_date_sk#169, i_brand_id#172, i_class_id#173, i_category_id#174]
Arguments: hashpartitioning(ws_sold_date_sk#169, 100), ENSURE_REQUIREMENTS, [plan_id=156]

(834) Sort
Input [4]: [ws_sold_date_sk#169, i_brand_id#172, i_class_id#173, i_category_id#174]
Arguments: [ws_sold_date_sk#169 ASC NULLS FIRST], false, 0

(835) Scan parquet
Output [2]: [d_date_sk#175, d_year#176]
Batched: true
Location: InMemoryFileIndex [file:/<warehouse_dir>]
PushedFilters: [IsNotNull(d_year), GreaterThanOrEqual(d_year,1999), LessThanOrEqual(d_year,2001), IsNotNull(d_date_sk)]
ReadSchema: struct<d_date_sk:int,d_year:int>

(836) Filter
Input [2]: [d_date_sk#175, d_year#176]
Condition : (((isnotnull(d_year#176) AND (d_year#176 >= 1999)) AND (d_year#176 <= 2001)) AND isnotnull(d_date_sk#175))

(837) Project
Output [1]: [d_date_sk#175]
Input [2]: [d_date_sk#175, d_year#176]

(838) Exchange
Input [1]: [d_date_sk#175]
Arguments: hashpartitioning(d_date_sk#175, 100), ENSURE_REQUIREMENTS, [plan_id=157]

(839) Sort
Input [1]: [d_date_sk#175]
Arguments: [d_date_sk#175 ASC NULLS FIRST], false, 0

(840) SortMergeJoin
Left keys [1]: [ws_sold_date_sk#169]
Right keys [1]: [d_date_sk#175]
Join type: Inner
Join condition: None

(841) Project
Output [3]: [i_brand_id#172, i_class_id#173, i_category_id#174]
Input [5]: [ws_sold_date_sk#169, i_brand_id#172, i_class_id#173, i_category_id#174, d_date_sk#175]

(842) Exchange
Input [3]: [i_brand_id#172, i_class_id#173, i_category_id#174]
Arguments: hashpartitioning(coalesce(i_brand_id#172, 0), isnull(i_brand_id#172), coalesce(i_class_id#173, 0), isnull(i_class_id#173), coalesce(i_category_id#174, 0), isnull(i_category_id#174), 100), ENSURE_REQUIREMENTS, [plan_id=158]

(843) Sort
Input [3]: [i_brand_id#172, i_class_id#173, i_category_id#174]
Arguments: [coalesce(i_brand_id#172, 0) ASC NULLS FIRST, isnull(i_brand_id#172) ASC NULLS FIRST, coalesce(i_class_id#173, 0) ASC NULLS FIRST, isnull(i_class_id#173) ASC NULLS FIRST, coalesce(i_category_id#174, 0) ASC NULLS FIRST, isnull(i_category_id#174) ASC NULLS FIRST], false, 0

(844) SortMergeJoin
Left keys [6]: [coalesce(brand_id#24, 0), isnull(brand_id#24), coalesce(class_id#25, 0), isnull(class_id#25), coalesce(category_id#26, 0), isnull(category_id#26)]
Right keys [6]: [coalesce(i_brand_id#172, 0), isnull(i_brand_id#172), coalesce(i_class_id#173, 0), isnull(i_class_id#173), coalesce(i_category_id#174, 0), isnull(i_category_id#174)]
Join type: LeftSemi
Join condition: None

(845) Exchange
Input [3]: [brand_id#24, class_id#25, category_id#26]
Arguments: hashpartitioning(brand_id#24, class_id#25, category_id#26, 100), ENSURE_REQUIREMENTS, [plan_id=159]

(846) Sort
Input [3]: [brand_id#24, class_id#25, category_id#26]
Arguments: [brand_id#24 ASC NULLS FIRST, class_id#25 ASC NULLS FIRST, category_id#26 ASC NULLS FIRST], false, 0

(847) SortMergeJoin
Left keys [3]: [i_brand_id#150, i_class_id#151, i_category_id#152]
Right keys [3]: [brand_id#24, class_id#25, category_id#26]
Join type: Inner
Join condition: None

(848) Project
Output [1]: [i_item_sk#149 AS ss_item_sk#81]
Input [7]: [i_item_sk#149, i_brand_id#150, i_class_id#151, i_category_id#152, brand_id#24, class_id#25, category_id#26]

(849) Exchange
Input [1]: [ss_item_sk#81]
Arguments: hashpartitioning(ss_item_sk#81, 100), ENSURE_REQUIREMENTS, [plan_id=160]

(850) Sort
Input [1]: [ss_item_sk#81]
Arguments: [ss_item_sk#81 ASC NULLS FIRST], false, 0

(851) SortMergeJoin
Left keys [1]: [i_item_sk#82]
Right keys [1]: [ss_item_sk#81]
Join type: LeftSemi
Join condition: None

(852) SortMergeJoin
Left keys [1]: [ws_item_sk#78]
Right keys [1]: [i_item_sk#82]
Join type: Inner
Join condition: None

(853) Project
Output [6]: [ws_sold_date_sk#77, ws_quantity#79, ws_list_price#80, i_brand_id#83, i_class_id#84, i_category_id#85]
Input [8]: [ws_sold_date_sk#77, ws_item_sk#78, ws_quantity#79, ws_list_price#80, i_item_sk#82, i_brand_id#83, i_class_id#84, i_category_id#85]

(854) Exchange
Input [6]: [ws_sold_date_sk#77, ws_quantity#79, ws_list_price#80, i_brand_id#83, i_class_id#84, i_category_id#85]
Arguments: hashpartitioning(ws_sold_date_sk#77, 100), ENSURE_REQUIREMENTS, [plan_id=161]

(855) Sort
Input [6]: [ws_sold_date_sk#77, ws_quantity#79, ws_list_price#80, i_brand_id#83, i_class_id#84, i_category_id#85]
Arguments: [ws_sold_date_sk#77 ASC NULLS FIRST], false, 0

(856) Scan parquet
Output [3]: [d_date_sk#86, d_year#177, d_moy#178]
Batched: true
Location: InMemoryFileIndex [file:/<warehouse_dir>]
PushedFilters: [IsNotNull(d_year), IsNotNull(d_moy), EqualTo(d_year,2001), EqualTo(d_moy,11), IsNotNull(d_date_sk)]
ReadSchema: struct<d_date_sk:int,d_year:int,d_moy:int>

(857) Filter
Input [3]: [d_date_sk#86, d_year#177, d_moy#178]
Condition : ((((isnotnull(d_year#177) AND isnotnull(d_moy#178)) AND (d_year#177 = 2001)) AND (d_moy#178 = 11)) AND isnotnull(d_date_sk#86))

(858) Project
Output [1]: [d_date_sk#86]
Input [3]: [d_date_sk#86, d_year#177, d_moy#178]

(859) Exchange
Input [1]: [d_date_sk#86]
Arguments: hashpartitioning(d_date_sk#86, 100), ENSURE_REQUIREMENTS, [plan_id=162]

(860) Sort
Input [1]: [d_date_sk#86]
Arguments: [d_date_sk#86 ASC NULLS FIRST], false, 0

(861) SortMergeJoin
Left keys [1]: [ws_sold_date_sk#77]
Right keys [1]: [d_date_sk#86]
Join type: Inner
Join condition: None

(862) Project
Output [5]: [ws_quantity#79, ws_list_price#80, i_brand_id#83, i_class_id#84, i_category_id#85]
Input [7]: [ws_sold_date_sk#77, ws_quantity#79, ws_list_price#80, i_brand_id#83, i_class_id#84, i_category_id#85, d_date_sk#86]

(863) HashAggregate
Input [5]: [ws_quantity#79, ws_list_price#80, i_brand_id#83, i_class_id#84, i_category_id#85]
Keys [3]: [i_brand_id#83, i_class_id#84, i_category_id#85]
Functions [2]: [partial_sum((cast(ws_quantity#79 as decimal(10,0)) * ws_list_price#80)), partial_count(1)]
Aggregate Attributes [3]: [sum#88, isEmpty#89, count#90]
Results [6]: [i_brand_id#83, i_class_id#84, i_category_id#85, sum#179, isEmpty#180, count#181]

(864) Exchange
Input [6]: [i_brand_id#83, i_class_id#84, i_category_id#85, sum#179, isEmpty#180, count#181]
Arguments: hashpartitioning(i_brand_id#83, i_class_id#84, i_category_id#85, 100), ENSURE_REQUIREMENTS, [plan_id=163]

(865) HashAggregate
Input [6]: [i_brand_id#83, i_class_id#84, i_category_id#85, sum#179, isEmpty#180, count#181]
Keys [3]: [i_brand_id#83, i_class_id#84, i_category_id#85]
Functions [2]: [sum((cast(ws_quantity#79 as decimal(10,0)) * ws_list_price#80)), count(1)]
Aggregate Attributes [2]: [sum((cast(ws_quantity#79 as decimal(10,0)) * ws_list_price#80))#91, count(1)#92]
Results [5]: [i_brand_id#83, i_class_id#84, i_category_id#85, sum((cast(ws_quantity#79 as decimal(10,0)) * ws_list_price#80))#91 AS sales#93, count(1)#92 AS number_sales#94]

(866) Filter
Input [5]: [i_brand_id#83, i_class_id#84, i_category_id#85, sales#93, number_sales#94]
Condition : (isnotnull(sales#93) AND (cast(sales#93 as decimal(32,6)) > cast(Subquery subquery#182, [id=#183] as decimal(32,6))))

(867) Project
Output [6]: [sales#93, number_sales#94, web AS channel#95, i_brand_id#83, i_class_id#84, i_category_id#85]
Input [5]: [i_brand_id#83, i_class_id#84, i_category_id#85, sales#93, number_sales#94]

(868) Union

(869) Expand
Input [6]: [sales#50, number_sales#51, channel#54, i_brand_id#55, i_class_id#56, i_category_id#57]
Arguments: [[sales#50, number_sales#51, channel#54, i_brand_id#55, i_class_id#56, i_category_id#57, 0], [sales#50, number_sales#51, channel#54, i_brand_id#55, i_class_id#56, null, 1], [sales#50, number_sales#51, channel#54, i_brand_id#55, null, null, 3], [sales#50, number_sales#51, channel#54, null, null, null, 7], [sales#50, number_sales#51, null, null, null, null, 15]], [sales#50, number_sales#51, channel#97, i_brand_id#98, i_class_id#99, i_category_id#100, spark_grouping_id#101]

(870) HashAggregate
Input [7]: [sales#50, number_sales#51, channel#97, i_brand_id#98, i_class_id#99, i_category_id#100, spark_grouping_id#101]
Keys [5]: [channel#97, i_brand_id#98, i_class_id#99, i_category_id#100, spark_grouping_id#101]
Functions [2]: [partial_sum(sales#50), partial_sum(number_sales#51)]
Aggregate Attributes [3]: [sum#102, isEmpty#103, sum#104]
Results [8]: [channel#97, i_brand_id#98, i_class_id#99, i_category_id#100, spark_grouping_id#101, sum#184, isEmpty#185, sum#186]

(871) Exchange
Input [8]: [channel#97, i_brand_id#98, i_class_id#99, i_category_id#100, spark_grouping_id#101, sum#184, isEmpty#185, sum#186]
Arguments: hashpartitioning(channel#97, i_brand_id#98, i_class_id#99, i_category_id#100, spark_grouping_id#101, 100), ENSURE_REQUIREMENTS, [plan_id=164]

(872) HashAggregate
Input [8]: [channel#97, i_brand_id#98, i_class_id#99, i_category_id#100, spark_grouping_id#101, sum#184, isEmpty#185, sum#186]
Keys [5]: [channel#97, i_brand_id#98, i_class_id#99, i_category_id#100, spark_grouping_id#101]
Functions [2]: [sum(sales#50), sum(number_sales#51)]
Aggregate Attributes [2]: [sum(sales#50)#105, sum(number_sales#51)#106]
Results [6]: [channel#97, i_brand_id#98, i_class_id#99, i_category_id#100, sum(sales#50)#105 AS sum(sales)#107, sum(number_sales#51)#106 AS sum(number_sales)#108]

(873) TakeOrderedAndProject
Input [6]: [channel#97, i_brand_id#98, i_class_id#99, i_category_id#100, sum(sales)#107, sum(number_sales)#108]
Arguments: X, [channel#97 ASC NULLS FIRST, i_brand_id#98 ASC NULLS FIRST, i_class_id#99 ASC NULLS FIRST, i_category_id#100 ASC NULLS FIRST], [channel#97, i_brand_id#98, i_class_id#99, i_category_id#100, sum(sales)#107, sum(number_sales)#108]

(874) AdaptiveSparkPlan
Output [6]: [channel#97, i_brand_id#98, i_class_id#99, i_category_id#100, sum(sales)#107, sum(number_sales)#108]
Arguments: isFinalPlan=true

===== Subqueries =====

Subquery:1 Hosting operator id = 191 Hosting Expression = Subquery subquery#52, [id=#53]
AdaptiveSparkPlan (968)
+- == Final Plan ==
   NativeProject (930)
   +- NativeHashAggregate (929)
      +- ShuffleQueryStage (928), Statistics(X)
         +- NativeShuffleExchange (927)
            +- NativeHashAggregate (926)
               +- NativeProject (925)
                  +- InputAdapter (924)
                     +- NativeUnion (923)
                        :- NativeProject (890)
                        :  +- NativeSortMergeJoin Inner (889)
                        :     :- NativeSort (882)
                        :     :  +- InputAdapter (881)
                        :     :     +- AQEShuffleRead (880)
                        :     :        +- ShuffleQueryStage (879), Statistics(X)
                        :     :           +- NativeShuffleExchange (878)
                        :     :              +- NativeFilter (877)
                        :     :                 +- InputAdapter (876)
                        :     :                    +- NativeParquetScan  (875)
                        :     +- NativeSort (888)
                        :        +- InputAdapter (887)
                        :           +- InputAdapter (886)
                        :              +- AQEShuffleRead (885)
                        :                 +- ShuffleQueryStage (884), Statistics(X)
                        :                    +- ReusedExchange (883)
                        :- NativeProject (906)
                        :  +- NativeSortMergeJoin Inner (905)
                        :     :- NativeSort (898)
                        :     :  +- InputAdapter (897)
                        :     :     +- AQEShuffleRead (896)
                        :     :        +- ShuffleQueryStage (895), Statistics(X)
                        :     :           +- NativeShuffleExchange (894)
                        :     :              +- NativeFilter (893)
                        :     :                 +- InputAdapter (892)
                        :     :                    +- NativeParquetScan  (891)
                        :     +- NativeSort (904)
                        :        +- InputAdapter (903)
                        :           +- InputAdapter (902)
                        :              +- AQEShuffleRead (901)
                        :                 +- ShuffleQueryStage (900), Statistics(X)
                        :                    +- ReusedExchange (899)
                        +- NativeProject (922)
                           +- NativeSortMergeJoin Inner (921)
                              :- NativeSort (914)
                              :  +- InputAdapter (913)
                              :     +- AQEShuffleRead (912)
                              :        +- ShuffleQueryStage (911), Statistics(X)
                              :           +- NativeShuffleExchange (910)
                              :              +- NativeFilter (909)
                              :                 +- InputAdapter (908)
                              :                    +- NativeParquetScan  (907)
                              +- NativeSort (920)
                                 +- InputAdapter (919)
                                    +- InputAdapter (918)
                                       +- AQEShuffleRead (917)
                                          +- ShuffleQueryStage (916), Statistics(X)
                                             +- ReusedExchange (915)
+- == Initial Plan ==
   HashAggregate (967)
   +- Exchange (966)
      +- HashAggregate (965)
         +- Union (964)
            :- Project (941)
            :  +- SortMergeJoin Inner (940)
            :     :- Sort (934)
            :     :  +- Exchange (933)
            :     :     +- Filter (932)
            :     :        +- Scan parquet (931)
            :     +- Sort (939)
            :        +- Exchange (938)
            :           +- Project (937)
            :              +- Filter (936)
            :                 +- Scan parquet (935)
            :- Project (952)
            :  +- SortMergeJoin Inner (951)
            :     :- Sort (945)
            :     :  +- Exchange (944)
            :     :     +- Filter (943)
            :     :        +- Scan parquet (942)
            :     +- Sort (950)
            :        +- Exchange (949)
            :           +- Project (948)
            :              +- Filter (947)
            :                 +- Scan parquet (946)
            +- Project (963)
               +- SortMergeJoin Inner (962)
                  :- Sort (956)
                  :  +- Exchange (955)
                  :     +- Filter (954)
                  :        +- Scan parquet (953)
                  +- Sort (961)
                     +- Exchange (960)
                        +- Project (959)
                           +- Filter (958)
                              +- Scan parquet (957)


(931) Scan parquet
Output [3]: [ss_sold_date_sk#187, ss_quantity#188, ss_list_price#189]
Batched: true
Location: InMemoryFileIndex [file:/<warehouse_dir>]
PushedFilters: [IsNotNull(ss_sold_date_sk)]
ReadSchema: struct<ss_sold_date_sk:int,ss_quantity:int,ss_list_price:decimal(7,2)>

(876) InputAdapter
Input [3]: [ss_sold_date_sk#187, ss_quantity#188, ss_list_price#189]
Arguments: [#187, #188, #189]

(877) NativeFilter
Input [3]: [#187#187, #188#188, #189#189]
Condition : isnotnull(ss_sold_date_sk#187)

(878) NativeShuffleExchange
Input [3]: [#187#187, #188#188, #189#189]
Arguments: hashpartitioning(ss_sold_date_sk#187, 100), ENSURE_REQUIREMENTS, [plan_id=165]

(879) ShuffleQueryStage
Output [3]: [#187#187, #188#188, #189#189]
Arguments: X

(880) AQEShuffleRead
Input [3]: [#187#187, #188#188, #189#189]
Arguments: coalesced

(881) InputAdapter
Input [3]: [#187#187, #188#188, #189#189]

(882) NativeSort
Input [3]: [#187#187, #188#188, #189#189]
Arguments: [ss_sold_date_sk#187 ASC NULLS FIRST], false

(883) ReusedExchange [Reuses operator id: 60]
Output [1]: [d_date_sk#190]

(884) ShuffleQueryStage
Output [1]: [d_date_sk#190]
Arguments: X

(885) AQEShuffleRead
Input [1]: [d_date_sk#190]
Arguments: coalesced

(886) InputAdapter
Input [1]: [d_date_sk#190]
Arguments: [#190]

(887) InputAdapter
Input [1]: [#190#190]

(888) NativeSort
Input [1]: [#190#190]
Arguments: [d_date_sk#190 ASC NULLS FIRST], false

(889) NativeSortMergeJoin
Left keys [1]: [ss_sold_date_sk#187]
Right keys [1]: [d_date_sk#190]
Join type: Inner
Join condition: None

(890) NativeProject
Output [2]: [ss_quantity#188 AS quantity#191, ss_list_price#189 AS list_price#192]
Input [4]: [#187#187, #188#188, #189#189, #190#190]

(942) Scan parquet
Output [3]: [cs_sold_date_sk#193, cs_quantity#194, cs_list_price#195]
Batched: true
Location: InMemoryFileIndex [file:/<warehouse_dir>]
PushedFilters: [IsNotNull(cs_sold_date_sk)]
ReadSchema: struct<cs_sold_date_sk:int,cs_quantity:int,cs_list_price:decimal(7,2)>

(892) InputAdapter
Input [3]: [cs_sold_date_sk#193, cs_quantity#194, cs_list_price#195]
Arguments: [#193, #194, #195]

(893) NativeFilter
Input [3]: [#193#193, #194#194, #195#195]
Condition : isnotnull(cs_sold_date_sk#193)

(894) NativeShuffleExchange
Input [3]: [#193#193, #194#194, #195#195]
Arguments: hashpartitioning(cs_sold_date_sk#193, 100), ENSURE_REQUIREMENTS, [plan_id=166]

(895) ShuffleQueryStage
Output [3]: [#193#193, #194#194, #195#195]
Arguments: X

(896) AQEShuffleRead
Input [3]: [#193#193, #194#194, #195#195]
Arguments: coalesced

(897) InputAdapter
Input [3]: [#193#193, #194#194, #195#195]

(898) NativeSort
Input [3]: [#193#193, #194#194, #195#195]
Arguments: [cs_sold_date_sk#193 ASC NULLS FIRST], false

(899) ReusedExchange [Reuses operator id: 60]
Output [1]: [d_date_sk#196]

(900) ShuffleQueryStage
Output [1]: [d_date_sk#196]
Arguments: X

(901) AQEShuffleRead
Input [1]: [d_date_sk#196]
Arguments: coalesced

(902) InputAdapter
Input [1]: [d_date_sk#196]
Arguments: [#196]

(903) InputAdapter
Input [1]: [#196#196]

(904) NativeSort
Input [1]: [#196#196]
Arguments: [d_date_sk#196 ASC NULLS FIRST], false

(905) NativeSortMergeJoin
Left keys [1]: [cs_sold_date_sk#193]
Right keys [1]: [d_date_sk#196]
Join type: Inner
Join condition: None

(906) NativeProject
Output [2]: [cs_quantity#194 AS quantity#197, cs_list_price#195 AS list_price#198]
Input [4]: [#193#193, #194#194, #195#195, #196#196]

(953) Scan parquet
Output [3]: [ws_sold_date_sk#199, ws_quantity#200, ws_list_price#201]
Batched: true
Location: InMemoryFileIndex [file:/<warehouse_dir>]
PushedFilters: [IsNotNull(ws_sold_date_sk)]
ReadSchema: struct<ws_sold_date_sk:int,ws_quantity:int,ws_list_price:decimal(7,2)>

(908) InputAdapter
Input [3]: [ws_sold_date_sk#199, ws_quantity#200, ws_list_price#201]
Arguments: [#199, #200, #201]

(909) NativeFilter
Input [3]: [#199#199, #200#200, #201#201]
Condition : isnotnull(ws_sold_date_sk#199)

(910) NativeShuffleExchange
Input [3]: [#199#199, #200#200, #201#201]
Arguments: hashpartitioning(ws_sold_date_sk#199, 100), ENSURE_REQUIREMENTS, [plan_id=167]

(911) ShuffleQueryStage
Output [3]: [#199#199, #200#200, #201#201]
Arguments: X

(912) AQEShuffleRead
Input [3]: [#199#199, #200#200, #201#201]
Arguments: coalesced

(913) InputAdapter
Input [3]: [#199#199, #200#200, #201#201]

(914) NativeSort
Input [3]: [#199#199, #200#200, #201#201]
Arguments: [ws_sold_date_sk#199 ASC NULLS FIRST], false

(915) ReusedExchange [Reuses operator id: 60]
Output [1]: [d_date_sk#202]

(916) ShuffleQueryStage
Output [1]: [d_date_sk#202]
Arguments: X

(917) AQEShuffleRead
Input [1]: [d_date_sk#202]
Arguments: coalesced

(918) InputAdapter
Input [1]: [d_date_sk#202]
Arguments: [#202]

(919) InputAdapter
Input [1]: [#202#202]

(920) NativeSort
Input [1]: [#202#202]
Arguments: [d_date_sk#202 ASC NULLS FIRST], false

(921) NativeSortMergeJoin
Left keys [1]: [ws_sold_date_sk#199]
Right keys [1]: [d_date_sk#202]
Join type: Inner
Join condition: None

(922) NativeProject
Output [2]: [ws_quantity#200 AS quantity#203, ws_list_price#201 AS list_price#204]
Input [4]: [#199#199, #200#200, #201#201, #202#202]

(923) NativeUnion
Arguments: [quantity#191, list_price#192]

(924) InputAdapter
Input [2]: [quantity#191, list_price#192]
Arguments: [#191, #192]

(925) NativeProject
Output [1]: [(cast(quantity#191 as decimal(10,0)) * list_price#192) AS _c0#205]
Input [2]: [#191#191, #192#192]

(926) NativeHashAggregate
Input [1]: [_c0#205]
Keys: []
Functions [1]: [partial_avg(_c0#205)]
Aggregate Attributes [2]: [sum#206, count#207]
Results [2]: [#46, #47]

(927) NativeShuffleExchange
Input [2]: [#46, #47]
Arguments: SinglePartition, ENSURE_REQUIREMENTS, [plan_id=168]

(928) ShuffleQueryStage
Output [2]: [#46, #47]
Arguments: X

(929) NativeHashAggregate
Input [2]: [#46, #47]
Keys: []
Functions [1]: [avg((cast(quantity#191 as decimal(10,0)) * list_price#192))]
Aggregate Attributes [1]: [avg((cast(quantity#191 as decimal(10,0)) * list_price#192))#208]
Results [1]: [avg((cast(quantity#191 as decimal(10,0)) * list_price#192))#208]

(930) NativeProject
Output [1]: [avg((cast(quantity#191 as decimal(10,0)) * list_price#192))#208 AS average_sales#209]
Input [1]: [avg((cast(quantity#191 as decimal(10,0)) * list_price#192))#208]

(931) Scan parquet
Output [3]: [ss_sold_date_sk#187, ss_quantity#188, ss_list_price#189]
Batched: true
Location: InMemoryFileIndex [file:/<warehouse_dir>]
PushedFilters: [IsNotNull(ss_sold_date_sk)]
ReadSchema: struct<ss_sold_date_sk:int,ss_quantity:int,ss_list_price:decimal(7,2)>

(932) Filter
Input [3]: [ss_sold_date_sk#187, ss_quantity#188, ss_list_price#189]
Condition : isnotnull(ss_sold_date_sk#187)

(933) Exchange
Input [3]: [ss_sold_date_sk#187, ss_quantity#188, ss_list_price#189]
Arguments: hashpartitioning(ss_sold_date_sk#187, 100), ENSURE_REQUIREMENTS, [plan_id=169]

(934) Sort
Input [3]: [ss_sold_date_sk#187, ss_quantity#188, ss_list_price#189]
Arguments: [ss_sold_date_sk#187 ASC NULLS FIRST], false, 0

(935) Scan parquet
Output [2]: [d_date_sk#190, d_year#210]
Batched: true
Location: InMemoryFileIndex [file:/<warehouse_dir>]
PushedFilters: [IsNotNull(d_year), GreaterThanOrEqual(d_year,1999), LessThanOrEqual(d_year,2001), IsNotNull(d_date_sk)]
ReadSchema: struct<d_date_sk:int,d_year:int>

(936) Filter
Input [2]: [d_date_sk#190, d_year#210]
Condition : (((isnotnull(d_year#210) AND (d_year#210 >= 1999)) AND (d_year#210 <= 2001)) AND isnotnull(d_date_sk#190))

(937) Project
Output [1]: [d_date_sk#190]
Input [2]: [d_date_sk#190, d_year#210]

(938) Exchange
Input [1]: [d_date_sk#190]
Arguments: hashpartitioning(d_date_sk#190, 100), ENSURE_REQUIREMENTS, [plan_id=170]

(939) Sort
Input [1]: [d_date_sk#190]
Arguments: [d_date_sk#190 ASC NULLS FIRST], false, 0

(940) SortMergeJoin
Left keys [1]: [ss_sold_date_sk#187]
Right keys [1]: [d_date_sk#190]
Join type: Inner
Join condition: None

(941) Project
Output [2]: [ss_quantity#188 AS quantity#191, ss_list_price#189 AS list_price#192]
Input [4]: [ss_sold_date_sk#187, ss_quantity#188, ss_list_price#189, d_date_sk#190]

(942) Scan parquet
Output [3]: [cs_sold_date_sk#193, cs_quantity#194, cs_list_price#195]
Batched: true
Location: InMemoryFileIndex [file:/<warehouse_dir>]
PushedFilters: [IsNotNull(cs_sold_date_sk)]
ReadSchema: struct<cs_sold_date_sk:int,cs_quantity:int,cs_list_price:decimal(7,2)>

(943) Filter
Input [3]: [cs_sold_date_sk#193, cs_quantity#194, cs_list_price#195]
Condition : isnotnull(cs_sold_date_sk#193)

(944) Exchange
Input [3]: [cs_sold_date_sk#193, cs_quantity#194, cs_list_price#195]
Arguments: hashpartitioning(cs_sold_date_sk#193, 100), ENSURE_REQUIREMENTS, [plan_id=171]

(945) Sort
Input [3]: [cs_sold_date_sk#193, cs_quantity#194, cs_list_price#195]
Arguments: [cs_sold_date_sk#193 ASC NULLS FIRST], false, 0

(946) Scan parquet
Output [2]: [d_date_sk#196, d_year#211]
Batched: true
Location: InMemoryFileIndex [file:/<warehouse_dir>]
PushedFilters: [IsNotNull(d_year), GreaterThanOrEqual(d_year,1999), LessThanOrEqual(d_year,2001), IsNotNull(d_date_sk)]
ReadSchema: struct<d_date_sk:int,d_year:int>

(947) Filter
Input [2]: [d_date_sk#196, d_year#211]
Condition : (((isnotnull(d_year#211) AND (d_year#211 >= 1999)) AND (d_year#211 <= 2001)) AND isnotnull(d_date_sk#196))

(948) Project
Output [1]: [d_date_sk#196]
Input [2]: [d_date_sk#196, d_year#211]

(949) Exchange
Input [1]: [d_date_sk#196]
Arguments: hashpartitioning(d_date_sk#196, 100), ENSURE_REQUIREMENTS, [plan_id=172]

(950) Sort
Input [1]: [d_date_sk#196]
Arguments: [d_date_sk#196 ASC NULLS FIRST], false, 0

(951) SortMergeJoin
Left keys [1]: [cs_sold_date_sk#193]
Right keys [1]: [d_date_sk#196]
Join type: Inner
Join condition: None

(952) Project
Output [2]: [cs_quantity#194 AS quantity#197, cs_list_price#195 AS list_price#198]
Input [4]: [cs_sold_date_sk#193, cs_quantity#194, cs_list_price#195, d_date_sk#196]

(953) Scan parquet
Output [3]: [ws_sold_date_sk#199, ws_quantity#200, ws_list_price#201]
Batched: true
Location: InMemoryFileIndex [file:/<warehouse_dir>]
PushedFilters: [IsNotNull(ws_sold_date_sk)]
ReadSchema: struct<ws_sold_date_sk:int,ws_quantity:int,ws_list_price:decimal(7,2)>

(954) Filter
Input [3]: [ws_sold_date_sk#199, ws_quantity#200, ws_list_price#201]
Condition : isnotnull(ws_sold_date_sk#199)

(955) Exchange
Input [3]: [ws_sold_date_sk#199, ws_quantity#200, ws_list_price#201]
Arguments: hashpartitioning(ws_sold_date_sk#199, 100), ENSURE_REQUIREMENTS, [plan_id=173]

(956) Sort
Input [3]: [ws_sold_date_sk#199, ws_quantity#200, ws_list_price#201]
Arguments: [ws_sold_date_sk#199 ASC NULLS FIRST], false, 0

(957) Scan parquet
Output [2]: [d_date_sk#202, d_year#212]
Batched: true
Location: InMemoryFileIndex [file:/<warehouse_dir>]
PushedFilters: [IsNotNull(d_year), GreaterThanOrEqual(d_year,1999), LessThanOrEqual(d_year,2001), IsNotNull(d_date_sk)]
ReadSchema: struct<d_date_sk:int,d_year:int>

(958) Filter
Input [2]: [d_date_sk#202, d_year#212]
Condition : (((isnotnull(d_year#212) AND (d_year#212 >= 1999)) AND (d_year#212 <= 2001)) AND isnotnull(d_date_sk#202))

(959) Project
Output [1]: [d_date_sk#202]
Input [2]: [d_date_sk#202, d_year#212]

(960) Exchange
Input [1]: [d_date_sk#202]
Arguments: hashpartitioning(d_date_sk#202, 100), ENSURE_REQUIREMENTS, [plan_id=174]

(961) Sort
Input [1]: [d_date_sk#202]
Arguments: [d_date_sk#202 ASC NULLS FIRST], false, 0

(962) SortMergeJoin
Left keys [1]: [ws_sold_date_sk#199]
Right keys [1]: [d_date_sk#202]
Join type: Inner
Join condition: None

(963) Project
Output [2]: [ws_quantity#200 AS quantity#203, ws_list_price#201 AS list_price#204]
Input [4]: [ws_sold_date_sk#199, ws_quantity#200, ws_list_price#201, d_date_sk#202]

(964) Union

(965) HashAggregate
Input [2]: [quantity#191, list_price#192]
Keys: []
Functions [1]: [partial_avg((cast(quantity#191 as decimal(10,0)) * list_price#192))]
Aggregate Attributes [2]: [sum#206, count#207]
Results [2]: [sum#213, count#214]

(966) Exchange
Input [2]: [sum#213, count#214]
Arguments: SinglePartition, ENSURE_REQUIREMENTS, [plan_id=175]

(967) HashAggregate
Input [2]: [sum#213, count#214]
Keys: []
Functions [1]: [avg((cast(quantity#191 as decimal(10,0)) * list_price#192))]
Aggregate Attributes [1]: [avg((cast(quantity#191 as decimal(10,0)) * list_price#192))#208]
Results [1]: [avg((cast(quantity#191 as decimal(10,0)) * list_price#192))#208 AS average_sales#209]

(968) AdaptiveSparkPlan
Output [1]: [average_sales#209]
Arguments: isFinalPlan=true

Subquery:2 Hosting operator id = 244 Hosting Expression = ReusedSubquery Subquery subquery#52, [id=#53]

Subquery:3 Hosting operator id = 297 Hosting Expression = ReusedSubquery Subquery subquery#52, [id=#53]


