== Physical Plan ==
AdaptiveSparkPlan (599)
+- == Final Plan ==
   NativeProject (224)
   +- NativeTakeOrdered (223)
      +- NativeSortMergeJoin Inner (222)
         :- NativeSort (194)
         :  +- NativeFilter (193)
         :     +- NativeProject (192)
         :        +- NativeHashAggregate (191)
         :           +- InputAdapter (190)
         :              +- AQEShuffleRead (189)
         :                 +- ShuffleQueryStage (188), Statistics(X)
         :                    +- NativeShuffleExchange (187)
         :                       +- NativeHashAggregate (186)
         :                          +- NativeProject (185)
         :                             +- NativeProject (184)
         :                                +- NativeSortMergeJoin Inner (183)
         :                                   :- NativeSort (173)
         :                                   :  +- InputAdapter (172)
         :                                   :     +- AQEShuffleRead (171)
         :                                   :        +- ShuffleQueryStage (170), Statistics(X)
         :                                   :           +- NativeShuffleExchange (169)
         :                                   :              +- NativeProject (168)
         :                                   :                 +- NativeSortMergeJoin Inner (167)
         :                                   :                    :- 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 (166)
         :                                   :                       :- NativeSort (160)
         :                                   :                       :  +- InputAdapter (159)
         :                                   :                       :     +- AQEShuffleRead (158)
         :                                   :                       :        +- ShuffleQueryStage (157), Statistics(X)
         :                                   :                       :           +- NativeShuffleExchange (156)
         :                                   :                       :              +- NativeFilter (155)
         :                                   :                       :                 +- InputAdapter (154)
         :                                   :                       :                    +- NativeParquetScan  (153)
         :                                   :                       +- NativeSort (165)
         :                                   :                          +- InputAdapter (164)
         :                                   :                             +- AQEShuffleRead (163)
         :                                   :                                +- ShuffleQueryStage (162), Statistics(X)
         :                                   :                                   +- ReusedExchange (161)
         :                                   +- NativeSort (182)
         :                                      +- InputAdapter (181)
         :                                         +- AQEShuffleRead (180)
         :                                            +- ShuffleQueryStage (179), Statistics(X)
         :                                               +- NativeShuffleExchange (178)
         :                                                  +- NativeProject (177)
         :                                                     +- NativeFilter (176)
         :                                                        +- InputAdapter (175)
         :                                                           +- NativeParquetScan  (174)
         +- NativeSort (221)
            +- NativeFilter (220)
               +- NativeProject (219)
                  +- NativeHashAggregate (218)
                     +- InputAdapter (217)
                        +- AQEShuffleRead (216)
                           +- ShuffleQueryStage (215), Statistics(X)
                              +- NativeShuffleExchange (214)
                                 +- NativeHashAggregate (213)
                                    +- NativeProject (212)
                                       +- NativeProject (211)
                                          +- NativeSortMergeJoin Inner (210)
                                             :- NativeSort (200)
                                             :  +- InputAdapter (199)
                                             :     +- InputAdapter (198)
                                             :        +- AQEShuffleRead (197)
                                             :           +- ShuffleQueryStage (196), Statistics(X)
                                             :              +- ReusedExchange (195)
                                             +- NativeSort (209)
                                                +- InputAdapter (208)
                                                   +- AQEShuffleRead (207)
                                                      +- ShuffleQueryStage (206), Statistics(X)
                                                         +- NativeShuffleExchange (205)
                                                            +- NativeProject (204)
                                                               +- NativeFilter (203)
                                                                  +- InputAdapter (202)
                                                                     +- NativeParquetScan  (201)
+- == Initial Plan ==
   TakeOrderedAndProject (598)
   +- SortMergeJoin Inner (597)
      :- Sort (410)
      :  +- Filter (409)
      :     +- HashAggregate (408)
      :        +- Exchange (407)
      :           +- HashAggregate (406)
      :              +- Project (405)
      :                 +- SortMergeJoin Inner (404)
      :                    :- Sort (398)
      :                    :  +- Exchange (397)
      :                    :     +- Project (396)
      :                    :        +- SortMergeJoin Inner (395)
      :                    :           :- SortMergeJoin LeftSemi (309)
      :                    :           :  :- Sort (228)
      :                    :           :  :  +- Exchange (227)
      :                    :           :  :     +- Filter (226)
      :                    :           :  :        +- Scan parquet (225)
      :                    :           :  +- Sort (308)
      :                    :           :     +- Exchange (307)
      :                    :           :        +- Project (306)
      :                    :           :           +- SortMergeJoin Inner (305)
      :                    :           :              :- Sort (232)
      :                    :           :              :  +- Exchange (231)
      :                    :           :              :     +- Filter (230)
      :                    :           :              :        +- Scan parquet (229)
      :                    :           :              +- Sort (304)
      :                    :           :                 +- Exchange (303)
      :                    :           :                    +- SortMergeJoin LeftSemi (302)
      :                    :           :                       :- Sort (280)
      :                    :           :                       :  +- Exchange (279)
      :                    :           :                       :     +- HashAggregate (278)
      :                    :           :                       :        +- Exchange (277)
      :                    :           :                       :           +- HashAggregate (276)
      :                    :           :                       :              +- Project (275)
      :                    :           :                       :                 +- SortMergeJoin Inner (274)
      :                    :           :                       :                    :- Sort (268)
      :                    :           :                       :                    :  +- Exchange (267)
      :                    :           :                       :                    :     +- Project (266)
      :                    :           :                       :                    :        +- SortMergeJoin Inner (265)
      :                    :           :                       :                    :           :- Sort (236)
      :                    :           :                       :                    :           :  +- Exchange (235)
      :                    :           :                       :                    :           :     +- Filter (234)
      :                    :           :                       :                    :           :        +- Scan parquet (233)
      :                    :           :                       :                    :           +- Sort (264)
      :                    :           :                       :                    :              +- Exchange (263)
      :                    :           :                       :                    :                 +- SortMergeJoin LeftSemi (262)
      :                    :           :                       :                    :                    :- Sort (240)
      :                    :           :                       :                    :                    :  +- Exchange (239)
      :                    :           :                       :                    :                    :     +- Filter (238)
      :                    :           :                       :                    :                    :        +- Scan parquet (237)
      :                    :           :                       :                    :                    +- Sort (261)
      :                    :           :                       :                    :                       +- Exchange (260)
      :                    :           :                       :                    :                          +- Project (259)
      :                    :           :                       :                    :                             +- SortMergeJoin Inner (258)
      :                    :           :                       :                    :                                :- Sort (252)
      :                    :           :                       :                    :                                :  +- Exchange (251)
      :                    :           :                       :                    :                                :     +- Project (250)
      :                    :           :                       :                    :                                :        +- SortMergeJoin Inner (249)
      :                    :           :                       :                    :                                :           :- Sort (244)
      :                    :           :                       :                    :                                :           :  +- Exchange (243)
      :                    :           :                       :                    :                                :           :     +- Filter (242)
      :                    :           :                       :                    :                                :           :        +- Scan parquet (241)
      :                    :           :                       :                    :                                :           +- Sort (248)
      :                    :           :                       :                    :                                :              +- Exchange (247)
      :                    :           :                       :                    :                                :                 +- Filter (246)
      :                    :           :                       :                    :                                :                    +- Scan parquet (245)
      :                    :           :                       :                    :                                +- Sort (257)
      :                    :           :                       :                    :                                   +- Exchange (256)
      :                    :           :                       :                    :                                      +- Project (255)
      :                    :           :                       :                    :                                         +- Filter (254)
      :                    :           :                       :                    :                                            +- Scan parquet (253)
      :                    :           :                       :                    +- Sort (273)
      :                    :           :                       :                       +- Exchange (272)
      :                    :           :                       :                          +- Project (271)
      :                    :           :                       :                             +- Filter (270)
      :                    :           :                       :                                +- Scan parquet (269)
      :                    :           :                       +- Sort (301)
      :                    :           :                          +- Exchange (300)
      :                    :           :                             +- Project (299)
      :                    :           :                                +- SortMergeJoin Inner (298)
      :                    :           :                                   :- Sort (292)
      :                    :           :                                   :  +- Exchange (291)
      :                    :           :                                   :     +- Project (290)
      :                    :           :                                   :        +- SortMergeJoin Inner (289)
      :                    :           :                                   :           :- Sort (284)
      :                    :           :                                   :           :  +- Exchange (283)
      :                    :           :                                   :           :     +- Filter (282)
      :                    :           :                                   :           :        +- Scan parquet (281)
      :                    :           :                                   :           +- Sort (288)
      :                    :           :                                   :              +- Exchange (287)
      :                    :           :                                   :                 +- Filter (286)
      :                    :           :                                   :                    +- Scan parquet (285)
      :                    :           :                                   +- Sort (297)
      :                    :           :                                      +- Exchange (296)
      :                    :           :                                         +- Project (295)
      :                    :           :                                            +- Filter (294)
      :                    :           :                                               +- Scan parquet (293)
      :                    :           +- 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)
      :                    +- Sort (403)
      :                       +- Exchange (402)
      :                          +- Project (401)
      :                             +- Filter (400)
      :                                +- Scan parquet (399)
      +- Sort (596)
         +- Filter (595)
            +- HashAggregate (594)
               +- Exchange (593)
                  +- HashAggregate (592)
                     +- Project (591)
                        +- SortMergeJoin Inner (590)
                           :- Sort (584)
                           :  +- Exchange (583)
                           :     +- Project (582)
                           :        +- SortMergeJoin Inner (581)
                           :           :- SortMergeJoin LeftSemi (495)
                           :           :  :- Sort (414)
                           :           :  :  +- Exchange (413)
                           :           :  :     +- Filter (412)
                           :           :  :        +- Scan parquet (411)
                           :           :  +- Sort (494)
                           :           :     +- Exchange (493)
                           :           :        +- Project (492)
                           :           :           +- SortMergeJoin Inner (491)
                           :           :              :- Sort (418)
                           :           :              :  +- Exchange (417)
                           :           :              :     +- Filter (416)
                           :           :              :        +- Scan parquet (415)
                           :           :              +- Sort (490)
                           :           :                 +- Exchange (489)
                           :           :                    +- SortMergeJoin LeftSemi (488)
                           :           :                       :- Sort (466)
                           :           :                       :  +- Exchange (465)
                           :           :                       :     +- HashAggregate (464)
                           :           :                       :        +- Exchange (463)
                           :           :                       :           +- HashAggregate (462)
                           :           :                       :              +- Project (461)
                           :           :                       :                 +- SortMergeJoin Inner (460)
                           :           :                       :                    :- Sort (454)
                           :           :                       :                    :  +- Exchange (453)
                           :           :                       :                    :     +- Project (452)
                           :           :                       :                    :        +- SortMergeJoin Inner (451)
                           :           :                       :                    :           :- Sort (422)
                           :           :                       :                    :           :  +- Exchange (421)
                           :           :                       :                    :           :     +- Filter (420)
                           :           :                       :                    :           :        +- Scan parquet (419)
                           :           :                       :                    :           +- Sort (450)
                           :           :                       :                    :              +- Exchange (449)
                           :           :                       :                    :                 +- SortMergeJoin LeftSemi (448)
                           :           :                       :                    :                    :- Sort (426)
                           :           :                       :                    :                    :  +- Exchange (425)
                           :           :                       :                    :                    :     +- Filter (424)
                           :           :                       :                    :                    :        +- Scan parquet (423)
                           :           :                       :                    :                    +- Sort (447)
                           :           :                       :                    :                       +- Exchange (446)
                           :           :                       :                    :                          +- Project (445)
                           :           :                       :                    :                             +- SortMergeJoin Inner (444)
                           :           :                       :                    :                                :- Sort (438)
                           :           :                       :                    :                                :  +- Exchange (437)
                           :           :                       :                    :                                :     +- Project (436)
                           :           :                       :                    :                                :        +- SortMergeJoin Inner (435)
                           :           :                       :                    :                                :           :- Sort (430)
                           :           :                       :                    :                                :           :  +- Exchange (429)
                           :           :                       :                    :                                :           :     +- Filter (428)
                           :           :                       :                    :                                :           :        +- Scan parquet (427)
                           :           :                       :                    :                                :           +- Sort (434)
                           :           :                       :                    :                                :              +- Exchange (433)
                           :           :                       :                    :                                :                 +- Filter (432)
                           :           :                       :                    :                                :                    +- Scan parquet (431)
                           :           :                       :                    :                                +- Sort (443)
                           :           :                       :                    :                                   +- Exchange (442)
                           :           :                       :                    :                                      +- Project (441)
                           :           :                       :                    :                                         +- Filter (440)
                           :           :                       :                    :                                            +- Scan parquet (439)
                           :           :                       :                    +- Sort (459)
                           :           :                       :                       +- Exchange (458)
                           :           :                       :                          +- Project (457)
                           :           :                       :                             +- Filter (456)
                           :           :                       :                                +- Scan parquet (455)
                           :           :                       +- Sort (487)
                           :           :                          +- Exchange (486)
                           :           :                             +- Project (485)
                           :           :                                +- SortMergeJoin Inner (484)
                           :           :                                   :- Sort (478)
                           :           :                                   :  +- Exchange (477)
                           :           :                                   :     +- Project (476)
                           :           :                                   :        +- SortMergeJoin Inner (475)
                           :           :                                   :           :- Sort (470)
                           :           :                                   :           :  +- Exchange (469)
                           :           :                                   :           :     +- Filter (468)
                           :           :                                   :           :        +- Scan parquet (467)
                           :           :                                   :           +- Sort (474)
                           :           :                                   :              +- Exchange (473)
                           :           :                                   :                 +- Filter (472)
                           :           :                                   :                    +- Scan parquet (471)
                           :           :                                   +- Sort (483)
                           :           :                                      +- Exchange (482)
                           :           :                                         +- Project (481)
                           :           :                                            +- Filter (480)
                           :           :                                               +- Scan parquet (479)
                           :           +- 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)
                           +- Sort (589)
                              +- Exchange (588)
                                 +- Project (587)
                                    +- Filter (586)
                                       +- Scan parquet (585)


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

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

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

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

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

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

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

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

