== Physical Plan ==
AdaptiveSparkPlan (155)
+- == Final Plan ==
   VeloxColumnarToRowExec (106)
   +- ^ SortExecTransformer (104)
      +- ^ InputIteratorTransformer (103)
         +- ShuffleQueryStage (101)
            +- ColumnarExchange (100)
               +- VeloxAppendBatches (99)
                  +- ^ RegularHashAggregateExecTransformer (97)
                     +- ^ InputIteratorTransformer (96)
                        +- ShuffleQueryStage (94)
                           +- ColumnarExchange (93)
                              +- VeloxAppendBatches (92)
                                 +- ^ ProjectExecTransformer (90)
                                    +- ^ FlushableHashAggregateExecTransformer (89)
                                       +- ^ ProjectExecTransformer (88)
                                          +- ^ ShuffledHashJoinExecTransformer Inner BuildRight (87)
                                             :- ^ InputIteratorTransformer (77)
                                             :  +- ShuffleQueryStage (75)
                                             :     +- ColumnarExchange (74)
                                             :        +- VeloxAppendBatches (73)
                                             :           +- ^ ProjectExecTransformer (71)
                                             :              +- ^ ShuffledHashJoinExecTransformer Inner BuildLeft (70)
                                             :                 :- ^ InputIteratorTransformer (60)
                                             :                 :  +- ShuffleQueryStage (58)
                                             :                 :     +- ColumnarExchange (57)
                                             :                 :        +- VeloxAppendBatches (56)
                                             :                 :           +- ^ ProjectExecTransformer (54)
                                             :                 :              +- ^ ShuffledHashJoinExecTransformer Inner BuildLeft (53)
                                             :                 :                 :- ^ InputIteratorTransformer (43)
                                             :                 :                 :  +- ShuffleQueryStage (41)
                                             :                 :                 :     +- ColumnarExchange (40)
                                             :                 :                 :        +- VeloxAppendBatches (39)
                                             :                 :                 :           +- ^ ProjectExecTransformer (37)
                                             :                 :                 :              +- ^ ShuffledHashJoinExecTransformer Inner BuildRight (36)
                                             :                 :                 :                 :- ^ InputIteratorTransformer (26)
                                             :                 :                 :                 :  +- ShuffleQueryStage (24)
                                             :                 :                 :                 :     +- ColumnarExchange (23)
                                             :                 :                 :                 :        +- VeloxAppendBatches (22)
                                             :                 :                 :                 :           +- ^ ProjectExecTransformer (20)
                                             :                 :                 :                 :              +- ^ ShuffledHashJoinExecTransformer Inner BuildLeft (19)
                                             :                 :                 :                 :                 :- ^ InputIteratorTransformer (9)
                                             :                 :                 :                 :                 :  +- ShuffleQueryStage (7)
                                             :                 :                 :                 :                 :     +- ColumnarExchange (6)
                                             :                 :                 :                 :                 :        +- VeloxAppendBatches (5)
                                             :                 :                 :                 :                 :           +- ^ ProjectExecTransformer (3)
                                             :                 :                 :                 :                 :              +- ^ FilterExecTransformer (2)
                                             :                 :                 :                 :                 :                 +- ^ Scan parquet (1)
                                             :                 :                 :                 :                 +- ^ InputIteratorTransformer (18)
                                             :                 :                 :                 :                    +- ShuffleQueryStage (16)
                                             :                 :                 :                 :                       +- ColumnarExchange (15)
                                             :                 :                 :                 :                          +- VeloxAppendBatches (14)
                                             :                 :                 :                 :                             +- ^ ProjectExecTransformer (12)
                                             :                 :                 :                 :                                +- ^ FilterExecTransformer (11)
                                             :                 :                 :                 :                                   +- ^ Scan parquet (10)
                                             :                 :                 :                 +- ^ InputIteratorTransformer (35)
                                             :                 :                 :                    +- ShuffleQueryStage (33)
                                             :                 :                 :                       +- ColumnarExchange (32)
                                             :                 :                 :                          +- VeloxAppendBatches (31)
                                             :                 :                 :                             +- ^ ProjectExecTransformer (29)
                                             :                 :                 :                                +- ^ FilterExecTransformer (28)
                                             :                 :                 :                                   +- ^ Scan parquet (27)
                                             :                 :                 +- ^ InputIteratorTransformer (52)
                                             :                 :                    +- ShuffleQueryStage (50)
                                             :                 :                       +- ColumnarExchange (49)
                                             :                 :                          +- VeloxAppendBatches (48)
                                             :                 :                             +- ^ ProjectExecTransformer (46)
                                             :                 :                                +- ^ FilterExecTransformer (45)
                                             :                 :                                   +- ^ Scan parquet (44)
                                             :                 +- ^ InputIteratorTransformer (69)
                                             :                    +- ShuffleQueryStage (67)
                                             :                       +- ColumnarExchange (66)
                                             :                          +- VeloxAppendBatches (65)
                                             :                             +- ^ ProjectExecTransformer (63)
                                             :                                +- ^ FilterExecTransformer (62)
                                             :                                   +- ^ Scan parquet (61)
                                             +- ^ InputIteratorTransformer (86)
                                                +- ShuffleQueryStage (84)
                                                   +- ColumnarExchange (83)
                                                      +- VeloxAppendBatches (82)
                                                         +- ^ ProjectExecTransformer (80)
                                                            +- ^ FilterExecTransformer (79)
                                                               +- ^ Scan parquet (78)
