== Physical Plan ==
VeloxColumnarToRow (74)
+- ^ ProjectExecTransformer (72)
   +- ^ RegularHashAggregateExecTransformer (71)
      +- ^ RegularHashAggregateExecTransformer (70)
         +- ^ RegularHashAggregateExecTransformer (69)
            +- ^ RegularHashAggregateExecTransformer (68)
               +- ^ ProjectExecTransformer (67)
                  +- ^ BroadcastHashJoinExecTransformer Inner BuildRight (66)
                     :- ^ ProjectExecTransformer (58)
                     :  +- ^ BroadcastHashJoinExecTransformer Inner BuildRight (57)
                     :     :- ^ ProjectExecTransformer (49)
                     :     :  +- ^ BroadcastHashJoinExecTransformer Inner BuildRight (48)
                     :     :     :- ^ ShuffledHashJoinExecTransformer LeftSemi BuildRight (40)
                     :     :     :  :- ^ ShuffledHashJoinExecTransformer LeftSemi BuildRight (22)
                     :     :     :  :  :- ^ InputIteratorTransformer (8)
                     :     :     :  :  :  +- ColumnarExchange (6)
                     :     :     :  :  :     +- VeloxResizeBatches (5)
                     :     :     :  :  :        +- ^ ProjectExecTransformer (3)
                     :     :     :  :  :           +- ^ FilterExecTransformer (2)
                     :     :     :  :  :              +- ^ FileSourceScanExecTransformer parquet spark_catalog.default.web_sales (1)
                     :     :     :  :  +- ^ ProjectExecTransformer (21)
                     :     :     :  :     +- ^ ShuffledHashJoinExecTransformer Inner BuildRight (20)
                     :     :     :  :        :- ^ InputIteratorTransformer (16)
                     :     :     :  :        :  +- ColumnarExchange (14)
                     :     :     :  :        :     +- VeloxResizeBatches (13)
                     :     :     :  :        :        +- ^ ProjectExecTransformer (11)
                     :     :     :  :        :           +- ^ FilterExecTransformer (10)
                     :     :     :  :        :              +- ^ FileSourceScanExecTransformer parquet spark_catalog.default.web_sales (9)
                     :     :     :  :        +- ^ InputIteratorTransformer (19)
                     :     :     :  :           +- ReusedExchange (17)
                     :     :     :  +- ^ ProjectExecTransformer (39)
                     :     :     :     +- ^ ShuffledHashJoinExecTransformer Inner BuildRight (38)
                     :     :     :        :- ^ ShuffledHashJoinExecTransformer Inner BuildLeft (34)
                     :     :     :        :  :- ^ InputIteratorTransformer (30)
                     :     :     :        :  :  +- ColumnarExchange (28)
                     :     :     :        :  :     +- VeloxResizeBatches (27)
                     :     :     :        :  :        +- ^ ProjectExecTransformer (25)
                     :     :     :        :  :           +- ^ FilterExecTransformer (24)
                     :     :     :        :  :              +- ^ FileSourceScanExecTransformer parquet spark_catalog.default.web_returns (23)
                     :     :     :        :  +- ^ InputIteratorTransformer (33)
                     :     :     :        :     +- ReusedExchange (31)
                     :     :     :        +- ^ InputIteratorTransformer (37)
                     :     :     :           +- ReusedExchange (35)
                     :     :     +- ^ InputIteratorTransformer (47)
                     :     :        +- ColumnarBroadcastExchange (45)
                     :     :           +- ^ ProjectExecTransformer (43)
                     :     :              +- ^ FilterExecTransformer (42)
                     :     :                 +- ^ FileSourceScanExecTransformer parquet spark_catalog.default.customer_address (41)
                     :     +- ^ InputIteratorTransformer (56)
                     :        +- ColumnarBroadcastExchange (54)
                     :           +- ^ ProjectExecTransformer (52)
                     :              +- ^ FilterExecTransformer (51)
                     :                 +- ^ FileSourceScanExecTransformer parquet spark_catalog.default.web_site (50)
                     +- ^ InputIteratorTransformer (65)
                        +- ColumnarBroadcastExchange (63)
                           +- ^ ProjectExecTransformer (61)
                              +- ^ FilterExecTransformer (60)
                                 +- ^ FileSourceScanExecTransformer parquet spark_catalog.default.date_dim (59)