(310) 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), 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>

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

(155) NativeFilter
Input [4]: [#35#35, #36#36, #37#37, #38#38]
Condition : (((isnotnull(i_item_sk#35) AND isnotnull(i_brand_id#36)) AND isnotnull(i_class_id#37)) AND isnotnull(i_category_id#38))

(156) NativeShuffleExchange
Input [4]: [#35#35, #36#36, #37#37, #38#38]
Arguments: hashpartitioning(i_item_sk#35, 100), ENSURE_REQUIREMENTS, [plan_id=19]

(157) ShuffleQueryStage
Output [4]: [#35#35, #36#36, #37#37, #38#38]
Arguments: X

(158) AQEShuffleRead
Input [4]: [#35#35, #36#36, #37#37, #38#38]
Arguments: coalesced

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

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

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

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

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

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

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

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

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

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

(169) 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=20]

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

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

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

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

(399) Scan parquet
Output [2]: [d_date_sk#39, d_week_seq#40]
Batched: true
Location: InMemoryFileIndex [file:/<warehouse_dir>]
PushedFilters: [IsNotNull(d_week_seq), IsNotNull(d_date_sk)]
ReadSchema: struct<d_date_sk:int,d_week_seq:int>

(175) InputAdapter
Input [2]: [d_date_sk#39, d_week_seq#40]
Arguments: [#39, #40]

(176) NativeFilter
Input [2]: [#39#39, #40#40]
Condition : ((isnotnull(d_week_seq#40) AND (d_week_seq#40 = Subquery subquery#41, [id=#42])) AND isnotnull(d_date_sk#39))

(177) NativeProject
Output [1]: [d_date_sk#39]
Input [2]: [#39#39, #40#40]

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

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

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

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

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

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

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

(185) 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#43]
Input [5]: [ss_quantity#3, ss_list_price#4, i_brand_id#36, i_class_id#37, i_category_id#38]

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

(187) NativeShuffleExchange
Input [5]: [i_brand_id#36, i_class_id#37, i_category_id#38, #47, #48]
Arguments: hashpartitioning(i_brand_id#36, i_class_id#37, i_category_id#38, 100), ENSURE_REQUIREMENTS, [plan_id=22]

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

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

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

(191) NativeHashAggregate
Input [5]: [i_brand_id#36, i_class_id#37, i_category_id#38, #47, #48]
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))#49, count(1)#50]
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))#49, count(1)#50]

(192) NativeProject
Output [6]: [store AS channel#51, 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))#49 AS sales#52, count(1)#50 AS number_sales#53]
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))#49, count(1)#50]

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

(194) NativeSort
Input [6]: [channel#51, i_brand_id#36, i_class_id#37, i_category_id#38, sales#52, number_sales#53]
Arguments: [i_brand_id#36 ASC NULLS FIRST, i_class_id#37 ASC NULLS FIRST, i_category_id#38 ASC NULLS FIRST], false

(195) ReusedExchange [Reuses operator id: 169]
Output [6]: [ss_sold_date_sk#56, ss_quantity#57, ss_list_price#58, i_brand_id#59, i_class_id#60, i_category_id#61]

(196) ShuffleQueryStage
Output [6]: [ss_sold_date_sk#56, ss_quantity#57, ss_list_price#58, i_brand_id#59, i_class_id#60, i_category_id#61]
Arguments: X

(197) AQEShuffleRead
Input [6]: [ss_sold_date_sk#56, ss_quantity#57, ss_list_price#58, i_brand_id#59, i_class_id#60, i_category_id#61]
Arguments: coalesced

(198) InputAdapter
Input [6]: [ss_sold_date_sk#56, ss_quantity#57, ss_list_price#58, i_brand_id#59, i_class_id#60, i_category_id#61]
Arguments: [#56, #57, #58, #59, #60, #61]

(199) InputAdapter
Input [6]: [#56#56, #57#57, #58#58, #59#59, #60#60, #61#61]

(200) NativeSort
Input [6]: [#56#56, #57#57, #58#58, #59#59, #60#60, #61#61]
Arguments: [ss_sold_date_sk#56 ASC NULLS FIRST], false

(585) Scan parquet
Output [2]: [d_date_sk#62, d_week_seq#63]
Batched: true
Location: InMemoryFileIndex [file:/<warehouse_dir>]
PushedFilters: [IsNotNull(d_week_seq), IsNotNull(d_date_sk)]
ReadSchema: struct<d_date_sk:int,d_week_seq:int>

(202) InputAdapter
Input [2]: [d_date_sk#62, d_week_seq#63]
Arguments: [#62, #63]

(203) NativeFilter
Input [2]: [#62#62, #63#63]
Condition : ((isnotnull(d_week_seq#63) AND (d_week_seq#63 = Subquery subquery#64, [id=#65])) AND isnotnull(d_date_sk#62))

(204) NativeProject
Output [1]: [d_date_sk#62]
Input [2]: [#62#62, #63#63]

(205) NativeShuffleExchange
Input [1]: [d_date_sk#62]
Arguments: hashpartitioning(d_date_sk#62, 100), ENSURE_REQUIREMENTS, [plan_id=23]

(206) ShuffleQueryStage
Output [1]: [d_date_sk#62]
Arguments: X

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

(208) InputAdapter
Input [1]: [d_date_sk#62]

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

(210) NativeSortMergeJoin
Left keys [1]: [ss_sold_date_sk#56]
Right keys [1]: [d_date_sk#62]
Join type: Inner
Join condition: None

(211) NativeProject
Output [5]: [ss_quantity#57, ss_list_price#58, i_brand_id#59, i_class_id#60, i_category_id#61]
Input [7]: [#56#56, #57#57, #58#58, #59#59, #60#60, #61#61, d_date_sk#62]

(212) NativeProject
Output [4]: [i_brand_id#59 AS i_brand_id#59, i_class_id#60 AS i_class_id#60, i_category_id#61 AS i_category_id#61, (cast(ss_quantity#57 as decimal(10,0)) * ss_list_price#58) AS _c3#66]
Input [5]: [ss_quantity#57, ss_list_price#58, i_brand_id#59, i_class_id#60, i_category_id#61]

(213) NativeHashAggregate
Input [4]: [i_brand_id#59, i_class_id#60, i_category_id#61, _c3#66]
Keys [3]: [i_brand_id#59, i_class_id#60, i_category_id#61]
Functions [2]: [partial_sum(_c3#66), partial_count(1)]
Aggregate Attributes [3]: [sum#67, isEmpty#68, count#69]
Results [5]: [i_brand_id#59, i_class_id#60, i_category_id#61, #47, #48]

(214) NativeShuffleExchange
Input [5]: [i_brand_id#59, i_class_id#60, i_category_id#61, #47, #48]
Arguments: hashpartitioning(i_brand_id#59, i_class_id#60, i_category_id#61, 100), ENSURE_REQUIREMENTS, [plan_id=24]

(215) ShuffleQueryStage
Output [5]: [i_brand_id#59, i_class_id#60, i_category_id#61, #47, #48]
Arguments: X

(216) AQEShuffleRead
Input [5]: [i_brand_id#59, i_class_id#60, i_category_id#61, #47, #48]
Arguments: coalesced

(217) InputAdapter
Input [5]: [i_brand_id#59, i_class_id#60, i_category_id#61, #47, #48]

(218) NativeHashAggregate
Input [5]: [i_brand_id#59, i_class_id#60, i_category_id#61, #47, #48]
Keys [3]: [i_brand_id#59, i_class_id#60, i_category_id#61]
Functions [2]: [sum((cast(ss_quantity#57 as decimal(10,0)) * ss_list_price#58)), count(1)]
Aggregate Attributes [2]: [sum((cast(ss_quantity#57 as decimal(10,0)) * ss_list_price#58))#70, count(1)#71]
Results [5]: [i_brand_id#59, i_class_id#60, i_category_id#61, sum((cast(ss_quantity#57 as decimal(10,0)) * ss_list_price#58))#70, count(1)#71]

(219) NativeProject
Output [6]: [store AS channel#72, i_brand_id#59, i_class_id#60, i_category_id#61, sum((cast(ss_quantity#57 as decimal(10,0)) * ss_list_price#58))#70 AS sales#73, count(1)#71 AS number_sales#74]
Input [5]: [i_brand_id#59, i_class_id#60, i_category_id#61, sum((cast(ss_quantity#57 as decimal(10,0)) * ss_list_price#58))#70, count(1)#71]

(220) NativeFilter
Input [6]: [channel#72, i_brand_id#59, i_class_id#60, i_category_id#61, sales#73, number_sales#74]
Condition : (isnotnull(sales#73) AND (cast(sales#73 as decimal(32,6)) > cast(ReusedSubquery Subquery subquery#54, [id=#55] as decimal(32,6))))

(221) NativeSort
Input [6]: [channel#72, i_brand_id#59, i_class_id#60, i_category_id#61, sales#73, number_sales#74]
Arguments: [i_brand_id#59 ASC NULLS FIRST, i_class_id#60 ASC NULLS FIRST, i_category_id#61 ASC NULLS FIRST], false

(222) NativeSortMergeJoin
Left keys [3]: [i_brand_id#36, i_class_id#37, i_category_id#38]
Right keys [3]: [i_brand_id#59, i_class_id#60, i_category_id#61]
Join type: Inner
Join condition: None

(223) NativeTakeOrdered
Input [12]: [channel#51, i_brand_id#36, i_class_id#37, i_category_id#38, sales#52, number_sales#53, channel#72, i_brand_id#59, i_class_id#60, i_category_id#61, sales#73, number_sales#74]
Arguments: X, X, [i_brand_id#36 ASC NULLS FIRST, i_class_id#37 ASC NULLS FIRST, i_category_id#38 ASC NULLS FIRST]

(224) NativeProject
Output [12]: [channel#51, i_brand_id#36, i_class_id#37, i_category_id#38, sales#52, number_sales#53, channel#72, i_brand_id#59, i_class_id#60, i_category_id#61, sales#73, number_sales#74]
Input [12]: [channel#51, i_brand_id#36, i_class_id#37, i_category_id#38, sales#52, number_sales#53, channel#72, i_brand_id#59, i_class_id#60, i_category_id#61, sales#73, number_sales#74]

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

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

(227) 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=25]

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

(251) 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=31]

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

(267) 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=35]

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

(269) Scan parquet
Output [2]: [d_date_sk#23, d_year#75]
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>

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

(271) Project
Output [1]: [d_date_sk#23]
Input [2]: [d_date_sk#23, d_year#75]

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

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

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

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

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

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

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

(279) 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=38]

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

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

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

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

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

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

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

(287) 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=40]

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

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

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

(291) 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=41]

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

(293) Scan parquet
Output [2]: [d_date_sk#33, d_year#76]
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>

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

(295) Project
Output [1]: [d_date_sk#33]
Input [2]: [d_date_sk#33, d_year#76]

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

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

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

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

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

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

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

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

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

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

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

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

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

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

(310) 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), 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>

(311) 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) AND isnotnull(i_brand_id#36)) AND isnotnull(i_class_id#37)) AND isnotnull(i_category_id#38))

(312) 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=46]

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

(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=47]

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

(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=49]

(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=50]

(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=51]

(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=52]

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

(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=54]

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

(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=56]

(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#75]
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#75]
Condition : (((isnotnull(d_year#75) AND (d_year#75 >= 1999)) AND (d_year#75 <= 2001)) AND isnotnull(d_date_sk#23))

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

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

(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=58]

(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=59]

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

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

(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=62]

(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#76]
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#76]
Condition : (((isnotnull(d_year#76) AND (d_year#76 >= 1999)) AND (d_year#76 <= 2001)) AND isnotnull(d_date_sk#33))

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

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

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

(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=65]

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

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

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

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

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

(397) 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=67]

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

(399) Scan parquet
Output [2]: [d_date_sk#39, d_week_seq#40]
Batched: true
Location: InMemoryFileIndex [file:/<warehouse_dir>]
PushedFilters: [IsNotNull(d_week_seq), IsNotNull(d_date_sk)]
ReadSchema: struct<d_date_sk:int,d_week_seq:int>

(400) Filter
Input [2]: [d_date_sk#39, d_week_seq#40]
Condition : ((isnotnull(d_week_seq#40) AND (d_week_seq#40 = Subquery subquery#41, [id=#42])) AND isnotnull(d_date_sk#39))

(401) Project
Output [1]: [d_date_sk#39]
Input [2]: [d_date_sk#39, d_week_seq#40]

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

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

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

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

(406) 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#44, isEmpty#45, count#46]
Results [6]: [i_brand_id#36, i_class_id#37, i_category_id#38, sum#77, isEmpty#78, count#79]

(407) Exchange
Input [6]: [i_brand_id#36, i_class_id#37, i_category_id#38, sum#77, isEmpty#78, count#79]
Arguments: hashpartitioning(i_brand_id#36, i_class_id#37, i_category_id#38, 100), ENSURE_REQUIREMENTS, [plan_id=69]

(408) HashAggregate
Input [6]: [i_brand_id#36, i_class_id#37, i_category_id#38, sum#77, isEmpty#78, count#79]
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))#49, count(1)#50]
Results [6]: [store AS channel#51, 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))#49 AS sales#52, count(1)#50 AS number_sales#53]

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

(410) Sort
Input [6]: [channel#51, i_brand_id#36, i_class_id#37, i_category_id#38, sales#52, number_sales#53]
Arguments: [i_brand_id#36 ASC NULLS FIRST, i_class_id#37 ASC NULLS FIRST, i_category_id#38 ASC NULLS FIRST], false, 0

(411) Scan parquet
Output [4]: [ss_sold_date_sk#56, ss_item_sk#80, ss_quantity#57, ss_list_price#58]
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)>

(412) Filter
Input [4]: [ss_sold_date_sk#56, ss_item_sk#80, ss_quantity#57, ss_list_price#58]
Condition : (isnotnull(ss_item_sk#80) AND isnotnull(ss_sold_date_sk#56))

(413) Exchange
Input [4]: [ss_sold_date_sk#56, ss_item_sk#80, ss_quantity#57, ss_list_price#58]
Arguments: hashpartitioning(ss_item_sk#80, 100), ENSURE_REQUIREMENTS, [plan_id=70]

(414) Sort
Input [4]: [ss_sold_date_sk#56, ss_item_sk#80, ss_quantity#57, ss_list_price#58]
Arguments: [ss_item_sk#80 ASC NULLS FIRST], false, 0

(415) Scan parquet
Output [4]: [i_item_sk#81, i_brand_id#82, i_class_id#83, i_category_id#84]
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>

(416) Filter
Input [4]: [i_item_sk#81, i_brand_id#82, i_class_id#83, i_category_id#84]
Condition : ((isnotnull(i_brand_id#82) AND isnotnull(i_class_id#83)) AND isnotnull(i_category_id#84))

(417) Exchange
Input [4]: [i_item_sk#81, i_brand_id#82, i_class_id#83, i_category_id#84]
Arguments: hashpartitioning(i_brand_id#82, i_class_id#83, i_category_id#84, 100), ENSURE_REQUIREMENTS, [plan_id=71]

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

(419) Scan parquet
Output [2]: [ss_sold_date_sk#85, ss_item_sk#86]
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>

(420) Filter
Input [2]: [ss_sold_date_sk#85, ss_item_sk#86]
Condition : (isnotnull(ss_item_sk#86) AND isnotnull(ss_sold_date_sk#85))

(421) Exchange
Input [2]: [ss_sold_date_sk#85, ss_item_sk#86]
Arguments: hashpartitioning(ss_item_sk#86, 100), ENSURE_REQUIREMENTS, [plan_id=72]

(422) Sort
Input [2]: [ss_sold_date_sk#85, ss_item_sk#86]
Arguments: [ss_item_sk#86 ASC NULLS FIRST], false, 0

(423) Scan parquet
Output [4]: [i_item_sk#87, i_brand_id#88, i_class_id#89, i_category_id#90]
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>

(424) Filter
Input [4]: [i_item_sk#87, i_brand_id#88, i_class_id#89, i_category_id#90]
Condition : (((isnotnull(i_item_sk#87) AND isnotnull(i_brand_id#88)) AND isnotnull(i_class_id#89)) AND isnotnull(i_category_id#90))

(425) Exchange
Input [4]: [i_item_sk#87, i_brand_id#88, i_class_id#89, i_category_id#90]
Arguments: hashpartitioning(coalesce(i_brand_id#88, 0), isnull(i_brand_id#88), coalesce(i_class_id#89, 0), isnull(i_class_id#89), coalesce(i_category_id#90, 0), isnull(i_category_id#90), 100), ENSURE_REQUIREMENTS, [plan_id=73]

(426) Sort
Input [4]: [i_item_sk#87, i_brand_id#88, i_class_id#89, i_category_id#90]
Arguments: [coalesce(i_brand_id#88, 0) ASC NULLS FIRST, isnull(i_brand_id#88) ASC NULLS FIRST, coalesce(i_class_id#89, 0) ASC NULLS FIRST, isnull(i_class_id#89) ASC NULLS FIRST, coalesce(i_category_id#90, 0) ASC NULLS FIRST, isnull(i_category_id#90) ASC NULLS FIRST], false, 0

(427) Scan parquet
Output [2]: [cs_sold_date_sk#91, cs_item_sk#92]
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>

(428) Filter
Input [2]: [cs_sold_date_sk#91, cs_item_sk#92]
Condition : (isnotnull(cs_item_sk#92) AND isnotnull(cs_sold_date_sk#91))

(429) Exchange
Input [2]: [cs_sold_date_sk#91, cs_item_sk#92]
Arguments: hashpartitioning(cs_item_sk#92, 100), ENSURE_REQUIREMENTS, [plan_id=74]

(430) Sort
Input [2]: [cs_sold_date_sk#91, cs_item_sk#92]
Arguments: [cs_item_sk#92 ASC NULLS FIRST], false, 0

(431) Scan parquet
Output [4]: [i_item_sk#93, i_brand_id#94, i_class_id#95, i_category_id#96]
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>

(432) Filter
Input [4]: [i_item_sk#93, i_brand_id#94, i_class_id#95, i_category_id#96]
Condition : isnotnull(i_item_sk#93)

(433) Exchange
Input [4]: [i_item_sk#93, i_brand_id#94, i_class_id#95, i_category_id#96]
Arguments: hashpartitioning(i_item_sk#93, 100), ENSURE_REQUIREMENTS, [plan_id=75]

(434) Sort
Input [4]: [i_item_sk#93, i_brand_id#94, i_class_id#95, i_category_id#96]
Arguments: [i_item_sk#93 ASC NULLS FIRST], false, 0

(435) SortMergeJoin
Left keys [1]: [cs_item_sk#92]
Right keys [1]: [i_item_sk#93]
Join type: Inner
Join condition: None

(436) Project
Output [4]: [cs_sold_date_sk#91, i_brand_id#94, i_class_id#95, i_category_id#96]
Input [6]: [cs_sold_date_sk#91, cs_item_sk#92, i_item_sk#93, i_brand_id#94, i_class_id#95, i_category_id#96]

(437) Exchange
Input [4]: [cs_sold_date_sk#91, i_brand_id#94, i_class_id#95, i_category_id#96]
Arguments: hashpartitioning(cs_sold_date_sk#91, 100), ENSURE_REQUIREMENTS, [plan_id=76]

(438) Sort
Input [4]: [cs_sold_date_sk#91, i_brand_id#94, i_class_id#95, i_category_id#96]
Arguments: [cs_sold_date_sk#91 ASC NULLS FIRST], false, 0

(439) Scan parquet
Output [2]: [d_date_sk#97, d_year#98]
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#97, d_year#98]
Condition : (((isnotnull(d_year#98) AND (d_year#98 >= 1999)) AND (d_year#98 <= 2001)) AND isnotnull(d_date_sk#97))

(441) Project
Output [1]: [d_date_sk#97]
Input [2]: [d_date_sk#97, d_year#98]

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

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

(444) SortMergeJoin
Left keys [1]: [cs_sold_date_sk#91]
Right keys [1]: [d_date_sk#97]
Join type: Inner
Join condition: None

(445) Project
Output [3]: [i_brand_id#94, i_class_id#95, i_category_id#96]
Input [5]: [cs_sold_date_sk#91, i_brand_id#94, i_class_id#95, i_category_id#96, d_date_sk#97]

(446) Exchange
Input [3]: [i_brand_id#94, i_class_id#95, i_category_id#96]
Arguments: hashpartitioning(coalesce(i_brand_id#94, 0), isnull(i_brand_id#94), coalesce(i_class_id#95, 0), isnull(i_class_id#95), coalesce(i_category_id#96, 0), isnull(i_category_id#96), 100), ENSURE_REQUIREMENTS, [plan_id=78]

(447) Sort
Input [3]: [i_brand_id#94, i_class_id#95, i_category_id#96]
Arguments: [coalesce(i_brand_id#94, 0) ASC NULLS FIRST, isnull(i_brand_id#94) ASC NULLS FIRST, coalesce(i_class_id#95, 0) ASC NULLS FIRST, isnull(i_class_id#95) ASC NULLS FIRST, coalesce(i_category_id#96, 0) ASC NULLS FIRST, isnull(i_category_id#96) ASC NULLS FIRST], false, 0

(448) SortMergeJoin
Left keys [6]: [coalesce(i_brand_id#88, 0), isnull(i_brand_id#88), coalesce(i_class_id#89, 0), isnull(i_class_id#89), coalesce(i_category_id#90, 0), isnull(i_category_id#90)]
Right keys [6]: [coalesce(i_brand_id#94, 0), isnull(i_brand_id#94), coalesce(i_class_id#95, 0), isnull(i_class_id#95), coalesce(i_category_id#96, 0), isnull(i_category_id#96)]
Join type: LeftSemi
Join condition: None

(449) Exchange
Input [4]: [i_item_sk#87, i_brand_id#88, i_class_id#89, i_category_id#90]
Arguments: hashpartitioning(i_item_sk#87, 100), ENSURE_REQUIREMENTS, [plan_id=79]

(450) Sort
Input [4]: [i_item_sk#87, i_brand_id#88, i_class_id#89, i_category_id#90]
Arguments: [i_item_sk#87 ASC NULLS FIRST], false, 0

(451) SortMergeJoin
Left keys [1]: [ss_item_sk#86]
Right keys [1]: [i_item_sk#87]
Join type: Inner
Join condition: None

(452) Project
Output [4]: [ss_sold_date_sk#85, i_brand_id#88, i_class_id#89, i_category_id#90]
Input [6]: [ss_sold_date_sk#85, ss_item_sk#86, i_item_sk#87, i_brand_id#88, i_class_id#89, i_category_id#90]

(453) Exchange
Input [4]: [ss_sold_date_sk#85, i_brand_id#88, i_class_id#89, i_category_id#90]
Arguments: hashpartitioning(ss_sold_date_sk#85, 100), ENSURE_REQUIREMENTS, [plan_id=80]

(454) Sort
Input [4]: [ss_sold_date_sk#85, i_brand_id#88, i_class_id#89, i_category_id#90]
Arguments: [ss_sold_date_sk#85 ASC NULLS FIRST], false, 0

(455) Scan parquet
Output [2]: [d_date_sk#99, d_year#100]
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>

(456) Filter
Input [2]: [d_date_sk#99, d_year#100]
Condition : (((isnotnull(d_year#100) AND (d_year#100 >= 1999)) AND (d_year#100 <= 2001)) AND isnotnull(d_date_sk#99))

(457) Project
Output [1]: [d_date_sk#99]
Input [2]: [d_date_sk#99, d_year#100]

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

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

(460) SortMergeJoin
Left keys [1]: [ss_sold_date_sk#85]
Right keys [1]: [d_date_sk#99]
Join type: Inner
Join condition: None

(461) Project
Output [3]: [i_brand_id#88 AS brand_id#24, i_class_id#89 AS class_id#25, i_category_id#90 AS category_id#26]
Input [5]: [ss_sold_date_sk#85, i_brand_id#88, i_class_id#89, i_category_id#90, d_date_sk#99]

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

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

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

(465) 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=83]

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

(467) Scan parquet
Output [2]: [ws_sold_date_sk#101, ws_item_sk#102]
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>

(468) Filter
Input [2]: [ws_sold_date_sk#101, ws_item_sk#102]
Condition : (isnotnull(ws_item_sk#102) AND isnotnull(ws_sold_date_sk#101))

(469) Exchange
Input [2]: [ws_sold_date_sk#101, ws_item_sk#102]
Arguments: hashpartitioning(ws_item_sk#102, 100), ENSURE_REQUIREMENTS, [plan_id=84]

(470) Sort
Input [2]: [ws_sold_date_sk#101, ws_item_sk#102]
Arguments: [ws_item_sk#102 ASC NULLS FIRST], false, 0

(471) Scan parquet
Output [4]: [i_item_sk#103, i_brand_id#104, i_class_id#105, i_category_id#106]
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>

(472) Filter
Input [4]: [i_item_sk#103, i_brand_id#104, i_class_id#105, i_category_id#106]
Condition : isnotnull(i_item_sk#103)

(473) Exchange
Input [4]: [i_item_sk#103, i_brand_id#104, i_class_id#105, i_category_id#106]
Arguments: hashpartitioning(i_item_sk#103, 100), ENSURE_REQUIREMENTS, [plan_id=85]

(474) Sort
Input [4]: [i_item_sk#103, i_brand_id#104, i_class_id#105, i_category_id#106]
Arguments: [i_item_sk#103 ASC NULLS FIRST], false, 0

(475) SortMergeJoin
Left keys [1]: [ws_item_sk#102]
Right keys [1]: [i_item_sk#103]
Join type: Inner
Join condition: None

(476) Project
Output [4]: [ws_sold_date_sk#101, i_brand_id#104, i_class_id#105, i_category_id#106]
Input [6]: [ws_sold_date_sk#101, ws_item_sk#102, i_item_sk#103, i_brand_id#104, i_class_id#105, i_category_id#106]

(477) Exchange
Input [4]: [ws_sold_date_sk#101, i_brand_id#104, i_class_id#105, i_category_id#106]
Arguments: hashpartitioning(ws_sold_date_sk#101, 100), ENSURE_REQUIREMENTS, [plan_id=86]

(478) Sort
Input [4]: [ws_sold_date_sk#101, i_brand_id#104, i_class_id#105, i_category_id#106]
Arguments: [ws_sold_date_sk#101 ASC NULLS FIRST], false, 0

(479) Scan parquet
Output [2]: [d_date_sk#107, d_year#108]
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>

(480) Filter
Input [2]: [d_date_sk#107, d_year#108]
Condition : (((isnotnull(d_year#108) AND (d_year#108 >= 1999)) AND (d_year#108 <= 2001)) AND isnotnull(d_date_sk#107))

(481) Project
Output [1]: [d_date_sk#107]
Input [2]: [d_date_sk#107, d_year#108]

(482) Exchange
Input [1]: [d_date_sk#107]
Arguments: hashpartitioning(d_date_sk#107, 100), ENSURE_REQUIREMENTS, [plan_id=87]

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

(484) SortMergeJoin
Left keys [1]: [ws_sold_date_sk#101]
Right keys [1]: [d_date_sk#107]
Join type: Inner
Join condition: None

(485) Project
Output [3]: [i_brand_id#104, i_class_id#105, i_category_id#106]
Input [5]: [ws_sold_date_sk#101, i_brand_id#104, i_class_id#105, i_category_id#106, d_date_sk#107]

(486) Exchange
Input [3]: [i_brand_id#104, i_class_id#105, i_category_id#106]
Arguments: hashpartitioning(coalesce(i_brand_id#104, 0), isnull(i_brand_id#104), coalesce(i_class_id#105, 0), isnull(i_class_id#105), coalesce(i_category_id#106, 0), isnull(i_category_id#106), 100), ENSURE_REQUIREMENTS, [plan_id=88]

(487) Sort
Input [3]: [i_brand_id#104, i_class_id#105, i_category_id#106]
Arguments: [coalesce(i_brand_id#104, 0) ASC NULLS FIRST, isnull(i_brand_id#104) ASC NULLS FIRST, coalesce(i_class_id#105, 0) ASC NULLS FIRST, isnull(i_class_id#105) ASC NULLS FIRST, coalesce(i_category_id#106, 0) ASC NULLS FIRST, isnull(i_category_id#106) ASC NULLS FIRST], false, 0

(488) 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#104, 0), isnull(i_brand_id#104), coalesce(i_class_id#105, 0), isnull(i_class_id#105), coalesce(i_category_id#106, 0), isnull(i_category_id#106)]
Join type: LeftSemi
Join condition: None

(489) 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=89]

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

(491) SortMergeJoin
Left keys [3]: [i_brand_id#82, i_class_id#83, i_category_id#84]
Right keys [3]: [brand_id#24, class_id#25, category_id#26]
Join type: Inner
Join condition: None

(492) Project
Output [1]: [i_item_sk#81 AS ss_item_sk#109]
Input [7]: [i_item_sk#81, i_brand_id#82, i_class_id#83, i_category_id#84, brand_id#24, class_id#25, category_id#26]

(493) Exchange
Input [1]: [ss_item_sk#109]
Arguments: hashpartitioning(ss_item_sk#109, 100), ENSURE_REQUIREMENTS, [plan_id=90]

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

(495) SortMergeJoin
Left keys [1]: [ss_item_sk#80]
Right keys [1]: [ss_item_sk#109]
Join type: LeftSemi
Join condition: None

(496) Scan parquet
Output [4]: [i_item_sk#110, i_brand_id#59, i_class_id#60, i_category_id#61]
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>

(497) Filter
Input [4]: [i_item_sk#110, i_brand_id#59, i_class_id#60, i_category_id#61]
Condition : (((isnotnull(i_item_sk#110) AND isnotnull(i_brand_id#59)) AND isnotnull(i_class_id#60)) AND isnotnull(i_category_id#61))

(498) Exchange
Input [4]: [i_item_sk#110, i_brand_id#59, i_class_id#60, i_category_id#61]
Arguments: hashpartitioning(i_item_sk#110, 100), ENSURE_REQUIREMENTS, [plan_id=91]

(499) Sort
Input [4]: [i_item_sk#110, i_brand_id#59, i_class_id#60, i_category_id#61]
Arguments: [i_item_sk#110 ASC NULLS FIRST], false, 0

(500) Scan parquet
Output [4]: [i_item_sk#81, i_brand_id#82, i_class_id#83, i_category_id#84]
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#81, i_brand_id#82, i_class_id#83, i_category_id#84]
Condition : ((isnotnull(i_brand_id#82) AND isnotnull(i_class_id#83)) AND isnotnull(i_category_id#84))

(502) Exchange
Input [4]: [i_item_sk#81, i_brand_id#82, i_class_id#83, i_category_id#84]
Arguments: hashpartitioning(i_brand_id#82, i_class_id#83, i_category_id#84, 100), ENSURE_REQUIREMENTS, [plan_id=92]

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

(504) Scan parquet
Output [2]: [ss_sold_date_sk#85, ss_item_sk#86]
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#85, ss_item_sk#86]
Condition : (isnotnull(ss_item_sk#86) AND isnotnull(ss_sold_date_sk#85))

(506) Exchange
Input [2]: [ss_sold_date_sk#85, ss_item_sk#86]
Arguments: hashpartitioning(ss_item_sk#86, 100), ENSURE_REQUIREMENTS, [plan_id=93]

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

(508) Scan parquet
Output [4]: [i_item_sk#87, i_brand_id#88, i_class_id#89, i_category_id#90]
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#87, i_brand_id#88, i_class_id#89, i_category_id#90]
Condition : (((isnotnull(i_item_sk#87) AND isnotnull(i_brand_id#88)) AND isnotnull(i_class_id#89)) AND isnotnull(i_category_id#90))

(510) Exchange
Input [4]: [i_item_sk#87, i_brand_id#88, i_class_id#89, i_category_id#90]
Arguments: hashpartitioning(coalesce(i_brand_id#88, 0), isnull(i_brand_id#88), coalesce(i_class_id#89, 0), isnull(i_class_id#89), coalesce(i_category_id#90, 0), isnull(i_category_id#90), 100), ENSURE_REQUIREMENTS, [plan_id=94]

(511) Sort
Input [4]: [i_item_sk#87, i_brand_id#88, i_class_id#89, i_category_id#90]
Arguments: [coalesce(i_brand_id#88, 0) ASC NULLS FIRST, isnull(i_brand_id#88) ASC NULLS FIRST, coalesce(i_class_id#89, 0) ASC NULLS FIRST, isnull(i_class_id#89) ASC NULLS FIRST, coalesce(i_category_id#90, 0) ASC NULLS FIRST, isnull(i_category_id#90) ASC NULLS FIRST], false, 0

(512) Scan parquet
Output [2]: [cs_sold_date_sk#91, cs_item_sk#92]
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#91, cs_item_sk#92]
Condition : (isnotnull(cs_item_sk#92) AND isnotnull(cs_sold_date_sk#91))

(514) Exchange
Input [2]: [cs_sold_date_sk#91, cs_item_sk#92]
Arguments: hashpartitioning(cs_item_sk#92, 100), ENSURE_REQUIREMENTS, [plan_id=95]

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

(516) Scan parquet
Output [4]: [i_item_sk#93, i_brand_id#94, i_class_id#95, i_category_id#96]
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#93, i_brand_id#94, i_class_id#95, i_category_id#96]
Condition : isnotnull(i_item_sk#93)

(518) Exchange
Input [4]: [i_item_sk#93, i_brand_id#94, i_class_id#95, i_category_id#96]
Arguments: hashpartitioning(i_item_sk#93, 100), ENSURE_REQUIREMENTS, [plan_id=96]

(519) Sort
Input [4]: [i_item_sk#93, i_brand_id#94, i_class_id#95, i_category_id#96]
Arguments: [i_item_sk#93 ASC NULLS FIRST], false, 0

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

(521) Project
Output [4]: [cs_sold_date_sk#91, i_brand_id#94, i_class_id#95, i_category_id#96]
Input [6]: [cs_sold_date_sk#91, cs_item_sk#92, i_item_sk#93, i_brand_id#94, i_class_id#95, i_category_id#96]

(522) Exchange
Input [4]: [cs_sold_date_sk#91, i_brand_id#94, i_class_id#95, i_category_id#96]
Arguments: hashpartitioning(cs_sold_date_sk#91, 100), ENSURE_REQUIREMENTS, [plan_id=97]

(523) Sort
Input [4]: [cs_sold_date_sk#91, i_brand_id#94, i_class_id#95, i_category_id#96]
Arguments: [cs_sold_date_sk#91 ASC NULLS FIRST], false, 0

(524) Scan parquet
Output [2]: [d_date_sk#97, d_year#98]
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#97, d_year#98]
Condition : (((isnotnull(d_year#98) AND (d_year#98 >= 1999)) AND (d_year#98 <= 2001)) AND isnotnull(d_date_sk#97))

(526) Project
Output [1]: [d_date_sk#97]
Input [2]: [d_date_sk#97, d_year#98]

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

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

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

(530) Project
Output [3]: [i_brand_id#94, i_class_id#95, i_category_id#96]
Input [5]: [cs_sold_date_sk#91, i_brand_id#94, i_class_id#95, i_category_id#96, d_date_sk#97]

(531) Exchange
Input [3]: [i_brand_id#94, i_class_id#95, i_category_id#96]
Arguments: hashpartitioning(coalesce(i_brand_id#94, 0), isnull(i_brand_id#94), coalesce(i_class_id#95, 0), isnull(i_class_id#95), coalesce(i_category_id#96, 0), isnull(i_category_id#96), 100), ENSURE_REQUIREMENTS, [plan_id=99]

(532) Sort
Input [3]: [i_brand_id#94, i_class_id#95, i_category_id#96]
Arguments: [coalesce(i_brand_id#94, 0) ASC NULLS FIRST, isnull(i_brand_id#94) ASC NULLS FIRST, coalesce(i_class_id#95, 0) ASC NULLS FIRST, isnull(i_class_id#95) ASC NULLS FIRST, coalesce(i_category_id#96, 0) ASC NULLS FIRST, isnull(i_category_id#96) ASC NULLS FIRST], false, 0

(533) SortMergeJoin
Left keys [6]: [coalesce(i_brand_id#88, 0), isnull(i_brand_id#88), coalesce(i_class_id#89, 0), isnull(i_class_id#89), coalesce(i_category_id#90, 0), isnull(i_category_id#90)]
Right keys [6]: [coalesce(i_brand_id#94, 0), isnull(i_brand_id#94), coalesce(i_class_id#95, 0), isnull(i_class_id#95), coalesce(i_category_id#96, 0), isnull(i_category_id#96)]
Join type: LeftSemi
Join condition: None

(534) Exchange
Input [4]: [i_item_sk#87, i_brand_id#88, i_class_id#89, i_category_id#90]
Arguments: hashpartitioning(i_item_sk#87, 100), ENSURE_REQUIREMENTS, [plan_id=100]

(535) Sort
Input [4]: [i_item_sk#87, i_brand_id#88, i_class_id#89, i_category_id#90]
Arguments: [i_item_sk#87 ASC NULLS FIRST], false, 0

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

(537) Project
Output [4]: [ss_sold_date_sk#85, i_brand_id#88, i_class_id#89, i_category_id#90]
Input [6]: [ss_sold_date_sk#85, ss_item_sk#86, i_item_sk#87, i_brand_id#88, i_class_id#89, i_category_id#90]

(538) Exchange
Input [4]: [ss_sold_date_sk#85, i_brand_id#88, i_class_id#89, i_category_id#90]
Arguments: hashpartitioning(ss_sold_date_sk#85, 100), ENSURE_REQUIREMENTS, [plan_id=101]

(539) Sort
Input [4]: [ss_sold_date_sk#85, i_brand_id#88, i_class_id#89, i_category_id#90]
Arguments: [ss_sold_date_sk#85 ASC NULLS FIRST], false, 0

(540) Scan parquet
Output [2]: [d_date_sk#99, d_year#100]
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#99, d_year#100]
Condition : (((isnotnull(d_year#100) AND (d_year#100 >= 1999)) AND (d_year#100 <= 2001)) AND isnotnull(d_date_sk#99))

(542) Project
Output [1]: [d_date_sk#99]
Input [2]: [d_date_sk#99, d_year#100]

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

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

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

(546) Project
Output [3]: [i_brand_id#88 AS brand_id#24, i_class_id#89 AS class_id#25, i_category_id#90 AS category_id#26]
Input [5]: [ss_sold_date_sk#85, i_brand_id#88, i_class_id#89, i_category_id#90, d_date_sk#99]

(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=103]

(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=104]

(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#101, ws_item_sk#102]
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#101, ws_item_sk#102]
Condition : (isnotnull(ws_item_sk#102) AND isnotnull(ws_sold_date_sk#101))

(554) Exchange
Input [2]: [ws_sold_date_sk#101, ws_item_sk#102]
Arguments: hashpartitioning(ws_item_sk#102, 100), ENSURE_REQUIREMENTS, [plan_id=105]

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

(556) Scan parquet
Output [4]: [i_item_sk#103, i_brand_id#104, i_class_id#105, i_category_id#106]
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#103, i_brand_id#104, i_class_id#105, i_category_id#106]
Condition : isnotnull(i_item_sk#103)

(558) Exchange
Input [4]: [i_item_sk#103, i_brand_id#104, i_class_id#105, i_category_id#106]
Arguments: hashpartitioning(i_item_sk#103, 100), ENSURE_REQUIREMENTS, [plan_id=106]

(559) Sort
Input [4]: [i_item_sk#103, i_brand_id#104, i_class_id#105, i_category_id#106]
Arguments: [i_item_sk#103 ASC NULLS FIRST], false, 0

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

(561) Project
Output [4]: [ws_sold_date_sk#101, i_brand_id#104, i_class_id#105, i_category_id#106]
Input [6]: [ws_sold_date_sk#101, ws_item_sk#102, i_item_sk#103, i_brand_id#104, i_class_id#105, i_category_id#106]

(562) Exchange
Input [4]: [ws_sold_date_sk#101, i_brand_id#104, i_class_id#105, i_category_id#106]
Arguments: hashpartitioning(ws_sold_date_sk#101, 100), ENSURE_REQUIREMENTS, [plan_id=107]

(563) Sort
Input [4]: [ws_sold_date_sk#101, i_brand_id#104, i_class_id#105, i_category_id#106]
Arguments: [ws_sold_date_sk#101 ASC NULLS FIRST], false, 0

(564) Scan parquet
Output [2]: [d_date_sk#107, d_year#108]
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#107, d_year#108]
Condition : (((isnotnull(d_year#108) AND (d_year#108 >= 1999)) AND (d_year#108 <= 2001)) AND isnotnull(d_date_sk#107))

(566) Project
Output [1]: [d_date_sk#107]
Input [2]: [d_date_sk#107, d_year#108]

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

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

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

(570) Project
Output [3]: [i_brand_id#104, i_class_id#105, i_category_id#106]
Input [5]: [ws_sold_date_sk#101, i_brand_id#104, i_class_id#105, i_category_id#106, d_date_sk#107]

(571) Exchange
Input [3]: [i_brand_id#104, i_class_id#105, i_category_id#106]
Arguments: hashpartitioning(coalesce(i_brand_id#104, 0), isnull(i_brand_id#104), coalesce(i_class_id#105, 0), isnull(i_class_id#105), coalesce(i_category_id#106, 0), isnull(i_category_id#106), 100), ENSURE_REQUIREMENTS, [plan_id=109]

(572) Sort
Input [3]: [i_brand_id#104, i_class_id#105, i_category_id#106]
Arguments: [coalesce(i_brand_id#104, 0) ASC NULLS FIRST, isnull(i_brand_id#104) ASC NULLS FIRST, coalesce(i_class_id#105, 0) ASC NULLS FIRST, isnull(i_class_id#105) ASC NULLS FIRST, coalesce(i_category_id#106, 0) ASC NULLS FIRST, isnull(i_category_id#106) 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#104, 0), isnull(i_brand_id#104), coalesce(i_class_id#105, 0), isnull(i_class_id#105), coalesce(i_category_id#106, 0), isnull(i_category_id#106)]
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=110]

(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#82, i_class_id#83, i_category_id#84]
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#81 AS ss_item_sk#109]
Input [7]: [i_item_sk#81, i_brand_id#82, i_class_id#83, i_category_id#84, brand_id#24, class_id#25, category_id#26]

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

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

(580) SortMergeJoin
Left keys [1]: [i_item_sk#110]
Right keys [1]: [ss_item_sk#109]
Join type: LeftSemi
Join condition: None

(581) SortMergeJoin
Left keys [1]: [ss_item_sk#80]
Right keys [1]: [i_item_sk#110]
Join type: Inner
Join condition: None

(582) Project
Output [6]: [ss_sold_date_sk#56, ss_quantity#57, ss_list_price#58, i_brand_id#59, i_class_id#60, i_category_id#61]
Input [8]: [ss_sold_date_sk#56, ss_item_sk#80, ss_quantity#57, ss_list_price#58, i_item_sk#110, i_brand_id#59, i_class_id#60, i_category_id#61]

(583) Exchange
Input [6]: [ss_sold_date_sk#56, ss_quantity#57, ss_list_price#58, i_brand_id#59, i_class_id#60, i_category_id#61]
Arguments: hashpartitioning(ss_sold_date_sk#56, 100), ENSURE_REQUIREMENTS, [plan_id=112]

(584) Sort
Input [6]: [ss_sold_date_sk#56, ss_quantity#57, ss_list_price#58, i_brand_id#59, i_class_id#60, i_category_id#61]
Arguments: [ss_sold_date_sk#56 ASC NULLS FIRST], false, 0

(585) Scan parquet
Output [2]: [d_date_sk#62, d_week_seq#63]
Batched: true
Location: InMemoryFileIndex [file:/<warehouse_dir>]
PushedFilters: [IsNotNull(d_week_seq), IsNotNull(d_date_sk)]
ReadSchema: struct<d_date_sk:int,d_week_seq:int>

(586) Filter
Input [2]: [d_date_sk#62, d_week_seq#63]
Condition : ((isnotnull(d_week_seq#63) AND (d_week_seq#63 = Subquery subquery#64, [id=#65])) AND isnotnull(d_date_sk#62))

(587) Project
Output [1]: [d_date_sk#62]
Input [2]: [d_date_sk#62, d_week_seq#63]

(588) Exchange
Input [1]: [d_date_sk#62]
Arguments: hashpartitioning(d_date_sk#62, 100), ENSURE_REQUIREMENTS, [plan_id=113]

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

(590) SortMergeJoin
Left keys [1]: [ss_sold_date_sk#56]
Right keys [1]: [d_date_sk#62]
Join type: Inner
Join condition: None

(591) Project
Output [5]: [ss_quantity#57, ss_list_price#58, i_brand_id#59, i_class_id#60, i_category_id#61]
Input [7]: [ss_sold_date_sk#56, ss_quantity#57, ss_list_price#58, i_brand_id#59, i_class_id#60, i_category_id#61, d_date_sk#62]

(592) HashAggregate
Input [5]: [ss_quantity#57, ss_list_price#58, i_brand_id#59, i_class_id#60, i_category_id#61]
Keys [3]: [i_brand_id#59, i_class_id#60, i_category_id#61]
Functions [2]: [partial_sum((cast(ss_quantity#57 as decimal(10,0)) * ss_list_price#58)), partial_count(1)]
Aggregate Attributes [3]: [sum#67, isEmpty#68, count#69]
Results [6]: [i_brand_id#59, i_class_id#60, i_category_id#61, sum#111, isEmpty#112, count#113]

(593) Exchange
Input [6]: [i_brand_id#59, i_class_id#60, i_category_id#61, sum#111, isEmpty#112, count#113]
Arguments: hashpartitioning(i_brand_id#59, i_class_id#60, i_category_id#61, 100), ENSURE_REQUIREMENTS, [plan_id=114]

(594) HashAggregate
Input [6]: [i_brand_id#59, i_class_id#60, i_category_id#61, sum#111, isEmpty#112, count#113]
Keys [3]: [i_brand_id#59, i_class_id#60, i_category_id#61]
Functions [2]: [sum((cast(ss_quantity#57 as decimal(10,0)) * ss_list_price#58)), count(1)]
Aggregate Attributes [2]: [sum((cast(ss_quantity#57 as decimal(10,0)) * ss_list_price#58))#70, count(1)#71]
Results [6]: [store AS channel#72, i_brand_id#59, i_class_id#60, i_category_id#61, sum((cast(ss_quantity#57 as decimal(10,0)) * ss_list_price#58))#70 AS sales#73, count(1)#71 AS number_sales#74]

(595) Filter
Input [6]: [channel#72, i_brand_id#59, i_class_id#60, i_category_id#61, sales#73, number_sales#74]
Condition : (isnotnull(sales#73) AND (cast(sales#73 as decimal(32,6)) > cast(Subquery subquery#114, [id=#115] as decimal(32,6))))

(596) Sort
Input [6]: [channel#72, i_brand_id#59, i_class_id#60, i_category_id#61, sales#73, number_sales#74]
Arguments: [i_brand_id#59 ASC NULLS FIRST, i_class_id#60 ASC NULLS FIRST, i_category_id#61 ASC NULLS FIRST], false, 0

(597) SortMergeJoin
Left keys [3]: [i_brand_id#36, i_class_id#37, i_category_id#38]
Right keys [3]: [i_brand_id#59, i_class_id#60, i_category_id#61]
Join type: Inner
Join condition: None

(598) TakeOrderedAndProject
Input [12]: [channel#51, i_brand_id#36, i_class_id#37, i_category_id#38, sales#52, number_sales#53, channel#72, i_brand_id#59, i_class_id#60, i_category_id#61, sales#73, number_sales#74]
Arguments: X, [i_brand_id#36 ASC NULLS FIRST, i_class_id#37 ASC NULLS FIRST, i_category_id#38 ASC NULLS FIRST], [channel#51, i_brand_id#36, i_class_id#37, i_category_id#38, sales#52, number_sales#53, channel#72, i_brand_id#59, i_class_id#60, i_category_id#61, sales#73, number_sales#74]

(599) AdaptiveSparkPlan
Output [12]: [channel#51, i_brand_id#36, i_class_id#37, i_category_id#38, sales#52, number_sales#53, channel#72, i_brand_id#59, i_class_id#60, i_category_id#61, sales#73, number_sales#74]
Arguments: isFinalPlan=true

===== Subqueries =====

Subquery:1 Hosting operator id = 193 Hosting Expression = Subquery subquery#54, [id=#55]
AdaptiveSparkPlan (693)
+- == Final Plan ==
   NativeProject (655)
   +- NativeHashAggregate (654)
      +- ShuffleQueryStage (653), Statistics(X)
         +- NativeShuffleExchange (652)
            +- NativeHashAggregate (651)
               +- NativeProject (650)
                  +- InputAdapter (649)
                     +- NativeUnion (648)
                        :- NativeProject (615)
                        :  +- NativeSortMergeJoin Inner (614)
                        :     :- NativeSort (607)
                        :     :  +- InputAdapter (606)
                        :     :     +- AQEShuffleRead (605)
                        :     :        +- ShuffleQueryStage (604), Statistics(X)
                        :     :           +- NativeShuffleExchange (603)
                        :     :              +- NativeFilter (602)
                        :     :                 +- InputAdapter (601)
                        :     :                    +- NativeParquetScan  (600)
                        :     +- NativeSort (613)
                        :        +- InputAdapter (612)
                        :           +- InputAdapter (611)
                        :              +- AQEShuffleRead (610)
                        :                 +- ShuffleQueryStage (609), Statistics(X)
                        :                    +- ReusedExchange (608)
                        :- NativeProject (631)
                        :  +- NativeSortMergeJoin Inner (630)
                        :     :- NativeSort (623)
                        :     :  +- InputAdapter (622)
                        :     :     +- AQEShuffleRead (621)
                        :     :        +- ShuffleQueryStage (620), Statistics(X)
                        :     :           +- NativeShuffleExchange (619)
                        :     :              +- NativeFilter (618)
                        :     :                 +- InputAdapter (617)
                        :     :                    +- NativeParquetScan  (616)
                        :     +- NativeSort (629)
                        :        +- InputAdapter (628)
                        :           +- InputAdapter (627)
                        :              +- AQEShuffleRead (626)
                        :                 +- ShuffleQueryStage (625), Statistics(X)
                        :                    +- ReusedExchange (624)
                        +- NativeProject (647)
                           +- NativeSortMergeJoin Inner (646)
                              :- NativeSort (639)
                              :  +- InputAdapter (638)
                              :     +- AQEShuffleRead (637)
                              :        +- ShuffleQueryStage (636), Statistics(X)
                              :           +- NativeShuffleExchange (635)
                              :              +- NativeFilter (634)
                              :                 +- InputAdapter (633)
                              :                    +- NativeParquetScan  (632)
                              +- NativeSort (645)
                                 +- InputAdapter (644)
                                    +- InputAdapter (643)
                                       +- AQEShuffleRead (642)
                                          +- ShuffleQueryStage (641), Statistics(X)
                                             +- ReusedExchange (640)
+- == Initial Plan ==
   HashAggregate (692)
   +- Exchange (691)
      +- HashAggregate (690)
         +- Union (689)
            :- Project (666)
            :  +- SortMergeJoin Inner (665)
            :     :- Sort (659)
            :     :  +- Exchange (658)
            :     :     +- Filter (657)
            :     :        +- Scan parquet (656)
            :     +- Sort (664)
            :        +- Exchange (663)
            :           +- Project (662)
            :              +- Filter (661)
            :                 +- Scan parquet (660)
            :- Project (677)
            :  +- SortMergeJoin Inner (676)
            :     :- Sort (670)
            :     :  +- Exchange (669)
            :     :     +- Filter (668)
            :     :        +- Scan parquet (667)
            :     +- Sort (675)
            :        +- Exchange (674)
            :           +- Project (673)
            :              +- Filter (672)
            :                 +- Scan parquet (671)
            +- Project (688)
               +- SortMergeJoin Inner (687)
                  :- Sort (681)
                  :  +- Exchange (680)
                  :     +- Filter (679)
                  :        +- Scan parquet (678)
                  +- Sort (686)
                     +- Exchange (685)
                        +- Project (684)
                           +- Filter (683)
                              +- Scan parquet (682)


(656) Scan parquet
Output [3]: [ss_sold_date_sk#116, ss_quantity#117, ss_list_price#118]
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)>

(601) InputAdapter
Input [3]: [ss_sold_date_sk#116, ss_quantity#117, ss_list_price#118]
Arguments: [#116, #117, #118]

(602) NativeFilter
Input [3]: [#116#116, #117#117, #118#118]
Condition : isnotnull(ss_sold_date_sk#116)

(603) NativeShuffleExchange
Input [3]: [#116#116, #117#117, #118#118]
Arguments: hashpartitioning(ss_sold_date_sk#116, 100), ENSURE_REQUIREMENTS, [plan_id=115]

(604) ShuffleQueryStage
Output [3]: [#116#116, #117#117, #118#118]
Arguments: X

(605) AQEShuffleRead
Input [3]: [#116#116, #117#117, #118#118]
Arguments: coalesced

(606) InputAdapter
Input [3]: [#116#116, #117#117, #118#118]

(607) NativeSort
Input [3]: [#116#116, #117#117, #118#118]
Arguments: [ss_sold_date_sk#116 ASC NULLS FIRST], false

(608) ReusedExchange [Reuses operator id: 60]
Output [1]: [d_date_sk#119]

(609) ShuffleQueryStage
Output [1]: [d_date_sk#119]
Arguments: X

(610) AQEShuffleRead
Input [1]: [d_date_sk#119]
Arguments: coalesced

(611) InputAdapter
Input [1]: [d_date_sk#119]
Arguments: [#119]

(612) InputAdapter
Input [1]: [#119#119]

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

(614) NativeSortMergeJoin
Left keys [1]: [ss_sold_date_sk#116]
Right keys [1]: [d_date_sk#119]
Join type: Inner
Join condition: None

(615) NativeProject
Output [2]: [ss_quantity#117 AS quantity#120, ss_list_price#118 AS list_price#121]
Input [4]: [#116#116, #117#117, #118#118, #119#119]

(667) Scan parquet
Output [3]: [cs_sold_date_sk#122, cs_quantity#123, cs_list_price#124]
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)>

(617) InputAdapter
Input [3]: [cs_sold_date_sk#122, cs_quantity#123, cs_list_price#124]
Arguments: [#122, #123, #124]

(618) NativeFilter
Input [3]: [#122#122, #123#123, #124#124]
Condition : isnotnull(cs_sold_date_sk#122)

(619) NativeShuffleExchange
Input [3]: [#122#122, #123#123, #124#124]
Arguments: hashpartitioning(cs_sold_date_sk#122, 100), ENSURE_REQUIREMENTS, [plan_id=116]

(620) ShuffleQueryStage
Output [3]: [#122#122, #123#123, #124#124]
Arguments: X

(621) AQEShuffleRead
Input [3]: [#122#122, #123#123, #124#124]
Arguments: coalesced

(622) InputAdapter
Input [3]: [#122#122, #123#123, #124#124]

(623) NativeSort
Input [3]: [#122#122, #123#123, #124#124]
Arguments: [cs_sold_date_sk#122 ASC NULLS FIRST], false

(624) ReusedExchange [Reuses operator id: 60]
Output [1]: [d_date_sk#125]

(625) ShuffleQueryStage
Output [1]: [d_date_sk#125]
Arguments: X

(626) AQEShuffleRead
Input [1]: [d_date_sk#125]
Arguments: coalesced

(627) InputAdapter
Input [1]: [d_date_sk#125]
Arguments: [#125]

(628) InputAdapter
Input [1]: [#125#125]

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

(630) NativeSortMergeJoin
Left keys [1]: [cs_sold_date_sk#122]
Right keys [1]: [d_date_sk#125]
Join type: Inner
Join condition: None

(631) NativeProject
Output [2]: [cs_quantity#123 AS quantity#126, cs_list_price#124 AS list_price#127]
Input [4]: [#122#122, #123#123, #124#124, #125#125]

(678) Scan parquet
Output [3]: [ws_sold_date_sk#128, ws_quantity#129, ws_list_price#130]
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)>

(633) InputAdapter
Input [3]: [ws_sold_date_sk#128, ws_quantity#129, ws_list_price#130]
Arguments: [#128, #129, #130]

(634) NativeFilter
Input [3]: [#128#128, #129#129, #130#130]
Condition : isnotnull(ws_sold_date_sk#128)

(635) NativeShuffleExchange
Input [3]: [#128#128, #129#129, #130#130]
Arguments: hashpartitioning(ws_sold_date_sk#128, 100), ENSURE_REQUIREMENTS, [plan_id=117]

(636) ShuffleQueryStage
Output [3]: [#128#128, #129#129, #130#130]
Arguments: X

(637) AQEShuffleRead
Input [3]: [#128#128, #129#129, #130#130]
Arguments: coalesced

(638) InputAdapter
Input [3]: [#128#128, #129#129, #130#130]

(639) NativeSort
Input [3]: [#128#128, #129#129, #130#130]
Arguments: [ws_sold_date_sk#128 ASC NULLS FIRST], false

(640) ReusedExchange [Reuses operator id: 60]
Output [1]: [d_date_sk#131]

(641) ShuffleQueryStage
Output [1]: [d_date_sk#131]
Arguments: X

(642) AQEShuffleRead
Input [1]: [d_date_sk#131]
Arguments: coalesced

(643) InputAdapter
Input [1]: [d_date_sk#131]
Arguments: [#131]

(644) InputAdapter
Input [1]: [#131#131]

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

(646) NativeSortMergeJoin
Left keys [1]: [ws_sold_date_sk#128]
Right keys [1]: [d_date_sk#131]
Join type: Inner
Join condition: None

(647) NativeProject
Output [2]: [ws_quantity#129 AS quantity#132, ws_list_price#130 AS list_price#133]
Input [4]: [#128#128, #129#129, #130#130, #131#131]

(648) NativeUnion
Arguments: [quantity#120, list_price#121]

(649) InputAdapter
Input [2]: [quantity#120, list_price#121]
Arguments: [#120, #121]

(650) NativeProject
Output [1]: [(cast(quantity#120 as decimal(10,0)) * list_price#121) AS _c0#134]
Input [2]: [#120#120, #121#121]

(651) NativeHashAggregate
Input [1]: [_c0#134]
Keys: []
Functions [1]: [partial_avg(_c0#134)]
Aggregate Attributes [2]: [sum#135, count#136]
Results [2]: [#47, #48]

(652) NativeShuffleExchange
Input [2]: [#47, #48]
Arguments: SinglePartition, ENSURE_REQUIREMENTS, [plan_id=118]

(653) ShuffleQueryStage
Output [2]: [#47, #48]
Arguments: X

(654) NativeHashAggregate
Input [2]: [#47, #48]
Keys: []
Functions [1]: [avg((cast(quantity#120 as decimal(10,0)) * list_price#121))]
Aggregate Attributes [1]: [avg((cast(quantity#120 as decimal(10,0)) * list_price#121))#137]
Results [1]: [avg((cast(quantity#120 as decimal(10,0)) * list_price#121))#137]

(655) NativeProject
Output [1]: [avg((cast(quantity#120 as decimal(10,0)) * list_price#121))#137 AS average_sales#138]
Input [1]: [avg((cast(quantity#120 as decimal(10,0)) * list_price#121))#137]

(656) Scan parquet
Output [3]: [ss_sold_date_sk#116, ss_quantity#117, ss_list_price#118]
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)>

(657) Filter
Input [3]: [ss_sold_date_sk#116, ss_quantity#117, ss_list_price#118]
Condition : isnotnull(ss_sold_date_sk#116)

(658) Exchange
Input [3]: [ss_sold_date_sk#116, ss_quantity#117, ss_list_price#118]
Arguments: hashpartitioning(ss_sold_date_sk#116, 100), ENSURE_REQUIREMENTS, [plan_id=119]

(659) Sort
Input [3]: [ss_sold_date_sk#116, ss_quantity#117, ss_list_price#118]
Arguments: [ss_sold_date_sk#116 ASC NULLS FIRST], false, 0

(660) Scan parquet
Output [2]: [d_date_sk#119, d_year#139]
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>

(661) Filter
Input [2]: [d_date_sk#119, d_year#139]
Condition : (((isnotnull(d_year#139) AND (d_year#139 >= 1999)) AND (d_year#139 <= 2001)) AND isnotnull(d_date_sk#119))

(662) Project
Output [1]: [d_date_sk#119]
Input [2]: [d_date_sk#119, d_year#139]

(663) Exchange
Input [1]: [d_date_sk#119]
Arguments: hashpartitioning(d_date_sk#119, 100), ENSURE_REQUIREMENTS, [plan_id=120]

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

(665) SortMergeJoin
Left keys [1]: [ss_sold_date_sk#116]
Right keys [1]: [d_date_sk#119]
Join type: Inner
Join condition: None

(666) Project
Output [2]: [ss_quantity#117 AS quantity#120, ss_list_price#118 AS list_price#121]
Input [4]: [ss_sold_date_sk#116, ss_quantity#117, ss_list_price#118, d_date_sk#119]

(667) Scan parquet
Output [3]: [cs_sold_date_sk#122, cs_quantity#123, cs_list_price#124]
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)>

(668) Filter
Input [3]: [cs_sold_date_sk#122, cs_quantity#123, cs_list_price#124]
Condition : isnotnull(cs_sold_date_sk#122)

(669) Exchange
Input [3]: [cs_sold_date_sk#122, cs_quantity#123, cs_list_price#124]
Arguments: hashpartitioning(cs_sold_date_sk#122, 100), ENSURE_REQUIREMENTS, [plan_id=121]

(670) Sort
Input [3]: [cs_sold_date_sk#122, cs_quantity#123, cs_list_price#124]
Arguments: [cs_sold_date_sk#122 ASC NULLS FIRST], false, 0

(671) Scan parquet
Output [2]: [d_date_sk#125, d_year#140]
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>

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

(673) Project
Output [1]: [d_date_sk#125]
Input [2]: [d_date_sk#125, d_year#140]

(674) Exchange
Input [1]: [d_date_sk#125]
Arguments: hashpartitioning(d_date_sk#125, 100), ENSURE_REQUIREMENTS, [plan_id=122]

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

(676) SortMergeJoin
Left keys [1]: [cs_sold_date_sk#122]
Right keys [1]: [d_date_sk#125]
Join type: Inner
Join condition: None

(677) Project
Output [2]: [cs_quantity#123 AS quantity#126, cs_list_price#124 AS list_price#127]
Input [4]: [cs_sold_date_sk#122, cs_quantity#123, cs_list_price#124, d_date_sk#125]

(678) Scan parquet
Output [3]: [ws_sold_date_sk#128, ws_quantity#129, ws_list_price#130]
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)>

(679) Filter
Input [3]: [ws_sold_date_sk#128, ws_quantity#129, ws_list_price#130]
Condition : isnotnull(ws_sold_date_sk#128)

(680) Exchange
Input [3]: [ws_sold_date_sk#128, ws_quantity#129, ws_list_price#130]
Arguments: hashpartitioning(ws_sold_date_sk#128, 100), ENSURE_REQUIREMENTS, [plan_id=123]

(681) Sort
Input [3]: [ws_sold_date_sk#128, ws_quantity#129, ws_list_price#130]
Arguments: [ws_sold_date_sk#128 ASC NULLS FIRST], false, 0

(682) Scan parquet
Output [2]: [d_date_sk#131, 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>

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

(684) Project
Output [1]: [d_date_sk#131]
Input [2]: [d_date_sk#131, d_year#141]

(685) Exchange
Input [1]: [d_date_sk#131]
Arguments: hashpartitioning(d_date_sk#131, 100), ENSURE_REQUIREMENTS, [plan_id=124]

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

(687) SortMergeJoin
Left keys [1]: [ws_sold_date_sk#128]
Right keys [1]: [d_date_sk#131]
Join type: Inner
Join condition: None

(688) Project
Output [2]: [ws_quantity#129 AS quantity#132, ws_list_price#130 AS list_price#133]
Input [4]: [ws_sold_date_sk#128, ws_quantity#129, ws_list_price#130, d_date_sk#131]

(689) Union

(690) HashAggregate
Input [2]: [quantity#120, list_price#121]
Keys: []
Functions [1]: [partial_avg((cast(quantity#120 as decimal(10,0)) * list_price#121))]
Aggregate Attributes [2]: [sum#135, count#136]
Results [2]: [sum#142, count#143]

(691) Exchange
Input [2]: [sum#142, count#143]
Arguments: SinglePartition, ENSURE_REQUIREMENTS, [plan_id=125]

(692) HashAggregate
Input [2]: [sum#142, count#143]
Keys: []
Functions [1]: [avg((cast(quantity#120 as decimal(10,0)) * list_price#121))]
Aggregate Attributes [1]: [avg((cast(quantity#120 as decimal(10,0)) * list_price#121))#137]
Results [1]: [avg((cast(quantity#120 as decimal(10,0)) * list_price#121))#137 AS average_sales#138]

(693) AdaptiveSparkPlan
Output [1]: [average_sales#138]
Arguments: isFinalPlan=true

Subquery:2 Hosting operator id = 176 Hosting Expression = Subquery subquery#41, [id=#42]
AdaptiveSparkPlan (701)
+- == Final Plan ==
   NativeProject (697)
   +- NativeFilter (696)
      +- InputAdapter (695)
         +- NativeParquetScan  (694)
+- == Initial Plan ==
   Project (700)
   +- Filter (699)
      +- Scan parquet (698)


(698) Scan parquet
Output [4]: [d_week_seq#144, d_year#145, d_moy#146, d_dom#147]
Batched: true
Location: InMemoryFileIndex [file:/<warehouse_dir>]
PushedFilters: [IsNotNull(d_year), IsNotNull(d_moy), IsNotNull(d_dom), EqualTo(d_year,2000), EqualTo(d_moy,12), EqualTo(d_dom,11)]
ReadSchema: struct<d_week_seq:int,d_year:int,d_moy:int,d_dom:int>

(695) InputAdapter
Input [4]: [d_week_seq#144, d_year#145, d_moy#146, d_dom#147]
Arguments: [#144, #145, #146, #147]

(696) NativeFilter
Input [4]: [#144#144, #145#145, #146#146, #147#147]
Condition : (((((isnotnull(d_year#145) AND isnotnull(d_moy#146)) AND isnotnull(d_dom#147)) AND (d_year#145 = 2000)) AND (d_moy#146 = 12)) AND (d_dom#147 = 11))

(697) NativeProject
Output [1]: [d_week_seq#144]
Input [4]: [#144#144, #145#145, #146#146, #147#147]

(698) Scan parquet
Output [4]: [d_week_seq#144, d_year#145, d_moy#146, d_dom#147]
Batched: true
Location: InMemoryFileIndex [file:/<warehouse_dir>]
PushedFilters: [IsNotNull(d_year), IsNotNull(d_moy), IsNotNull(d_dom), EqualTo(d_year,2000), EqualTo(d_moy,12), EqualTo(d_dom,11)]
ReadSchema: struct<d_week_seq:int,d_year:int,d_moy:int,d_dom:int>

(699) Filter
Input [4]: [d_week_seq#144, d_year#145, d_moy#146, d_dom#147]
Condition : (((((isnotnull(d_year#145) AND isnotnull(d_moy#146)) AND isnotnull(d_dom#147)) AND (d_year#145 = 2000)) AND (d_moy#146 = 12)) AND (d_dom#147 = 11))

(700) Project
Output [1]: [d_week_seq#144]
Input [4]: [d_week_seq#144, d_year#145, d_moy#146, d_dom#147]

(701) AdaptiveSparkPlan
Output [1]: [d_week_seq#144]
Arguments: isFinalPlan=true

Subquery:3 Hosting operator id = 220 Hosting Expression = ReusedSubquery Subquery subquery#54, [id=#55]

Subquery:4 Hosting operator id = 203 Hosting Expression = Subquery subquery#64, [id=#65]
AdaptiveSparkPlan (709)
+- == Final Plan ==
   NativeProject (705)
   +- NativeFilter (704)
      +- InputAdapter (703)
         +- NativeParquetScan  (702)
+- == Initial Plan ==
   Project (708)
   +- Filter (707)
      +- Scan parquet (706)


(706) Scan parquet
Output [4]: [d_week_seq#148, d_year#149, d_moy#150, d_dom#151]
Batched: true
Location: InMemoryFileIndex [file:/<warehouse_dir>]
PushedFilters: [IsNotNull(d_year), IsNotNull(d_moy), IsNotNull(d_dom), EqualTo(d_year,1999), EqualTo(d_moy,12), EqualTo(d_dom,11)]
ReadSchema: struct<d_week_seq:int,d_year:int,d_moy:int,d_dom:int>

(703) InputAdapter
Input [4]: [d_week_seq#148, d_year#149, d_moy#150, d_dom#151]
Arguments: [#148, #149, #150, #151]

(704) NativeFilter
Input [4]: [#148#148, #149#149, #150#150, #151#151]
Condition : (((((isnotnull(d_year#149) AND isnotnull(d_moy#150)) AND isnotnull(d_dom#151)) AND (d_year#149 = 1999)) AND (d_moy#150 = 12)) AND (d_dom#151 = 11))

(705) NativeProject
Output [1]: [d_week_seq#148]
Input [4]: [#148#148, #149#149, #150#150, #151#151]

(706) Scan parquet
Output [4]: [d_week_seq#148, d_year#149, d_moy#150, d_dom#151]
Batched: true
Location: InMemoryFileIndex [file:/<warehouse_dir>]
PushedFilters: [IsNotNull(d_year), IsNotNull(d_moy), IsNotNull(d_dom), EqualTo(d_year,1999), EqualTo(d_moy,12), EqualTo(d_dom,11)]
ReadSchema: struct<d_week_seq:int,d_year:int,d_moy:int,d_dom:int>

(707) Filter
Input [4]: [d_week_seq#148, d_year#149, d_moy#150, d_dom#151]
Condition : (((((isnotnull(d_year#149) AND isnotnull(d_moy#150)) AND isnotnull(d_dom#151)) AND (d_year#149 = 1999)) AND (d_moy#150 = 12)) AND (d_dom#151 = 11))

(708) Project
Output [1]: [d_week_seq#148]
Input [4]: [d_week_seq#148, d_year#149, d_moy#150, d_dom#151]

(709) AdaptiveSparkPlan
Output [1]: [d_week_seq#148]
Arguments: isFinalPlan=true