+- == Initial Plan ==
   Sort (154)
   +- Exchange (153)
      +- HashAggregate (152)
         +- Exchange (151)
            +- HashAggregate (150)
               +- Project (149)
                  +- SortMergeJoin Inner (148)
                     :- Sort (143)
                     :  +- Exchange (142)
                     :     +- Project (141)
                     :        +- SortMergeJoin Inner (140)
                     :           :- Sort (135)
                     :           :  +- Exchange (134)
                     :           :     +- Project (133)
                     :           :        +- SortMergeJoin Inner (132)
                     :           :           :- Sort (127)
                     :           :           :  +- Exchange (126)
                     :           :           :     +- Project (125)
                     :           :           :        +- SortMergeJoin Inner (124)
                     :           :           :           :- Sort (119)
                     :           :           :           :  +- Exchange (118)
                     :           :           :           :     +- Project (117)
                     :           :           :           :        +- SortMergeJoin Inner (116)
                     :           :           :           :           :- Sort (111)
                     :           :           :           :           :  +- Exchange (110)
                     :           :           :           :           :     +- Project (109)
                     :           :           :           :           :        +- Filter (108)
                     :           :           :           :           :           +- Scan parquet (107)
                     :           :           :           :           +- Sort (115)
                     :           :           :           :              +- Exchange (114)
                     :           :           :           :                 +- Filter (113)
                     :           :           :           :                    +- Scan parquet (112)
                     :           :           :           +- Sort (123)
                     :           :           :              +- Exchange (122)
                     :           :           :                 +- Filter (121)
                     :           :           :                    +- Scan parquet (120)
                     :           :           +- Sort (131)
                     :           :              +- Exchange (130)
                     :           :                 +- Filter (129)
                     :           :                    +- Scan parquet (128)
                     :           +- Sort (139)
                     :              +- Exchange (138)
                     :                 +- Filter (137)
                     :                    +- Scan parquet (136)
                     +- Sort (147)
                        +- Exchange (146)
                           +- Filter (145)
                              +- Scan parquet (144)