(1) FileSourceScanExecTransformer parquet spark_catalog.default.web_sales
Output [7]: [ws_ship_date_sk#1, ws_ship_addr_sk#2, ws_web_site_sk#3, ws_order_number#4, ws_ext_ship_cost#5, ws_net_profit#6, ws_sold_date_sk#7]
Batched: true
Location: CatalogFileIndex [{warehouse_dir}/web_sales]
PushedFilters: [IsNotNull(ws_ship_date_sk), IsNotNull(ws_ship_addr_sk), IsNotNull(ws_web_site_sk)]
ReadSchema: struct<ws_ship_date_sk:int,ws_ship_addr_sk:int,ws_web_site_sk:int,ws_order_number:int,ws_ext_ship_cost:decimal(7,2),ws_net_profit:decimal(7,2)>

(2) FilterExecTransformer
Input [7]: [ws_ship_date_sk#1, ws_ship_addr_sk#2, ws_web_site_sk#3, ws_order_number#4, ws_ext_ship_cost#5, ws_net_profit#6, ws_sold_date_sk#7]
Arguments: (((((isnotnull(ws_ship_date_sk#1) AND isnotnull(ws_ship_addr_sk#2)) AND isnotnull(ws_web_site_sk#3)) AND velox_might_contain(Subquery scalar-subquery#8, [id=#1], xxhash64(ws_ship_addr_sk#2, 42))) AND velox_might_contain(Subquery scalar-subquery#9, [id=#2], xxhash64(ws_web_site_sk#3, 42))) AND velox_might_contain(Subquery scalar-subquery#10, [id=#3], xxhash64(ws_ship_date_sk#1, 42)))

(3) ProjectExecTransformer
Output [7]: [hash(ws_order_number#4, 42) AS hash_partition_key#11, ws_ship_date_sk#1, ws_ship_addr_sk#2, ws_web_site_sk#3, ws_order_number#4, ws_ext_ship_cost#5, ws_net_profit#6]
Input [7]: [ws_ship_date_sk#1, ws_ship_addr_sk#2, ws_web_site_sk#3, ws_order_number#4, ws_ext_ship_cost#5, ws_net_profit#6, ws_sold_date_sk#7]

(4) WholeStageCodegenTransformer (7)
Input [7]: [hash_partition_key#11, ws_ship_date_sk#1, ws_ship_addr_sk#2, ws_web_site_sk#3, ws_order_number#4, ws_ext_ship_cost#5, ws_net_profit#6]
Arguments: false

(5) VeloxResizeBatches
Input [7]: [hash_partition_key#11, ws_ship_date_sk#1, ws_ship_addr_sk#2, ws_web_site_sk#3, ws_order_number#4, ws_ext_ship_cost#5, ws_net_profit#6]
Arguments: 1024, 2147483647, 10485760

(6) ColumnarExchange
Input [7]: [hash_partition_key#11, ws_ship_date_sk#1, ws_ship_addr_sk#2, ws_web_site_sk#3, ws_order_number#4, ws_ext_ship_cost#5, ws_net_profit#6]
Arguments: hashpartitioning(ws_order_number#4, 1), ENSURE_REQUIREMENTS, [ws_ship_date_sk#1, ws_ship_addr_sk#2, ws_web_site_sk#3, ws_order_number#4, ws_ext_ship_cost#5, ws_net_profit#6], [plan_id=4], [shuffle_writer_type=hash]

(7) InputAdapter
Input [6]: [ws_ship_date_sk#1, ws_ship_addr_sk#2, ws_web_site_sk#3, ws_order_number#4, ws_ext_ship_cost#5, ws_net_profit#6]

(8) InputIteratorTransformer
Input [6]: [ws_ship_date_sk#1, ws_ship_addr_sk#2, ws_web_site_sk#3, ws_order_number#4, ws_ext_ship_cost#5, ws_net_profit#6]

(9) FileSourceScanExecTransformer parquet spark_catalog.default.web_sales
Output [3]: [ws_warehouse_sk#12, ws_order_number#13, ws_sold_date_sk#14]
Batched: true
Location: CatalogFileIndex [{warehouse_dir}/web_sales]
PushedFilters: [IsNotNull(ws_order_number), IsNotNull(ws_warehouse_sk)]
ReadSchema: struct<ws_warehouse_sk:int,ws_order_number:int>

(10) FilterExecTransformer
Input [3]: [ws_warehouse_sk#12, ws_order_number#13, ws_sold_date_sk#14]
Arguments: (isnotnull(ws_order_number#13) AND isnotnull(ws_warehouse_sk#12))

(11) ProjectExecTransformer
Output [3]: [hash(ws_order_number#13, 42) AS hash_partition_key#15, ws_warehouse_sk#12, ws_order_number#13]
Input [3]: [ws_warehouse_sk#12, ws_order_number#13, ws_sold_date_sk#14]

(12) WholeStageCodegenTransformer (8)
Input [3]: [hash_partition_key#15, ws_warehouse_sk#12, ws_order_number#13]
Arguments: false

(13) VeloxResizeBatches
Input [3]: [hash_partition_key#15, ws_warehouse_sk#12, ws_order_number#13]
Arguments: 1024, 2147483647, 10485760

(14) ColumnarExchange
Input [3]: [hash_partition_key#15, ws_warehouse_sk#12, ws_order_number#13]
Arguments: hashpartitioning(ws_order_number#13, 1), ENSURE_REQUIREMENTS, [ws_warehouse_sk#12, ws_order_number#13], [plan_id=5], [shuffle_writer_type=hash]

(15) InputAdapter
Input [2]: [ws_warehouse_sk#12, ws_order_number#13]

(16) InputIteratorTransformer
Input [2]: [ws_warehouse_sk#12, ws_order_number#13]

(17) ReusedExchange [Reuses operator id: 14]
Output [2]: [ws_warehouse_sk#16, ws_order_number#17]

(18) InputAdapter
Input [2]: [ws_warehouse_sk#16, ws_order_number#17]

(19) InputIteratorTransformer
Input [2]: [ws_warehouse_sk#16, ws_order_number#17]

(20) ShuffledHashJoinExecTransformer
Left keys [1]: [ws_order_number#13]
Right keys [1]: [ws_order_number#17]
Join type: Inner
Join condition: NOT (ws_warehouse_sk#12 = ws_warehouse_sk#16)

(21) ProjectExecTransformer
Output [1]: [ws_order_number#13]
Input [4]: [ws_warehouse_sk#12, ws_order_number#13, ws_warehouse_sk#16, ws_order_number#17]

(22) ShuffledHashJoinExecTransformer
Left keys [1]: [ws_order_number#4]
Right keys [1]: [ws_order_number#13]
Join type: LeftSemi
Join condition: None

(23) FileSourceScanExecTransformer parquet spark_catalog.default.web_returns
Output [2]: [wr_order_number#18, wr_returned_date_sk#19]
Batched: true
Location: CatalogFileIndex [{warehouse_dir}/web_returns]
PushedFilters: [IsNotNull(wr_order_number)]
ReadSchema: struct<wr_order_number:int>

(24) FilterExecTransformer
Input [2]: [wr_order_number#18, wr_returned_date_sk#19]
Arguments: isnotnull(wr_order_number#18)

(25) ProjectExecTransformer
Output [2]: [hash(wr_order_number#18, 42) AS hash_partition_key#20, wr_order_number#18]
Input [2]: [wr_order_number#18, wr_returned_date_sk#19]

(26) WholeStageCodegenTransformer (10)
Input [2]: [hash_partition_key#20, wr_order_number#18]
Arguments: false

(27) VeloxResizeBatches
Input [2]: [hash_partition_key#20, wr_order_number#18]
Arguments: 1024, 2147483647, 10485760

(28) ColumnarExchange
Input [2]: [hash_partition_key#20, wr_order_number#18]
Arguments: hashpartitioning(wr_order_number#18, 1), ENSURE_REQUIREMENTS, [wr_order_number#18], [plan_id=6], [shuffle_writer_type=hash]

(29) InputAdapter
Input [1]: [wr_order_number#18]

(30) InputIteratorTransformer
Input [1]: [wr_order_number#18]

(31) ReusedExchange [Reuses operator id: 14]
Output [2]: [ws_warehouse_sk#21, ws_order_number#22]

(32) InputAdapter
Input [2]: [ws_warehouse_sk#21, ws_order_number#22]

(33) InputIteratorTransformer
Input [2]: [ws_warehouse_sk#21, ws_order_number#22]

(34) ShuffledHashJoinExecTransformer
Left keys [1]: [wr_order_number#18]
Right keys [1]: [ws_order_number#22]
Join type: Inner
Join condition: None

(35) ReusedExchange [Reuses operator id: 14]
Output [2]: [ws_warehouse_sk#23, ws_order_number#24]

(36) InputAdapter
Input [2]: [ws_warehouse_sk#23, ws_order_number#24]

(37) InputIteratorTransformer
Input [2]: [ws_warehouse_sk#23, ws_order_number#24]

(38) ShuffledHashJoinExecTransformer
Left keys [1]: [ws_order_number#22]
Right keys [1]: [ws_order_number#24]
Join type: Inner
Join condition: NOT (ws_warehouse_sk#21 = ws_warehouse_sk#23)

(39) ProjectExecTransformer
Output [1]: [wr_order_number#18]
Input [5]: [wr_order_number#18, ws_warehouse_sk#21, ws_order_number#22, ws_warehouse_sk#23, ws_order_number#24]

(40) ShuffledHashJoinExecTransformer
Left keys [1]: [ws_order_number#4]
Right keys [1]: [wr_order_number#18]
Join type: LeftSemi
Join condition: None

(41) FileSourceScanExecTransformer parquet spark_catalog.default.customer_address
Output [2]: [ca_address_sk#25, ca_state#26]
Batched: true
Location: InMemoryFileIndex [{warehouse_dir}/customer_address]
PushedFilters: [IsNotNull(ca_state), EqualTo(ca_state,IL), IsNotNull(ca_address_sk)]
ReadSchema: struct<ca_address_sk:int,ca_state:string>

(42) FilterExecTransformer
Input [2]: [ca_address_sk#25, ca_state#26]
Arguments: ((isnotnull(ca_state#26) AND (ca_state#26 = IL)) AND isnotnull(ca_address_sk#25))

(43) ProjectExecTransformer
Output [1]: [ca_address_sk#25]
Input [2]: [ca_address_sk#25, ca_state#26]

(44) WholeStageCodegenTransformer (13)
Input [1]: [ca_address_sk#25]
Arguments: false

(45) ColumnarBroadcastExchange
Input [1]: [ca_address_sk#25]
Arguments: HashedRelationBroadcastMode(List(cast(input[0, int, true] as bigint)),false), [plan_id=7]

(46) InputAdapter
Input [1]: [ca_address_sk#25]

(47) InputIteratorTransformer
Input [1]: [ca_address_sk#25]

(48) BroadcastHashJoinExecTransformer
Left keys [1]: [ws_ship_addr_sk#2]
Right keys [1]: [ca_address_sk#25]
Join type: Inner
Join condition: None

(49) ProjectExecTransformer
Output [5]: [ws_ship_date_sk#1, ws_web_site_sk#3, ws_order_number#4, ws_ext_ship_cost#5, ws_net_profit#6]
Input [7]: [ws_ship_date_sk#1, ws_ship_addr_sk#2, ws_web_site_sk#3, ws_order_number#4, ws_ext_ship_cost#5, ws_net_profit#6, ca_address_sk#25]

(50) FileSourceScanExecTransformer parquet spark_catalog.default.web_site
Output [2]: [web_site_sk#27, web_company_name#28]
Batched: true
Location: InMemoryFileIndex [{warehouse_dir}/web_site]
PushedFilters: [IsNotNull(web_company_name), EqualTo(web_company_name,pri                                               ), IsNotNull(web_site_sk)]
ReadSchema: struct<web_site_sk:int,web_company_name:string>

(51) FilterExecTransformer
Input [2]: [web_site_sk#27, web_company_name#28]
Arguments: ((isnotnull(web_company_name#28) AND (web_company_name#28 = pri                                               )) AND isnotnull(web_site_sk#27))

(52) ProjectExecTransformer
Output [1]: [web_site_sk#27]
Input [2]: [web_site_sk#27, web_company_name#28]

(53) WholeStageCodegenTransformer (14)
Input [1]: [web_site_sk#27]
Arguments: false

(54) ColumnarBroadcastExchange
Input [1]: [web_site_sk#27]
Arguments: HashedRelationBroadcastMode(List(cast(input[0, int, true] as bigint)),false), [plan_id=8]

(55) InputAdapter
Input [1]: [web_site_sk#27]

(56) InputIteratorTransformer
Input [1]: [web_site_sk#27]

(57) BroadcastHashJoinExecTransformer
Left keys [1]: [ws_web_site_sk#3]
Right keys [1]: [web_site_sk#27]
Join type: Inner
Join condition: None

(58) ProjectExecTransformer
Output [4]: [ws_ship_date_sk#1, ws_order_number#4, ws_ext_ship_cost#5, ws_net_profit#6]
Input [6]: [ws_ship_date_sk#1, ws_web_site_sk#3, ws_order_number#4, ws_ext_ship_cost#5, ws_net_profit#6, web_site_sk#27]

(59) FileSourceScanExecTransformer parquet spark_catalog.default.date_dim
Output [2]: [d_date_sk#29, d_date#30]
Batched: true
Location: InMemoryFileIndex [{warehouse_dir}/date_dim]
PushedFilters: [IsNotNull(d_date), GreaterThanOrEqual(d_date,1999-02-01), LessThanOrEqual(d_date,1999-04-02), IsNotNull(d_date_sk)]
ReadSchema: struct<d_date_sk:int,d_date:date>

(60) FilterExecTransformer
Input [2]: [d_date_sk#29, d_date#30]
Arguments: (((isnotnull(d_date#30) AND (d_date#30 >= 1999-02-01)) AND (d_date#30 <= 1999-04-02)) AND isnotnull(d_date_sk#29))

(61) ProjectExecTransformer
Output [1]: [d_date_sk#29]
Input [2]: [d_date_sk#29, d_date#30]

(62) WholeStageCodegenTransformer (15)
Input [1]: [d_date_sk#29]
Arguments: false

(63) ColumnarBroadcastExchange
Input [1]: [d_date_sk#29]
Arguments: HashedRelationBroadcastMode(List(cast(input[0, int, true] as bigint)),false), [plan_id=9]

(64) InputAdapter
Input [1]: [d_date_sk#29]

(65) InputIteratorTransformer
Input [1]: [d_date_sk#29]

(66) BroadcastHashJoinExecTransformer
Left keys [1]: [ws_ship_date_sk#1]
Right keys [1]: [d_date_sk#29]
Join type: Inner
Join condition: None

(67) ProjectExecTransformer
Output [3]: [ws_order_number#4, UnscaledValue(ws_ext_ship_cost#5) AS _pre_1#31, UnscaledValue(ws_net_profit#6) AS _pre_2#32]
Input [5]: [ws_ship_date_sk#1, ws_order_number#4, ws_ext_ship_cost#5, ws_net_profit#6, d_date_sk#29]

(68) RegularHashAggregateExecTransformer
Input [3]: [ws_order_number#4, _pre_1#31, _pre_2#32]
Keys [1]: [ws_order_number#4]
Functions [2]: [partial_sum(_pre_1#31), partial_sum(_pre_2#32)]
Aggregate Attributes [2]: [sum(UnscaledValue(ws_ext_ship_cost#5))#33, sum(UnscaledValue(ws_net_profit#6))#34]
Results [3]: [ws_order_number#4, sum#35, sum#36]

(69) RegularHashAggregateExecTransformer
Input [3]: [ws_order_number#4, sum#35, sum#36]
Keys [1]: [ws_order_number#4]
Functions [2]: [merge_sum(UnscaledValue(ws_ext_ship_cost#5)), merge_sum(UnscaledValue(ws_net_profit#6))]
Aggregate Attributes [2]: [sum(UnscaledValue(ws_ext_ship_cost#5))#33, sum(UnscaledValue(ws_net_profit#6))#34]
Results [3]: [ws_order_number#4, sum#35, sum#36]

(70) RegularHashAggregateExecTransformer
Input [3]: [ws_order_number#4, sum#35, sum#36]
Keys: []
Functions [3]: [merge_sum(UnscaledValue(ws_ext_ship_cost#5)), merge_sum(UnscaledValue(ws_net_profit#6)), partial_count(distinct ws_order_number#4)]
Aggregate Attributes [3]: [sum(UnscaledValue(ws_ext_ship_cost#5))#33, sum(UnscaledValue(ws_net_profit#6))#34, count(ws_order_number#4)#37]
Results [3]: [sum#35, sum#36, count#38]

(71) RegularHashAggregateExecTransformer
Input [3]: [sum#35, sum#36, count#38]
Keys: []
Functions [3]: [sum(UnscaledValue(ws_ext_ship_cost#5)), sum(UnscaledValue(ws_net_profit#6)), count(distinct ws_order_number#4)]
Aggregate Attributes [3]: [sum(UnscaledValue(ws_ext_ship_cost#5))#33, sum(UnscaledValue(ws_net_profit#6))#34, count(ws_order_number#4)#37]
Results [3]: [sum(UnscaledValue(ws_ext_ship_cost#5))#33, sum(UnscaledValue(ws_net_profit#6))#34, count(ws_order_number#4)#37]

(72) ProjectExecTransformer
Output [3]: [count(ws_order_number#4)#37 AS order count #39, MakeDecimal(sum(UnscaledValue(ws_ext_ship_cost#5))#33,17,2) AS total shipping cost #40, MakeDecimal(sum(UnscaledValue(ws_net_profit#6))#34,17,2) AS total net profit #41]
Input [3]: [sum(UnscaledValue(ws_ext_ship_cost#5))#33, sum(UnscaledValue(ws_net_profit#6))#34, count(ws_order_number#4)#37]

(73) WholeStageCodegenTransformer (16)
Input [3]: [order count #39, total shipping cost #40, total net profit #41]
Arguments: false

(74) VeloxColumnarToRow
Input [3]: [order count #39, total shipping cost #40, total net profit #41]

===== Subqueries =====

Subquery:1 Hosting operator id = 2 Hosting Expression = Subquery scalar-subquery#8, [id=#1]
VeloxColumnarToRow (86)
+- ^ RegularHashAggregateExecTransformer (84)
   +- ^ InputIteratorTransformer (83)
      +- ColumnarExchange (81)
         +- VeloxResizeBatches (80)
            +- ^ FlushableHashAggregateExecTransformer (78)
               +- ^ ProjectExecTransformer (77)
                  +- ^ FilterExecTransformer (76)
                     +- ^ FileSourceScanExecTransformer parquet spark_catalog.default.customer_address (75)


(75) FileSourceScanExecTransformer parquet spark_catalog.default.customer_address
Output [2]: [ca_address_sk#25, ca_state#26]
Batched: true
Location: InMemoryFileIndex [{warehouse_dir}/customer_address]
PushedFilters: [IsNotNull(ca_state), EqualTo(ca_state,IL), IsNotNull(ca_address_sk)]
ReadSchema: struct<ca_address_sk:int,ca_state:string>

(76) FilterExecTransformer
Input [2]: [ca_address_sk#25, ca_state#26]
Arguments: ((isnotnull(ca_state#26) AND (ca_state#26 = IL)) AND isnotnull(ca_address_sk#25))

(77) ProjectExecTransformer
Output [1]: [xxhash64(ca_address_sk#25, 42) AS _pre_3#42]
Input [2]: [ca_address_sk#25, ca_state#26]

(78) FlushableHashAggregateExecTransformer
Input [1]: [_pre_3#42]
Keys: []
Functions [1]: [partial_velox_bloom_filter_agg(_pre_3#42, 17961, 333176, 0, 0)]
Aggregate Attributes [1]: [buf#43]
Results [1]: [buf#44]

(79) WholeStageCodegenTransformer (1)
Input [1]: [buf#44]
Arguments: false

(80) VeloxResizeBatches
Input [1]: [buf#44]
Arguments: 1024, 2147483647, 10485760

(81) ColumnarExchange
Input [1]: [buf#44]
Arguments: SinglePartition, ENSURE_REQUIREMENTS, [plan_id=10], [shuffle_writer_type=hash]

(82) InputAdapter
Input [1]: [buf#44]

(83) InputIteratorTransformer
Input [1]: [buf#44]

(84) RegularHashAggregateExecTransformer
Input [1]: [buf#44]
Keys: []
Functions [1]: [velox_bloom_filter_agg(xxhash64(ca_address_sk#25, 42), 17961, 333176, 0, 0)]
Aggregate Attributes [1]: [bloom_filter_agg(xxhash64(ca_address_sk#25, 42), 17961, 333176, 0, 0)#45]
Results [1]: [bloom_filter_agg(xxhash64(ca_address_sk#25, 42), 17961, 333176, 0, 0)#45 AS bloomFilter#46]

(85) WholeStageCodegenTransformer (2)
Input [1]: [bloomFilter#46]
Arguments: false

(86) VeloxColumnarToRow
Input [1]: [bloomFilter#46]

Subquery:2 Hosting operator id = 2 Hosting Expression = Subquery scalar-subquery#9, [id=#2]
VeloxColumnarToRow (98)
+- ^ RegularHashAggregateExecTransformer (96)
   +- ^ InputIteratorTransformer (95)
      +- ColumnarExchange (93)
         +- VeloxResizeBatches (92)
            +- ^ FlushableHashAggregateExecTransformer (90)
               +- ^ ProjectExecTransformer (89)
                  +- ^ FilterExecTransformer (88)
                     +- ^ FileSourceScanExecTransformer parquet spark_catalog.default.web_site (87)


(87) FileSourceScanExecTransformer parquet spark_catalog.default.web_site
Output [2]: [web_site_sk#27, web_company_name#28]
Batched: true
Location: InMemoryFileIndex [{warehouse_dir}/web_site]
PushedFilters: [IsNotNull(web_company_name), EqualTo(web_company_name,pri                                               ), IsNotNull(web_site_sk)]
ReadSchema: struct<web_site_sk:int,web_company_name:string>

(88) FilterExecTransformer
Input [2]: [web_site_sk#27, web_company_name#28]
Arguments: ((isnotnull(web_company_name#28) AND (web_company_name#28 = pri                                               )) AND isnotnull(web_site_sk#27))

(89) ProjectExecTransformer
Output [1]: [xxhash64(web_site_sk#27, 42) AS _pre_4#47]
Input [2]: [web_site_sk#27, web_company_name#28]

(90) FlushableHashAggregateExecTransformer
Input [1]: [_pre_4#47]
Keys: []
Functions [1]: [partial_velox_bloom_filter_agg(_pre_4#47, 4, 144, 0, 0)]
Aggregate Attributes [1]: [buf#48]
Results [1]: [buf#49]

(91) WholeStageCodegenTransformer (3)
Input [1]: [buf#49]
Arguments: false

(92) VeloxResizeBatches
Input [1]: [buf#49]
Arguments: 1024, 2147483647, 10485760

(93) ColumnarExchange
Input [1]: [buf#49]
Arguments: SinglePartition, ENSURE_REQUIREMENTS, [plan_id=11], [shuffle_writer_type=hash]

(94) InputAdapter
Input [1]: [buf#49]

(95) InputIteratorTransformer
Input [1]: [buf#49]

(96) RegularHashAggregateExecTransformer
Input [1]: [buf#49]
Keys: []
Functions [1]: [velox_bloom_filter_agg(xxhash64(web_site_sk#27, 42), 4, 144, 0, 0)]
Aggregate Attributes [1]: [bloom_filter_agg(xxhash64(web_site_sk#27, 42), 4, 144, 0, 0)#50]
Results [1]: [bloom_filter_agg(xxhash64(web_site_sk#27, 42), 4, 144, 0, 0)#50 AS bloomFilter#51]

(97) WholeStageCodegenTransformer (4)
Input [1]: [bloomFilter#51]
Arguments: false

(98) VeloxColumnarToRow
Input [1]: [bloomFilter#51]

Subquery:3 Hosting operator id = 2 Hosting Expression = Subquery scalar-subquery#10, [id=#3]
VeloxColumnarToRow (110)
+- ^ RegularHashAggregateExecTransformer (108)
   +- ^ InputIteratorTransformer (107)
      +- ColumnarExchange (105)
         +- VeloxResizeBatches (104)
            +- ^ FlushableHashAggregateExecTransformer (102)
               +- ^ ProjectExecTransformer (101)
                  +- ^ FilterExecTransformer (100)
                     +- ^ FileSourceScanExecTransformer parquet spark_catalog.default.date_dim (99)


(99) FileSourceScanExecTransformer parquet spark_catalog.default.date_dim
Output [2]: [d_date_sk#29, d_date#30]
Batched: true
Location: InMemoryFileIndex [{warehouse_dir}/date_dim]
PushedFilters: [IsNotNull(d_date), GreaterThanOrEqual(d_date,1999-02-01), LessThanOrEqual(d_date,1999-04-02), IsNotNull(d_date_sk)]
ReadSchema: struct<d_date_sk:int,d_date:date>

(100) FilterExecTransformer
Input [2]: [d_date_sk#29, d_date#30]
Arguments: (((isnotnull(d_date#30) AND (d_date#30 >= 1999-02-01)) AND (d_date#30 <= 1999-04-02)) AND isnotnull(d_date_sk#29))

(101) ProjectExecTransformer
Output [1]: [xxhash64(d_date_sk#29, 42) AS _pre_5#52]
Input [2]: [d_date_sk#29, d_date#30]

(102) FlushableHashAggregateExecTransformer
Input [1]: [_pre_5#52]
Keys: []
Functions [1]: [partial_velox_bloom_filter_agg(_pre_5#52, 73049, 1141755, 0, 0)]
Aggregate Attributes [1]: [buf#53]
Results [1]: [buf#54]

(103) WholeStageCodegenTransformer (5)
Input [1]: [buf#54]
Arguments: false

(104) VeloxResizeBatches
Input [1]: [buf#54]
Arguments: 1024, 2147483647, 10485760

(105) ColumnarExchange
Input [1]: [buf#54]
Arguments: SinglePartition, ENSURE_REQUIREMENTS, [plan_id=12], [shuffle_writer_type=hash]

(106) InputAdapter
Input [1]: [buf#54]

(107) InputIteratorTransformer
Input [1]: [buf#54]

(108) RegularHashAggregateExecTransformer
Input [1]: [buf#54]
Keys: []
Functions [1]: [velox_bloom_filter_agg(xxhash64(d_date_sk#29, 42), 73049, 1141755, 0, 0)]
Aggregate Attributes [1]: [bloom_filter_agg(xxhash64(d_date_sk#29, 42), 73049, 1141755, 0, 0)#55]
Results [1]: [bloom_filter_agg(xxhash64(d_date_sk#29, 42), 73049, 1141755, 0, 0)#55 AS bloomFilter#56]

(109) WholeStageCodegenTransformer (6)
Input [1]: [bloomFilter#56]
Arguments: false

(110) VeloxColumnarToRow
Input [1]: [bloomFilter#56]

Subquery:4 Hosting operator id = 1 Hosting Expression = Subquery scalar-subquery#8, [id=#1]
VeloxColumnarToRow (86)
+- ^ RegularHashAggregateExecTransformer (84)
   +- ^ InputIteratorTransformer (83)
      +- ColumnarExchange (81)
         +- VeloxResizeBatches (80)
            +- ^ FlushableHashAggregateExecTransformer (78)
               +- ^ ProjectExecTransformer (77)
                  +- ^ FilterExecTransformer (76)
                     +- ^ FileSourceScanExecTransformer parquet spark_catalog.default.customer_address (75)


Subquery:5 Hosting operator id = 1 Hosting Expression = Subquery scalar-subquery#9, [id=#2]
VeloxColumnarToRow (98)
+- ^ RegularHashAggregateExecTransformer (96)
   +- ^ InputIteratorTransformer (95)
      +- ColumnarExchange (93)
         +- VeloxResizeBatches (92)
            +- ^ FlushableHashAggregateExecTransformer (90)
               +- ^ ProjectExecTransformer (89)
                  +- ^ FilterExecTransformer (88)
                     +- ^ FileSourceScanExecTransformer parquet spark_catalog.default.web_site (87)


Subquery:6 Hosting operator id = 1 Hosting Expression = Subquery scalar-subquery#10, [id=#3]
VeloxColumnarToRow (110)
+- ^ RegularHashAggregateExecTransformer (108)
   +- ^ InputIteratorTransformer (107)
      +- ColumnarExchange (105)
         +- VeloxResizeBatches (104)
            +- ^ FlushableHashAggregateExecTransformer (102)
               +- ^ ProjectExecTransformer (101)
                  +- ^ FilterExecTransformer (100)
                     +- ^ FileSourceScanExecTransformer parquet spark_catalog.default.date_dim (99)