(1) Scan parquet
Output [2]: [p_partkey#X, p_name#X]
Batched: true
Location: InMemoryFileIndex [*]
PushedFilters: [IsNotNull(p_name), StringContains(p_name,green), IsNotNull(p_partkey)]
ReadSchema: struct<p_partkey:bigint,p_name:string>

(2) FilterExecTransformer
Input [2]: [p_partkey#X, p_name#X]
Arguments: ((isnotnull(p_name#X) AND Contains(p_name#X, green)) AND isnotnull(p_partkey#X))

(3) ProjectExecTransformer
Output [2]: [hash(p_partkey#X, 42) AS hash_partition_key#X, p_partkey#X]
Input [2]: [p_partkey#X, p_name#X]

(4) WholeStageCodegenTransformer (X)
Input [2]: [hash_partition_key#X, p_partkey#X]
Arguments: false

(5) VeloxAppendBatches
Input [2]: [hash_partition_key#X, p_partkey#X]
Arguments: X

(6) ColumnarExchange
Input [2]: [hash_partition_key#X, p_partkey#X]
Arguments: hashpartitioning(p_partkey#X, 1), ENSURE_REQUIREMENTS, [p_partkey#X], [plan_id=X], [id=#X]

(7) ShuffleQueryStage
Output [1]: [p_partkey#X]
Arguments: X

(8) InputAdapter
Input [1]: [p_partkey#X]

(9) InputIteratorTransformer
Input [1]: [p_partkey#X]

(10) Scan parquet
Output [6]: [l_orderkey#X, l_partkey#X, l_suppkey#X, l_quantity#X, l_extendedprice#X, l_discount#X]
Batched: true
Location: InMemoryFileIndex [*]
PushedFilters: [IsNotNull(l_partkey), IsNotNull(l_suppkey), IsNotNull(l_orderkey)]
ReadSchema: struct<l_orderkey:bigint,l_partkey:bigint,l_suppkey:bigint,l_quantity:decimal(12,2),l_extendedprice:decimal(12,2),l_discount:decimal(12,2)>

(11) FilterExecTransformer
Input [6]: [l_orderkey#X, l_partkey#X, l_suppkey#X, l_quantity#X, l_extendedprice#X, l_discount#X]
Arguments: ((isnotnull(l_partkey#X) AND isnotnull(l_suppkey#X)) AND isnotnull(l_orderkey#X))

(12) ProjectExecTransformer
Output [7]: [hash(l_partkey#X, 42) AS hash_partition_key#X, l_orderkey#X, l_partkey#X, l_suppkey#X, l_quantity#X, l_extendedprice#X, l_discount#X]
Input [6]: [l_orderkey#X, l_partkey#X, l_suppkey#X, l_quantity#X, l_extendedprice#X, l_discount#X]

(13) WholeStageCodegenTransformer (X)
Input [7]: [hash_partition_key#X, l_orderkey#X, l_partkey#X, l_suppkey#X, l_quantity#X, l_extendedprice#X, l_discount#X]
Arguments: false

(14) VeloxAppendBatches
Input [7]: [hash_partition_key#X, l_orderkey#X, l_partkey#X, l_suppkey#X, l_quantity#X, l_extendedprice#X, l_discount#X]
Arguments: X

(15) ColumnarExchange
Input [7]: [hash_partition_key#X, l_orderkey#X, l_partkey#X, l_suppkey#X, l_quantity#X, l_extendedprice#X, l_discount#X]
Arguments: hashpartitioning(l_partkey#X, 1), ENSURE_REQUIREMENTS, [l_orderkey#X, l_partkey#X, l_suppkey#X, l_quantity#X, l_extendedprice#X, l_discount#X], [plan_id=X], [id=#X]

(16) ShuffleQueryStage
Output [6]: [l_orderkey#X, l_partkey#X, l_suppkey#X, l_quantity#X, l_extendedprice#X, l_discount#X]
Arguments: X

(17) InputAdapter
Input [6]: [l_orderkey#X, l_partkey#X, l_suppkey#X, l_quantity#X, l_extendedprice#X, l_discount#X]

(18) InputIteratorTransformer
Input [6]: [l_orderkey#X, l_partkey#X, l_suppkey#X, l_quantity#X, l_extendedprice#X, l_discount#X]

(19) ShuffledHashJoinExecTransformer
Left keys [1]: [p_partkey#X]
Right keys [1]: [l_partkey#X]
Join condition: None

(20) ProjectExecTransformer
Output [7]: [hash(l_suppkey#X, 42) AS hash_partition_key#X, l_orderkey#X, l_partkey#X, l_suppkey#X, l_quantity#X, l_extendedprice#X, l_discount#X]
Input [7]: [p_partkey#X, l_orderkey#X, l_partkey#X, l_suppkey#X, l_quantity#X, l_extendedprice#X, l_discount#X]

(21) WholeStageCodegenTransformer (X)
Input [7]: [hash_partition_key#X, l_orderkey#X, l_partkey#X, l_suppkey#X, l_quantity#X, l_extendedprice#X, l_discount#X]
Arguments: false

(22) VeloxAppendBatches
Input [7]: [hash_partition_key#X, l_orderkey#X, l_partkey#X, l_suppkey#X, l_quantity#X, l_extendedprice#X, l_discount#X]
Arguments: X

(23) ColumnarExchange
Input [7]: [hash_partition_key#X, l_orderkey#X, l_partkey#X, l_suppkey#X, l_quantity#X, l_extendedprice#X, l_discount#X]
Arguments: hashpartitioning(l_suppkey#X, 1), ENSURE_REQUIREMENTS, [l_orderkey#X, l_partkey#X, l_suppkey#X, l_quantity#X, l_extendedprice#X, l_discount#X], [plan_id=X], [id=#X]

(24) ShuffleQueryStage
Output [6]: [l_orderkey#X, l_partkey#X, l_suppkey#X, l_quantity#X, l_extendedprice#X, l_discount#X]
Arguments: X

(25) InputAdapter
Input [6]: [l_orderkey#X, l_partkey#X, l_suppkey#X, l_quantity#X, l_extendedprice#X, l_discount#X]

(26) InputIteratorTransformer
Input [6]: [l_orderkey#X, l_partkey#X, l_suppkey#X, l_quantity#X, l_extendedprice#X, l_discount#X]

(27) Scan parquet
Output [2]: [s_suppkey#X, s_nationkey#X]
Batched: true
Location: InMemoryFileIndex [*]
PushedFilters: [IsNotNull(s_suppkey), IsNotNull(s_nationkey)]
ReadSchema: struct<s_suppkey:bigint,s_nationkey:bigint>

(28) FilterExecTransformer
Input [2]: [s_suppkey#X, s_nationkey#X]
Arguments: (isnotnull(s_suppkey#X) AND isnotnull(s_nationkey#X))

(29) ProjectExecTransformer
Output [3]: [hash(s_suppkey#X, 42) AS hash_partition_key#X, s_suppkey#X, s_nationkey#X]
Input [2]: [s_suppkey#X, s_nationkey#X]

(30) WholeStageCodegenTransformer (X)
Input [3]: [hash_partition_key#X, s_suppkey#X, s_nationkey#X]
Arguments: false

(31) VeloxAppendBatches
Input [3]: [hash_partition_key#X, s_suppkey#X, s_nationkey#X]
Arguments: X

(32) ColumnarExchange
Input [3]: [hash_partition_key#X, s_suppkey#X, s_nationkey#X]
Arguments: hashpartitioning(s_suppkey#X, 1), ENSURE_REQUIREMENTS, [s_suppkey#X, s_nationkey#X], [plan_id=X], [id=#X]

(33) ShuffleQueryStage
Output [2]: [s_suppkey#X, s_nationkey#X]
Arguments: X

(34) InputAdapter
Input [2]: [s_suppkey#X, s_nationkey#X]

(35) InputIteratorTransformer
Input [2]: [s_suppkey#X, s_nationkey#X]

(36) ShuffledHashJoinExecTransformer
Left keys [1]: [l_suppkey#X]
Right keys [1]: [s_suppkey#X]
Join condition: None

(37) ProjectExecTransformer
Output [8]: [hash(l_suppkey#X, l_partkey#X, 42) AS hash_partition_key#X, l_orderkey#X, l_partkey#X, l_suppkey#X, l_quantity#X, l_extendedprice#X, l_discount#X, s_nationkey#X]
Input [8]: [l_orderkey#X, l_partkey#X, l_suppkey#X, l_quantity#X, l_extendedprice#X, l_discount#X, s_suppkey#X, s_nationkey#X]

(38) WholeStageCodegenTransformer (X)
Input [8]: [hash_partition_key#X, l_orderkey#X, l_partkey#X, l_suppkey#X, l_quantity#X, l_extendedprice#X, l_discount#X, s_nationkey#X]
Arguments: false

(39) VeloxAppendBatches
Input [8]: [hash_partition_key#X, l_orderkey#X, l_partkey#X, l_suppkey#X, l_quantity#X, l_extendedprice#X, l_discount#X, s_nationkey#X]
Arguments: X

(40) ColumnarExchange
Input [8]: [hash_partition_key#X, l_orderkey#X, l_partkey#X, l_suppkey#X, l_quantity#X, l_extendedprice#X, l_discount#X, s_nationkey#X]
Arguments: hashpartitioning(l_suppkey#X, l_partkey#X, 1), ENSURE_REQUIREMENTS, [l_orderkey#X, l_partkey#X, l_suppkey#X, l_quantity#X, l_extendedprice#X, l_discount#X, s_nationkey#X], [plan_id=X], [id=#X]

(41) ShuffleQueryStage
Output [7]: [l_orderkey#X, l_partkey#X, l_suppkey#X, l_quantity#X, l_extendedprice#X, l_discount#X, s_nationkey#X]
Arguments: X

(42) InputAdapter
Input [7]: [l_orderkey#X, l_partkey#X, l_suppkey#X, l_quantity#X, l_extendedprice#X, l_discount#X, s_nationkey#X]

(43) InputIteratorTransformer
Input [7]: [l_orderkey#X, l_partkey#X, l_suppkey#X, l_quantity#X, l_extendedprice#X, l_discount#X, s_nationkey#X]

(44) Scan parquet
Output [3]: [ps_partkey#X, ps_suppkey#X, ps_supplycost#X]
Batched: true
Location: InMemoryFileIndex [*]
PushedFilters: [IsNotNull(ps_suppkey), IsNotNull(ps_partkey)]
ReadSchema: struct<ps_partkey:bigint,ps_suppkey:bigint,ps_supplycost:decimal(12,2)>

(45) FilterExecTransformer
Input [3]: [ps_partkey#X, ps_suppkey#X, ps_supplycost#X]
Arguments: (isnotnull(ps_suppkey#X) AND isnotnull(ps_partkey#X))

(46) ProjectExecTransformer
Output [4]: [hash(ps_suppkey#X, ps_partkey#X, 42) AS hash_partition_key#X, ps_partkey#X, ps_suppkey#X, ps_supplycost#X]
Input [3]: [ps_partkey#X, ps_suppkey#X, ps_supplycost#X]

(47) WholeStageCodegenTransformer (X)
Input [4]: [hash_partition_key#X, ps_partkey#X, ps_suppkey#X, ps_supplycost#X]
Arguments: false

(48) VeloxAppendBatches
Input [4]: [hash_partition_key#X, ps_partkey#X, ps_suppkey#X, ps_supplycost#X]
Arguments: X

(49) ColumnarExchange
Input [4]: [hash_partition_key#X, ps_partkey#X, ps_suppkey#X, ps_supplycost#X]
Arguments: hashpartitioning(ps_suppkey#X, ps_partkey#X, 1), ENSURE_REQUIREMENTS, [ps_partkey#X, ps_suppkey#X, ps_supplycost#X], [plan_id=X], [id=#X]

(50) ShuffleQueryStage
Output [3]: [ps_partkey#X, ps_suppkey#X, ps_supplycost#X]
Arguments: X

(51) InputAdapter
Input [3]: [ps_partkey#X, ps_suppkey#X, ps_supplycost#X]

(52) InputIteratorTransformer
Input [3]: [ps_partkey#X, ps_suppkey#X, ps_supplycost#X]

(53) ShuffledHashJoinExecTransformer
Left keys [2]: [l_suppkey#X, l_partkey#X]
Right keys [2]: [ps_suppkey#X, ps_partkey#X]
Join condition: None

(54) ProjectExecTransformer
Output [7]: [hash(l_orderkey#X, 42) AS hash_partition_key#X, l_orderkey#X, l_quantity#X, l_extendedprice#X, l_discount#X, s_nationkey#X, ps_supplycost#X]
Input [10]: [l_orderkey#X, l_partkey#X, l_suppkey#X, l_quantity#X, l_extendedprice#X, l_discount#X, s_nationkey#X, ps_partkey#X, ps_suppkey#X, ps_supplycost#X]

(55) WholeStageCodegenTransformer (X)
Input [7]: [hash_partition_key#X, l_orderkey#X, l_quantity#X, l_extendedprice#X, l_discount#X, s_nationkey#X, ps_supplycost#X]
Arguments: false

(56) VeloxAppendBatches
Input [7]: [hash_partition_key#X, l_orderkey#X, l_quantity#X, l_extendedprice#X, l_discount#X, s_nationkey#X, ps_supplycost#X]
Arguments: X

(57) ColumnarExchange
Input [7]: [hash_partition_key#X, l_orderkey#X, l_quantity#X, l_extendedprice#X, l_discount#X, s_nationkey#X, ps_supplycost#X]
Arguments: hashpartitioning(l_orderkey#X, 1), ENSURE_REQUIREMENTS, [l_orderkey#X, l_quantity#X, l_extendedprice#X, l_discount#X, s_nationkey#X, ps_supplycost#X], [plan_id=X], [id=#X]

(58) ShuffleQueryStage
Output [6]: [l_orderkey#X, l_quantity#X, l_extendedprice#X, l_discount#X, s_nationkey#X, ps_supplycost#X]
Arguments: X

(59) InputAdapter
Input [6]: [l_orderkey#X, l_quantity#X, l_extendedprice#X, l_discount#X, s_nationkey#X, ps_supplycost#X]

(60) InputIteratorTransformer
Input [6]: [l_orderkey#X, l_quantity#X, l_extendedprice#X, l_discount#X, s_nationkey#X, ps_supplycost#X]

(61) Scan parquet
Output [2]: [o_orderkey#X, o_orderdate#X]
Batched: true
Location: InMemoryFileIndex [*]
PushedFilters: [IsNotNull(o_orderkey)]
ReadSchema: struct<o_orderkey:bigint,o_orderdate:date>

(62) FilterExecTransformer
Input [2]: [o_orderkey#X, o_orderdate#X]
Arguments: isnotnull(o_orderkey#X)

(63) ProjectExecTransformer
Output [3]: [hash(o_orderkey#X, 42) AS hash_partition_key#X, o_orderkey#X, o_orderdate#X]
Input [2]: [o_orderkey#X, o_orderdate#X]

(64) WholeStageCodegenTransformer (X)
Input [3]: [hash_partition_key#X, o_orderkey#X, o_orderdate#X]
Arguments: false

(65) VeloxAppendBatches
Input [3]: [hash_partition_key#X, o_orderkey#X, o_orderdate#X]
Arguments: X

(66) ColumnarExchange
Input [3]: [hash_partition_key#X, o_orderkey#X, o_orderdate#X]
Arguments: hashpartitioning(o_orderkey#X, 1), ENSURE_REQUIREMENTS, [o_orderkey#X, o_orderdate#X], [plan_id=X], [id=#X]

(67) ShuffleQueryStage
Output [2]: [o_orderkey#X, o_orderdate#X]
Arguments: X

(68) InputAdapter
Input [2]: [o_orderkey#X, o_orderdate#X]

(69) InputIteratorTransformer
Input [2]: [o_orderkey#X, o_orderdate#X]

(70) ShuffledHashJoinExecTransformer
Left keys [1]: [l_orderkey#X]
Right keys [1]: [o_orderkey#X]
Join condition: None

(71) ProjectExecTransformer
Output [7]: [hash(s_nationkey#X, 42) AS hash_partition_key#X, l_quantity#X, l_extendedprice#X, l_discount#X, s_nationkey#X, ps_supplycost#X, o_orderdate#X]
Input [8]: [l_orderkey#X, l_quantity#X, l_extendedprice#X, l_discount#X, s_nationkey#X, ps_supplycost#X, o_orderkey#X, o_orderdate#X]

(72) WholeStageCodegenTransformer (X)
Input [7]: [hash_partition_key#X, l_quantity#X, l_extendedprice#X, l_discount#X, s_nationkey#X, ps_supplycost#X, o_orderdate#X]
Arguments: false

(73) VeloxAppendBatches
Input [7]: [hash_partition_key#X, l_quantity#X, l_extendedprice#X, l_discount#X, s_nationkey#X, ps_supplycost#X, o_orderdate#X]
Arguments: X

(74) ColumnarExchange
Input [7]: [hash_partition_key#X, l_quantity#X, l_extendedprice#X, l_discount#X, s_nationkey#X, ps_supplycost#X, o_orderdate#X]
Arguments: hashpartitioning(s_nationkey#X, 1), ENSURE_REQUIREMENTS, [l_quantity#X, l_extendedprice#X, l_discount#X, s_nationkey#X, ps_supplycost#X, o_orderdate#X], [plan_id=X], [id=#X]

(75) ShuffleQueryStage
Output [6]: [l_quantity#X, l_extendedprice#X, l_discount#X, s_nationkey#X, ps_supplycost#X, o_orderdate#X]
Arguments: X

(76) InputAdapter
Input [6]: [l_quantity#X, l_extendedprice#X, l_discount#X, s_nationkey#X, ps_supplycost#X, o_orderdate#X]

(77) InputIteratorTransformer
Input [6]: [l_quantity#X, l_extendedprice#X, l_discount#X, s_nationkey#X, ps_supplycost#X, o_orderdate#X]

(78) Scan parquet
Output [2]: [n_nationkey#X, n_name#X]
Batched: true
Location: InMemoryFileIndex [*]
PushedFilters: [IsNotNull(n_nationkey)]
ReadSchema: struct<n_nationkey:bigint,n_name:string>

(79) FilterExecTransformer
Input [2]: [n_nationkey#X, n_name#X]
Arguments: isnotnull(n_nationkey#X)

(80) ProjectExecTransformer
Output [3]: [hash(n_nationkey#X, 42) AS hash_partition_key#X, n_nationkey#X, n_name#X]
Input [2]: [n_nationkey#X, n_name#X]

(81) WholeStageCodegenTransformer (X)
Input [3]: [hash_partition_key#X, n_nationkey#X, n_name#X]
Arguments: false

(82) VeloxAppendBatches
Input [3]: [hash_partition_key#X, n_nationkey#X, n_name#X]
Arguments: X

(83) ColumnarExchange
Input [3]: [hash_partition_key#X, n_nationkey#X, n_name#X]
Arguments: hashpartitioning(n_nationkey#X, 1), ENSURE_REQUIREMENTS, [n_nationkey#X, n_name#X], [plan_id=X], [id=#X]

(84) ShuffleQueryStage
Output [2]: [n_nationkey#X, n_name#X]
Arguments: X

(85) InputAdapter
Input [2]: [n_nationkey#X, n_name#X]

(86) InputIteratorTransformer
Input [2]: [n_nationkey#X, n_name#X]

(87) ShuffledHashJoinExecTransformer
Left keys [1]: [s_nationkey#X]
Right keys [1]: [n_nationkey#X]
Join condition: None

(88) ProjectExecTransformer
Output [3]: [n_name#X AS nation#X, year(o_orderdate#X) AS o_year#X, CheckOverflow((promote_precision(cast(CheckOverflow((promote_precision(cast(l_extendedprice#X as decimal(13,2))) * promote_precision(CheckOverflow((1.00 - promote_precision(cast(l_discount#X as decimal(13,2)))), DecimalType(13,2), true))), DecimalType(26,4), true) as decimal(27,4))) - promote_precision(cast(CheckOverflow((promote_precision(ps_supplycost#X) * promote_precision(l_quantity#X)), DecimalType(25,4), true) as decimal(27,4)))), DecimalType(27,4), true) AS amount#X]
Input [8]: [l_quantity#X, l_extendedprice#X, l_discount#X, s_nationkey#X, ps_supplycost#X, o_orderdate#X, n_nationkey#X, n_name#X]

(89) FlushableHashAggregateExecTransformer
Input [3]: [nation#X, o_year#X, amount#X]
Keys [2]: [nation#X, o_year#X]
Functions [1]: [partial_sum(amount#X)]
Aggregate Attributes [2]: [sum#X, isEmpty#X]
Results [4]: [nation#X, o_year#X, sum#X, isEmpty#X]

(90) ProjectExecTransformer
Output [5]: [hash(nation#X, o_year#X, 42) AS hash_partition_key#X, nation#X, o_year#X, sum#X, isEmpty#X]
Input [4]: [nation#X, o_year#X, sum#X, isEmpty#X]

(91) WholeStageCodegenTransformer (X)
Input [5]: [hash_partition_key#X, nation#X, o_year#X, sum#X, isEmpty#X]
Arguments: false

(92) VeloxAppendBatches
Input [5]: [hash_partition_key#X, nation#X, o_year#X, sum#X, isEmpty#X]
Arguments: X

(93) ColumnarExchange
Input [5]: [hash_partition_key#X, nation#X, o_year#X, sum#X, isEmpty#X]
Arguments: hashpartitioning(nation#X, o_year#X, 1), ENSURE_REQUIREMENTS, [nation#X, o_year#X, sum#X, isEmpty#X], [plan_id=X], [id=#X]

(94) ShuffleQueryStage
Output [4]: [nation#X, o_year#X, sum#X, isEmpty#X]
Arguments: X

(95) InputAdapter
Input [4]: [nation#X, o_year#X, sum#X, isEmpty#X]

(96) InputIteratorTransformer
Input [4]: [nation#X, o_year#X, sum#X, isEmpty#X]

(97) RegularHashAggregateExecTransformer
Input [4]: [nation#X, o_year#X, sum#X, isEmpty#X]
Keys [2]: [nation#X, o_year#X]
Functions [1]: [sum(amount#X)]
Aggregate Attributes [1]: [sum(amount#X)#X]
Results [3]: [nation#X, o_year#X, sum(amount#X)#X AS sum_profit#X]

(98) WholeStageCodegenTransformer (X)
Input [3]: [nation#X, o_year#X, sum_profit#X]
Arguments: false

(99) VeloxAppendBatches
Input [3]: [nation#X, o_year#X, sum_profit#X]
Arguments: X

(100) ColumnarExchange
Input [3]: [nation#X, o_year#X, sum_profit#X]
Arguments: rangepartitioning(nation#X ASC NULLS FIRST, o_year#X DESC NULLS LAST, 1), ENSURE_REQUIREMENTS, [plan_id=X], [id=#X]

(101) ShuffleQueryStage
Output [3]: [nation#X, o_year#X, sum_profit#X]
Arguments: X

(102) InputAdapter
Input [3]: [nation#X, o_year#X, sum_profit#X]

(103) InputIteratorTransformer
Input [3]: [nation#X, o_year#X, sum_profit#X]

(104) SortExecTransformer
Input [3]: [nation#X, o_year#X, sum_profit#X]
Arguments: [nation#X ASC NULLS FIRST, o_year#X DESC NULLS LAST], true, 0

(105) WholeStageCodegenTransformer (X)
Input [3]: [nation#X, o_year#X, sum_profit#X]
Arguments: false

(106) VeloxColumnarToRowExec
Input [3]: [nation#X, o_year#X, sum_profit#X]

(107) Scan parquet
Output [2]: [p_partkey#X, p_name#X]
Batched: true
Location: InMemoryFileIndex [*]
PushedFilters: [IsNotNull(p_name), StringContains(p_name,green), IsNotNull(p_partkey)]
ReadSchema: struct<p_partkey:bigint,p_name:string>

(108) Filter
Input [2]: [p_partkey#X, p_name#X]
Condition : ((isnotnull(p_name#X) AND Contains(p_name#X, green)) AND isnotnull(p_partkey#X))

(109) Project
Output [1]: [p_partkey#X]
Input [2]: [p_partkey#X, p_name#X]

(110) Exchange
Input [1]: [p_partkey#X]
Arguments: hashpartitioning(p_partkey#X, 1), ENSURE_REQUIREMENTS, [plan_id=X]

(111) Sort
Input [1]: [p_partkey#X]
Arguments: [p_partkey#X ASC NULLS FIRST], false, 0

(112) Scan parquet
Output [6]: [l_orderkey#X, l_partkey#X, l_suppkey#X, l_quantity#X, l_extendedprice#X, l_discount#X]
Batched: true
Location: InMemoryFileIndex [*]
PushedFilters: [IsNotNull(l_partkey), IsNotNull(l_suppkey), IsNotNull(l_orderkey)]
ReadSchema: struct<l_orderkey:bigint,l_partkey:bigint,l_suppkey:bigint,l_quantity:decimal(12,2),l_extendedprice:decimal(12,2),l_discount:decimal(12,2)>

(113) Filter
Input [6]: [l_orderkey#X, l_partkey#X, l_suppkey#X, l_quantity#X, l_extendedprice#X, l_discount#X]
Condition : ((isnotnull(l_partkey#X) AND isnotnull(l_suppkey#X)) AND isnotnull(l_orderkey#X))

(114) Exchange
Input [6]: [l_orderkey#X, l_partkey#X, l_suppkey#X, l_quantity#X, l_extendedprice#X, l_discount#X]
Arguments: hashpartitioning(l_partkey#X, 1), ENSURE_REQUIREMENTS, [plan_id=X]

(115) Sort
Input [6]: [l_orderkey#X, l_partkey#X, l_suppkey#X, l_quantity#X, l_extendedprice#X, l_discount#X]
Arguments: [l_partkey#X ASC NULLS FIRST], false, 0

(116) SortMergeJoin
Left keys [1]: [p_partkey#X]
Right keys [1]: [l_partkey#X]
Join condition: None

(117) Project
Output [6]: [l_orderkey#X, l_partkey#X, l_suppkey#X, l_quantity#X, l_extendedprice#X, l_discount#X]
Input [7]: [p_partkey#X, l_orderkey#X, l_partkey#X, l_suppkey#X, l_quantity#X, l_extendedprice#X, l_discount#X]

(118) Exchange
Input [6]: [l_orderkey#X, l_partkey#X, l_suppkey#X, l_quantity#X, l_extendedprice#X, l_discount#X]
Arguments: hashpartitioning(l_suppkey#X, 1), ENSURE_REQUIREMENTS, [plan_id=X]

(119) Sort
Input [6]: [l_orderkey#X, l_partkey#X, l_suppkey#X, l_quantity#X, l_extendedprice#X, l_discount#X]
Arguments: [l_suppkey#X ASC NULLS FIRST], false, 0

(120) Scan parquet
Output [2]: [s_suppkey#X, s_nationkey#X]
Batched: true
Location: InMemoryFileIndex [*]
PushedFilters: [IsNotNull(s_suppkey), IsNotNull(s_nationkey)]
ReadSchema: struct<s_suppkey:bigint,s_nationkey:bigint>

(121) Filter
Input [2]: [s_suppkey#X, s_nationkey#X]
Condition : (isnotnull(s_suppkey#X) AND isnotnull(s_nationkey#X))

(122) Exchange
Input [2]: [s_suppkey#X, s_nationkey#X]
Arguments: hashpartitioning(s_suppkey#X, 1), ENSURE_REQUIREMENTS, [plan_id=X]

(123) Sort
Input [2]: [s_suppkey#X, s_nationkey#X]
Arguments: [s_suppkey#X ASC NULLS FIRST], false, 0

(124) SortMergeJoin
Left keys [1]: [l_suppkey#X]
Right keys [1]: [s_suppkey#X]
Join condition: None

(125) Project
Output [7]: [l_orderkey#X, l_partkey#X, l_suppkey#X, l_quantity#X, l_extendedprice#X, l_discount#X, s_nationkey#X]
Input [8]: [l_orderkey#X, l_partkey#X, l_suppkey#X, l_quantity#X, l_extendedprice#X, l_discount#X, s_suppkey#X, s_nationkey#X]

(126) Exchange
Input [7]: [l_orderkey#X, l_partkey#X, l_suppkey#X, l_quantity#X, l_extendedprice#X, l_discount#X, s_nationkey#X]
Arguments: hashpartitioning(l_suppkey#X, l_partkey#X, 1), ENSURE_REQUIREMENTS, [plan_id=X]

(127) Sort
Input [7]: [l_orderkey#X, l_partkey#X, l_suppkey#X, l_quantity#X, l_extendedprice#X, l_discount#X, s_nationkey#X]
Arguments: [l_suppkey#X ASC NULLS FIRST, l_partkey#X ASC NULLS FIRST], false, 0

(128) Scan parquet
Output [3]: [ps_partkey#X, ps_suppkey#X, ps_supplycost#X]
Batched: true
Location: InMemoryFileIndex [*]
PushedFilters: [IsNotNull(ps_suppkey), IsNotNull(ps_partkey)]
ReadSchema: struct<ps_partkey:bigint,ps_suppkey:bigint,ps_supplycost:decimal(12,2)>

(129) Filter
Input [3]: [ps_partkey#X, ps_suppkey#X, ps_supplycost#X]
Condition : (isnotnull(ps_suppkey#X) AND isnotnull(ps_partkey#X))

(130) Exchange
Input [3]: [ps_partkey#X, ps_suppkey#X, ps_supplycost#X]
Arguments: hashpartitioning(ps_suppkey#X, ps_partkey#X, 1), ENSURE_REQUIREMENTS, [plan_id=X]

(131) Sort
Input [3]: [ps_partkey#X, ps_suppkey#X, ps_supplycost#X]
Arguments: [ps_suppkey#X ASC NULLS FIRST, ps_partkey#X ASC NULLS FIRST], false, 0

(132) SortMergeJoin
Left keys [2]: [l_suppkey#X, l_partkey#X]
Right keys [2]: [ps_suppkey#X, ps_partkey#X]
Join condition: None

(133) Project
Output [6]: [l_orderkey#X, l_quantity#X, l_extendedprice#X, l_discount#X, s_nationkey#X, ps_supplycost#X]
Input [10]: [l_orderkey#X, l_partkey#X, l_suppkey#X, l_quantity#X, l_extendedprice#X, l_discount#X, s_nationkey#X, ps_partkey#X, ps_suppkey#X, ps_supplycost#X]

(134) Exchange
Input [6]: [l_orderkey#X, l_quantity#X, l_extendedprice#X, l_discount#X, s_nationkey#X, ps_supplycost#X]
Arguments: hashpartitioning(l_orderkey#X, 1), ENSURE_REQUIREMENTS, [plan_id=X]

(135) Sort
Input [6]: [l_orderkey#X, l_quantity#X, l_extendedprice#X, l_discount#X, s_nationkey#X, ps_supplycost#X]
Arguments: [l_orderkey#X ASC NULLS FIRST], false, 0

(136) Scan parquet
Output [2]: [o_orderkey#X, o_orderdate#X]
Batched: true
Location: InMemoryFileIndex [*]
PushedFilters: [IsNotNull(o_orderkey)]
ReadSchema: struct<o_orderkey:bigint,o_orderdate:date>

(137) Filter
Input [2]: [o_orderkey#X, o_orderdate#X]
Condition : isnotnull(o_orderkey#X)

(138) Exchange
Input [2]: [o_orderkey#X, o_orderdate#X]
Arguments: hashpartitioning(o_orderkey#X, 1), ENSURE_REQUIREMENTS, [plan_id=X]

(139) Sort
Input [2]: [o_orderkey#X, o_orderdate#X]
Arguments: [o_orderkey#X ASC NULLS FIRST], false, 0

(140) SortMergeJoin
Left keys [1]: [l_orderkey#X]
Right keys [1]: [o_orderkey#X]
Join condition: None

(141) Project
Output [6]: [l_quantity#X, l_extendedprice#X, l_discount#X, s_nationkey#X, ps_supplycost#X, o_orderdate#X]
Input [8]: [l_orderkey#X, l_quantity#X, l_extendedprice#X, l_discount#X, s_nationkey#X, ps_supplycost#X, o_orderkey#X, o_orderdate#X]

(142) Exchange
Input [6]: [l_quantity#X, l_extendedprice#X, l_discount#X, s_nationkey#X, ps_supplycost#X, o_orderdate#X]
Arguments: hashpartitioning(s_nationkey#X, 1), ENSURE_REQUIREMENTS, [plan_id=X]

(143) Sort
Input [6]: [l_quantity#X, l_extendedprice#X, l_discount#X, s_nationkey#X, ps_supplycost#X, o_orderdate#X]
Arguments: [s_nationkey#X ASC NULLS FIRST], false, 0

(144) Scan parquet
Output [2]: [n_nationkey#X, n_name#X]
Batched: true
Location: InMemoryFileIndex [*]
PushedFilters: [IsNotNull(n_nationkey)]
ReadSchema: struct<n_nationkey:bigint,n_name:string>

(145) Filter
Input [2]: [n_nationkey#X, n_name#X]
Condition : isnotnull(n_nationkey#X)

(146) Exchange
Input [2]: [n_nationkey#X, n_name#X]
Arguments: hashpartitioning(n_nationkey#X, 1), ENSURE_REQUIREMENTS, [plan_id=X]

(147) Sort
Input [2]: [n_nationkey#X, n_name#X]
Arguments: [n_nationkey#X ASC NULLS FIRST], false, 0

(148) SortMergeJoin
Left keys [1]: [s_nationkey#X]
Right keys [1]: [n_nationkey#X]
Join condition: None

(149) Project
Output [3]: [n_name#X AS nation#X, year(o_orderdate#X) AS o_year#X, CheckOverflow((promote_precision(cast(CheckOverflow((promote_precision(cast(l_extendedprice#X as decimal(13,2))) * promote_precision(CheckOverflow((1.00 - promote_precision(cast(l_discount#X as decimal(13,2)))), DecimalType(13,2), true))), DecimalType(26,4), true) as decimal(27,4))) - promote_precision(cast(CheckOverflow((promote_precision(ps_supplycost#X) * promote_precision(l_quantity#X)), DecimalType(25,4), true) as decimal(27,4)))), DecimalType(27,4), true) AS amount#X]
Input [8]: [l_quantity#X, l_extendedprice#X, l_discount#X, s_nationkey#X, ps_supplycost#X, o_orderdate#X, n_nationkey#X, n_name#X]

(150) HashAggregate
Input [3]: [nation#X, o_year#X, amount#X]
Keys [2]: [nation#X, o_year#X]
Functions [1]: [partial_sum(amount#X)]
Aggregate Attributes [2]: [sum#X, isEmpty#X]
Results [4]: [nation#X, o_year#X, sum#X, isEmpty#X]

(151) Exchange
Input [4]: [nation#X, o_year#X, sum#X, isEmpty#X]
Arguments: hashpartitioning(nation#X, o_year#X, 1), ENSURE_REQUIREMENTS, [plan_id=X]

(152) HashAggregate
Input [4]: [nation#X, o_year#X, sum#X, isEmpty#X]
Keys [2]: [nation#X, o_year#X]
Functions [1]: [sum(amount#X)]
Aggregate Attributes [1]: [sum(amount#X)#X]
Results [3]: [nation#X, o_year#X, sum(amount#X)#X AS sum_profit#X]

(153) Exchange
Input [3]: [nation#X, o_year#X, sum_profit#X]
Arguments: rangepartitioning(nation#X ASC NULLS FIRST, o_year#X DESC NULLS LAST, 1), ENSURE_REQUIREMENTS, [plan_id=X]

(154) Sort
Input [3]: [nation#X, o_year#X, sum_profit#X]
Arguments: [nation#X ASC NULLS FIRST, o_year#X DESC NULLS LAST], true, 0

(155) AdaptiveSparkPlan
Output [3]: [nation#X, o_year#X, sum_profit#X]
Arguments: isFinalPlan=true