== Q1
Finalize GroupAggregate
  Group Key: l_returnflag, l_linestatus
  ->  Gather Merge
        Workers Planned: 8
        ->  Sort
              Sort Key: l_returnflag, l_linestatus
              ->  Partial HashAggregate
                    Group Key: l_returnflag, l_linestatus
                    ->  Parallel Seq Scan on lineitem
                          Filter: (l_shipdate <= '1998-09-02 00:00:00'::timestamp without time zone)
== Q2
Sort
  Sort Key: supplier.s_acctbal DESC, nation.n_name, supplier.s_name, part.p_partkey
  ->  Merge Join
        Merge Cond: (part.p_partkey = partsupp.ps_partkey)
        Join Filter: (partsupp.ps_supplycost = (SubPlan expr_1))
        ->  Gather Merge
              Workers Planned: 5
              ->  Parallel Index Scan using part_pk on part
                    Filter: (((p_type)::text ~~ '%BRASS'::text) AND (p_size = '15'::numeric))
        ->  Materialize
              ->  Sort
                    Sort Key: partsupp.ps_partkey
                    ->  Nested Loop
                          ->  Nested Loop
                                ->  Nested Loop
                                      Join Filter: (nation.n_regionkey = region.r_regionkey)
                                      ->  Index Scan using nation_pk on nation
                                      ->  Materialize
                                            ->  Seq Scan on region
                                                  Filter: (r_name = 'EUROPE'::bpchar)
                                ->  Index Scan using supplier_nation_fkidx on supplier
                                      Index Cond: (s_nationkey = nation.n_nationkey)
                          ->  Index Scan using partsupp_supplier_fkidx on partsupp
                                Index Cond: (ps_suppkey = supplier.s_suppkey)
        SubPlan expr_1
          ->  Aggregate
                ->  Nested Loop
                      Join Filter: (nation_1.n_regionkey = region_1.r_regionkey)
                      ->  Seq Scan on region region_1
                            Filter: (r_name = 'EUROPE'::bpchar)
                      ->  Hash Join
                            Hash Cond: (supplier_1.s_nationkey = nation_1.n_nationkey)
                            ->  Nested Loop
                                  ->  Index Scan using partsupp_part_fkidx on partsupp partsupp_1
                                        Index Cond: (ps_partkey = part.p_partkey)
                                  ->  Index Only Scan using supplier_norm on supplier supplier_1
                                        Index Cond: (s_suppkey = partsupp_1.ps_suppkey)
                            ->  Hash
                                  ->  Seq Scan on nation nation_1
== Q3
Sort
  Sort Key: (sum((lineitem.l_extendedprice * ('1'::numeric - lineitem.l_discount)))) DESC, orders.o_orderdate
  ->  GroupAggregate
        Group Key: lineitem.l_orderkey, orders.o_orderdate, orders.o_shippriority
        ->  Gather Merge
              Workers Planned: 8
              ->  Sort
                    Sort Key: lineitem.l_orderkey, orders.o_orderdate, orders.o_shippriority
                    ->  Parallel Hash Join
                          Hash Cond: (lineitem.l_orderkey = orders.o_orderkey)
                          ->  Parallel Seq Scan on lineitem
                                Filter: (l_shipdate > '1995-03-15'::date)
                          ->  Parallel Hash
                                ->  Nested Loop
                                      ->  Parallel Seq Scan on customer
                                            Filter: (c_mktsegment = 'BUILDING'::bpchar)
                                      ->  Index Scan using order_customer_fkidx on orders
                                            Index Cond: (o_custkey = customer.c_custkey)
                                            Filter: (o_orderdate < '1995-03-15'::date)
== Q4
Finalize GroupAggregate
  Group Key: orders.o_orderpriority
  ->  Gather Merge
        Workers Planned: 7
        ->  Partial GroupAggregate
              Group Key: orders.o_orderpriority
              ->  Sort
                    Sort Key: orders.o_orderpriority
                    ->  Nested Loop Semi Join
                          ->  Parallel Bitmap Heap Scan on orders
                                Recheck Cond: ((o_orderdate >= '1993-07-01'::date) AND (o_orderdate < '1993-10-01 00:00:00'::timestamp without time zone))
                                ->  Bitmap Index Scan on orders_date
                                      Index Cond: ((o_orderdate >= '1993-07-01'::date) AND (o_orderdate < '1993-10-01 00:00:00'::timestamp without time zone))
                          ->  Index Scan using idx_lineitem_orderkey_fkidx on lineitem
                                Index Cond: (l_orderkey = orders.o_orderkey)
                                Filter: (l_commitdate < l_receiptdate)
== Q5
Sort
  Sort Key: (sum((lineitem.l_extendedprice * ('1'::numeric - lineitem.l_discount)))) DESC
  ->  Finalize GroupAggregate
        Group Key: nation.n_name
        ->  Gather Merge
              Workers Planned: 5
              ->  Partial GroupAggregate
                    Group Key: nation.n_name
                    ->  Sort
                          Sort Key: nation.n_name
                          ->  Parallel Hash Join
                                Hash Cond: ((lineitem.l_suppkey = supplier.s_suppkey) AND (customer.c_nationkey = supplier.s_nationkey))
                                ->  Nested Loop
                                      ->  Nested Loop
                                            ->  Hash Join
                                                  Hash Cond: (customer.c_nationkey = nation.n_nationkey)
                                                  ->  Parallel Seq Scan on customer
                                                  ->  Hash
                                                        ->  Hash Join
                                                              Hash Cond: (nation.n_regionkey = region.r_regionkey)
                                                              ->  Seq Scan on nation
                                                              ->  Hash
                                                                    ->  Seq Scan on region
                                                                          Filter: (r_name = 'ASIA'::bpchar)
                                            ->  Index Scan using order_customer_fkidx on orders
                                                  Index Cond: (o_custkey = customer.c_custkey)
                                                  Filter: ((o_orderdate >= '1994-01-01'::date) AND (o_orderdate < '1995-01-01 00:00:00'::timestamp without time zone))
                                      ->  Index Scan using idx_lineitem_orderkey_fkidx on lineitem
                                            Index Cond: (l_orderkey = orders.o_orderkey)
                                ->  Parallel Hash
                                      ->  Parallel Index Only Scan using supplier_norm on supplier
== Q6
Finalize Aggregate
  ->  Gather
        Workers Planned: 8
        ->  Partial Aggregate
              ->  Parallel Seq Scan on lineitem
                    Filter: ((l_shipdate >= '1994-01-01'::date) AND (l_shipdate < '1995-01-01 00:00:00'::timestamp without time zone) AND (l_discount >= 0.05) AND (l_discount <= 0.07) AND (l_quantity < '24'::numeric))
== Q7
Finalize GroupAggregate
  Group Key: n1.n_name, n2.n_name, (EXTRACT(year FROM lineitem.l_shipdate))
  ->  Gather Merge
        Workers Planned: 8
        ->  Partial GroupAggregate
              Group Key: n1.n_name, n2.n_name, (EXTRACT(year FROM lineitem.l_shipdate))
              ->  Sort
                    Sort Key: n1.n_name, n2.n_name, (EXTRACT(year FROM lineitem.l_shipdate))
                    ->  Parallel Hash Join
                          Hash Cond: (lineitem.l_suppkey = supplier.s_suppkey)
                          Join Filter: (((n1.n_name = 'FRANCE'::bpchar) AND (n2.n_name = 'GERMANY'::bpchar)) OR ((n1.n_name = 'GERMANY'::bpchar) AND (n2.n_name = 'FRANCE'::bpchar)))
                          ->  Parallel Hash Join
                                Hash Cond: (lineitem.l_orderkey = orders.o_orderkey)
                                ->  Parallel Seq Scan on lineitem
                                      Filter: ((l_shipdate >= '1995-01-01'::date) AND (l_shipdate <= '1996-12-31'::date))
                                ->  Parallel Hash
                                      ->  Nested Loop
                                            ->  Hash Join
                                                  Hash Cond: (customer.c_nationkey = n2.n_nationkey)
                                                  ->  Parallel Seq Scan on customer
                                                  ->  Hash
                                                        ->  Seq Scan on nation n2
                                                              Filter: ((n_name = 'GERMANY'::bpchar) OR (n_name = 'FRANCE'::bpchar))
                                            ->  Index Scan using order_customer_fkidx on orders
                                                  Index Cond: (o_custkey = customer.c_custkey)
                          ->  Parallel Hash
                                ->  Hash Join
                                      Hash Cond: (supplier.s_nationkey = n1.n_nationkey)
                                      ->  Parallel Index Only Scan using supplier_norm on supplier
                                      ->  Hash
                                            ->  Seq Scan on nation n1
                                                  Filter: ((n_name = 'FRANCE'::bpchar) OR (n_name = 'GERMANY'::bpchar))
== Q8
Finalize GroupAggregate
  Group Key: (EXTRACT(year FROM orders.o_orderdate))
  ->  Gather Merge
        Workers Planned: 5
        ->  Partial GroupAggregate
              Group Key: (EXTRACT(year FROM orders.o_orderdate))
              ->  Sort
                    Sort Key: (EXTRACT(year FROM orders.o_orderdate))
                    ->  Hash Join
                          Hash Cond: (customer.c_nationkey = n1.n_nationkey)
                          ->  Hash Join
                                Hash Cond: (supplier.s_nationkey = n2.n_nationkey)
                                ->  Nested Loop
                                      ->  Nested Loop
                                            ->  Parallel Hash Join
                                                  Hash Cond: (lineitem.l_suppkey = supplier.s_suppkey)
                                                  ->  Nested Loop
                                                        ->  Parallel Seq Scan on part
                                                              Filter: ((p_type)::text = 'ECONOMY ANODIZED STEEL'::text)
                                                        ->  Index Scan using lineitem_part_supp_fkidx on lineitem
                                                              Index Cond: (l_partkey = part.p_partkey)
                                                  ->  Parallel Hash
                                                        ->  Parallel Index Only Scan using supplier_norm on supplier
                                            ->  Index Scan using orders_pk on orders
                                                  Index Cond: (o_orderkey = lineitem.l_orderkey)
                                                  Filter: ((o_orderdate >= '1995-01-01'::date) AND (o_orderdate <= '1996-12-31'::date))
                                      ->  Index Scan using customer_pk on customer
                                            Index Cond: (c_custkey = orders.o_custkey)
                                ->  Hash
                                      ->  Seq Scan on nation n2
                          ->  Hash
                                ->  Hash Join
                                      Hash Cond: (n1.n_regionkey = region.r_regionkey)
                                      ->  Seq Scan on nation n1
                                      ->  Hash
                                            ->  Seq Scan on region
                                                  Filter: (r_name = 'AMERICA'::bpchar)
== Q9
Finalize GroupAggregate
  Group Key: nation.n_name, (EXTRACT(year FROM orders.o_orderdate))
  ->  Gather Merge
        Workers Planned: 5
        ->  Sort
              Sort Key: nation.n_name, (EXTRACT(year FROM orders.o_orderdate)) DESC
              ->  Partial HashAggregate
                    Group Key: nation.n_name, EXTRACT(year FROM orders.o_orderdate)
                    ->  Nested Loop
                          ->  Nested Loop
                                Join Filter: (supplier.s_suppkey = lineitem.l_suppkey)
                                ->  Hash Join
                                      Hash Cond: (supplier.s_nationkey = nation.n_nationkey)
                                      ->  Parallel Hash Join
                                            Hash Cond: (partsupp.ps_suppkey = supplier.s_suppkey)
                                            ->  Nested Loop
                                                  ->  Parallel Seq Scan on part
                                                        Filter: ((p_name)::text ~~ '%green%'::text)
                                                  ->  Index Scan using partsupp_part_fkidx on partsupp
                                                        Index Cond: (ps_partkey = part.p_partkey)
                                            ->  Parallel Hash
                                                  ->  Parallel Index Only Scan using supplier_norm on supplier
                                      ->  Hash
                                            ->  Seq Scan on nation
                                ->  Index Scan using lineitem_part_supp_fkidx on lineitem
                                      Index Cond: ((l_partkey = partsupp.ps_partkey) AND (l_suppkey = partsupp.ps_suppkey))
                          ->  Memoize
                                Cache Key: lineitem.l_orderkey
                                Cache Mode: logical
                                ->  Index Scan using orders_pk on orders
                                      Index Cond: (o_orderkey = lineitem.l_orderkey)
== Q10
Sort
  Sort Key: (sum((lineitem.l_extendedprice * ('1'::numeric - lineitem.l_discount)))) DESC
  ->  GroupAggregate
        Group Key: customer.c_custkey, nation.n_name
        ->  Gather Merge
              Workers Planned: 7
              ->  Sort
                    Sort Key: customer.c_custkey, nation.n_name
                    ->  Hash Join
                          Hash Cond: (customer.c_nationkey = nation.n_nationkey)
                          ->  Nested Loop
                                ->  Nested Loop
                                      ->  Parallel Bitmap Heap Scan on orders
                                            Recheck Cond: ((o_orderdate >= '1993-10-01'::date) AND (o_orderdate < '1994-01-01 00:00:00'::timestamp without time zone))
                                            ->  Bitmap Index Scan on orders_date
                                                  Index Cond: ((o_orderdate >= '1993-10-01'::date) AND (o_orderdate < '1994-01-01 00:00:00'::timestamp without time zone))
                                      ->  Index Scan using idx_lineitem_orderkey_fkidx on lineitem
                                            Index Cond: (l_orderkey = orders.o_orderkey)
                                            Filter: (l_returnflag = 'R'::bpchar)
                                ->  Index Scan using customer_pk on customer
                                      Index Cond: (c_custkey = orders.o_custkey)
                          ->  Hash
                                ->  Seq Scan on nation
== Q11
Sort
  Sort Key: (sum((partsupp.ps_supplycost * partsupp.ps_availqty))) DESC
  InitPlan expr_1
    ->  Finalize Aggregate
          ->  Gather
                Workers Planned: 4
                ->  Partial Aggregate
                      ->  Nested Loop
                            ->  Hash Join
                                  Hash Cond: (supplier_1.s_nationkey = nation_1.n_nationkey)
                                  ->  Parallel Index Only Scan using supplier_norm on supplier supplier_1
                                  ->  Hash
                                        ->  Seq Scan on nation nation_1
                                              Filter: (n_name = 'GERMANY'::bpchar)
                            ->  Index Scan using partsupp_supplier_fkidx on partsupp partsupp_1
                                  Index Cond: (ps_suppkey = supplier_1.s_suppkey)
  ->  HashAggregate
        Group Key: partsupp.ps_partkey
        Filter: (sum((partsupp.ps_supplycost * partsupp.ps_availqty)) > (InitPlan expr_1).col1)
        ->  Nested Loop
              ->  Nested Loop
                    ->  Seq Scan on nation
                          Filter: (n_name = 'GERMANY'::bpchar)
                    ->  Bitmap Heap Scan on supplier
                          Recheck Cond: (s_nationkey = nation.n_nationkey)
                          ->  Bitmap Index Scan on supplier_nation_fkidx
                                Index Cond: (s_nationkey = nation.n_nationkey)
              ->  Index Scan using partsupp_supplier_fkidx on partsupp
                    Index Cond: (ps_suppkey = supplier.s_suppkey)
== Q12
Finalize GroupAggregate
  Group Key: lineitem.l_shipmode
  ->  Gather Merge
        Workers Planned: 8
        ->  Partial GroupAggregate
              Group Key: lineitem.l_shipmode
              ->  Sort
                    Sort Key: lineitem.l_shipmode
                    ->  Nested Loop
                          ->  Parallel Seq Scan on lineitem
                                Filter: ((l_shipmode = ANY ('{MAIL,SHIP}'::bpchar[])) AND (l_commitdate < l_receiptdate) AND (l_shipdate < l_commitdate) AND (l_receiptdate >= '1994-01-01'::date) AND (l_receiptdate < '1995-01-01 00:00:00'::timestamp without time zone))
                          ->  Index Scan using orders_pk on orders
                                Index Cond: (o_orderkey = lineitem.l_orderkey)
== Q13
Sort
  Sort Key: (count(*)) DESC, (count(orders.o_orderkey)) DESC
  ->  HashAggregate
        Group Key: count(orders.o_orderkey)
        ->  GroupAggregate
              Group Key: customer.c_custkey
              ->  Merge Left Join
                    Merge Cond: (customer.c_custkey = orders.o_custkey)
                    ->  Index Only Scan using customer_pk on customer
                    ->  Index Scan using order_customer_fkidx on orders
                          Filter: ((o_comment)::text !~~ '%special%requests%'::text)
== Q14
Finalize Aggregate
  ->  Gather
        Workers Planned: 5
        ->  Partial Aggregate
              ->  Nested Loop
                    ->  Parallel Seq Scan on part
                    ->  Index Scan using lineitem_part_supp_fkidx on lineitem
                          Index Cond: (l_partkey = part.p_partkey)
                          Filter: ((l_shipdate >= '1995-09-01'::date) AND (l_shipdate < '1995-10-01 00:00:00'::timestamp without time zone))
== Q15
Sort
  Sort Key: supplier.s_suppkey
  CTE revenue0
    ->  Finalize HashAggregate
          Group Key: lineitem.l_suppkey
          ->  Gather
                Workers Planned: 8
                ->  Partial HashAggregate
                      Group Key: lineitem.l_suppkey
                      ->  Parallel Seq Scan on lineitem
                            Filter: ((l_shipdate >= to_date('1996-01-01'::text, 'YYYY-MM-DD'::text)) AND (l_shipdate < (to_date('1996-01-01'::text, 'YYYY-MM-DD'::text) + '3 mons'::interval)))
  InitPlan expr_1
    ->  Aggregate
          ->  CTE Scan on revenue0 revenue0_1
  ->  Nested Loop
        ->  CTE Scan on revenue0
              Filter: (total_revenue = (InitPlan expr_1).col1)
        ->  Index Scan using supplier_pk on supplier
              Index Cond: (s_suppkey = revenue0.supplier_no)
== Q16
Sort
  Sort Key: (count(DISTINCT partsupp.ps_suppkey)) DESC, part.p_brand, part.p_type, part.p_size
  ->  GroupAggregate
        Group Key: part.p_brand, part.p_type, part.p_size
        ->  Gather Merge
              Workers Planned: 7
              ->  Sort
                    Sort Key: part.p_brand, part.p_type, part.p_size, partsupp.ps_suppkey
                    ->  Parallel Hash Anti Join
                          Hash Cond: (partsupp.ps_suppkey = supplier.s_suppkey)
                          ->  Parallel Hash Join
                                Hash Cond: (partsupp.ps_partkey = part.p_partkey)
                                ->  Parallel Index Only Scan using partsupp_pk on partsupp
                                ->  Parallel Hash
                                      ->  Parallel Seq Scan on part
                                            Filter: ((p_brand <> 'Brand#45'::bpchar) AND ((p_type)::text !~~ 'MEDIUM POLISHED%'::text) AND (p_size = ANY ('{49,14,23,45,19,3,36,9}'::numeric[])))
                          ->  Parallel Hash
                                ->  Parallel Seq Scan on supplier
                                      Filter: ((s_comment)::text ~~ '%Customer%Complaints%'::text)
== Q17
Aggregate
  ->  Hash Join
        Hash Cond: (lineitem.l_partkey = part.p_partkey)
        Join Filter: (lineitem.l_quantity < (SubPlan expr_1))
        ->  Seq Scan on lineitem
        ->  Hash
              ->  Gather
                    Workers Planned: 5
                    ->  Parallel Seq Scan on part
                          Filter: ((p_brand = 'Brand#23'::bpchar) AND (p_container = 'MED BOX'::bpchar))
        SubPlan expr_1
          ->  Aggregate
                ->  Index Scan using lineitem_part_supp_fkidx on lineitem lineitem_1
                      Index Cond: (l_partkey = part.p_partkey)
== Q18
Sort
  Sort Key: orders.o_totalprice DESC, orders.o_orderdate
  ->  GroupAggregate
        Group Key: customer.c_custkey, orders.o_orderkey
        ->  Sort
              Sort Key: customer.c_custkey, orders.o_orderkey
              ->  Nested Loop
                    ->  Nested Loop
                          ->  Nested Loop
                                ->  Finalize HashAggregate
                                      Group Key: lineitem_1.l_orderkey
                                      Filter: (sum(lineitem_1.l_quantity) > '300'::numeric)
                                      ->  Gather
                                            Workers Planned: 8
                                            ->  Partial HashAggregate
                                                  Group Key: lineitem_1.l_orderkey
                                                  ->  Parallel Seq Scan on lineitem lineitem_1
                                ->  Index Scan using orders_pk on orders
                                      Index Cond: (o_orderkey = lineitem_1.l_orderkey)
                          ->  Index Scan using customer_pk on customer
                                Index Cond: (c_custkey = orders.o_custkey)
                    ->  Index Scan using idx_lineitem_orderkey_fkidx on lineitem
                          Index Cond: (l_orderkey = orders.o_orderkey)
== Q19
Finalize Aggregate
  ->  Gather
        Workers Planned: 5
        ->  Partial Aggregate
              ->  Nested Loop
                    ->  Parallel Seq Scan on part
                          Filter: ((p_size >= '1'::numeric) AND (((p_brand = 'Brand#12'::bpchar) AND (p_container = ANY ('{"SM CASE","SM BOX","SM PACK","SM PKG"}'::bpchar[])) AND (p_size <= '5'::numeric)) OR ((p_brand = 'Brand#23'::bpchar) AND (p_container = ANY ('{"MED BAG","MED BOX","MED PKG","MED PACK"}'::bpchar[])) AND (p_size <= '10'::numeric)) OR ((p_brand = 'Brand#34'::bpchar) AND (p_container = ANY ('{"LG CASE","LG BOX","LG PACK","LG PKG"}'::bpchar[])) AND (p_size <= '15'::numeric))))
                    ->  Index Scan using lineitem_part_supp_fkidx on lineitem
                          Index Cond: (l_partkey = part.p_partkey)
                          Filter: ((l_shipmode = ANY ('{AIR,"AIR REG"}'::bpchar[])) AND (l_shipinstruct = 'DELIVER IN PERSON'::bpchar) AND (((l_quantity >= '1'::numeric) AND (l_quantity <= '11'::numeric)) OR ((l_quantity >= '10'::numeric) AND (l_quantity <= '20'::numeric)) OR ((l_quantity >= '20'::numeric) AND (l_quantity <= '30'::numeric))) AND (((part.p_brand = 'Brand#12'::bpchar) AND (part.p_container = ANY ('{"SM CASE","SM BOX","SM PACK","SM PKG"}'::bpchar[])) AND (l_quantity >= '1'::numeric) AND (l_quantity <= '11'::numeric) AND (part.p_size <= '5'::numeric)) OR ((part.p_brand = 'Brand#23'::bpchar) AND (part.p_container = ANY ('{"MED BAG","MED BOX","MED PKG","MED PACK"}'::bpchar[])) AND (l_quantity >= '10'::numeric) AND (l_quantity <= '20'::numeric) AND (part.p_size <= '10'::numeric)) OR ((part.p_brand = 'Brand#34'::bpchar) AND (part.p_container = ANY ('{"LG CASE","LG BOX","LG PACK","LG PKG"}'::bpchar[])) AND (l_quantity >= '20'::numeric) AND (l_quantity <= '30'::numeric) AND (part.p_size <= '15'::numeric))))
== Q20
Nested Loop Semi Join
  ->  Gather Merge
        Workers Planned: 2
        ->  Sort
              Sort Key: supplier.s_name
              ->  Hash Join
                    Hash Cond: (supplier.s_nationkey = nation.n_nationkey)
                    ->  Parallel Seq Scan on supplier
                    ->  Hash
                          ->  Seq Scan on nation
                                Filter: (n_name = 'CANADA'::bpchar)
  ->  Nested Loop
        ->  Index Scan using partsupp_supplier_fkidx on partsupp
              Index Cond: (ps_suppkey = supplier.s_suppkey)
              Filter: (ps_availqty > (SubPlan expr_1))
              SubPlan expr_1
                ->  Aggregate
                      ->  Index Scan using lineitem_part_supp_fkidx on lineitem
                            Index Cond: ((l_partkey = partsupp.ps_partkey) AND (l_suppkey = partsupp.ps_suppkey))
                            Filter: ((l_shipdate >= '1994-01-01'::date) AND (l_shipdate < '1995-01-01 00:00:00'::timestamp without time zone))
        ->  Index Scan using part_pk on part
              Index Cond: (p_partkey = partsupp.ps_partkey)
              Filter: ((p_name)::text ~~ 'forest%'::text)
== Q21
Sort
  Sort Key: (count(*)) DESC, supplier.s_name
  ->  GroupAggregate
        Group Key: supplier.s_name
        ->  Sort
              Sort Key: supplier.s_name
              ->  Nested Loop
                    ->  Nested Loop Semi Join
                          ->  Gather
                                Workers Planned: 8
                                ->  Nested Loop Anti Join
                                      ->  Hash Join
                                            Hash Cond: (l1.l_suppkey = supplier.s_suppkey)
                                            ->  Parallel Seq Scan on lineitem l1
                                                  Filter: (l_receiptdate > l_commitdate)
                                            ->  Hash
                                                  ->  Nested Loop
                                                        ->  Seq Scan on nation
                                                              Filter: (n_name = 'SAUDI ARABIA'::bpchar)
                                                        ->  Bitmap Heap Scan on supplier
                                                              Recheck Cond: (s_nationkey = nation.n_nationkey)
                                                              ->  Bitmap Index Scan on supplier_nation_fkidx
                                                                    Index Cond: (s_nationkey = nation.n_nationkey)
                                      ->  Index Scan using idx_lineitem_orderkey_fkidx on lineitem l3
                                            Index Cond: (l_orderkey = l1.l_orderkey)
                                            Filter: ((l_receiptdate > l_commitdate) AND (l_suppkey <> l1.l_suppkey))
                          ->  Index Scan using idx_lineitem_orderkey_fkidx on lineitem l2
                                Index Cond: (l_orderkey = l1.l_orderkey)
                                Filter: (l_suppkey <> l1.l_suppkey)
                    ->  Index Scan using orders_pk on orders
                          Index Cond: (o_orderkey = l1.l_orderkey)
                          Filter: (o_orderstatus = 'F'::bpchar)
== Q22
Finalize GroupAggregate
  Group Key: (substr((customer.c_phone)::text, 1, 2))
  InitPlan expr_1
    ->  Finalize Aggregate
          ->  Gather
                Workers Planned: 5
                ->  Partial Aggregate
                      ->  Parallel Seq Scan on customer customer_1
                            Filter: ((c_acctbal > 0.00) AND (substr((c_phone)::text, 1, 2) = ANY ('{13,31,23,29,30,18,17}'::text[])))
  ->  Gather Merge
        Workers Planned: 5
        ->  Partial GroupAggregate
              Group Key: (substr((customer.c_phone)::text, 1, 2))
              ->  Sort
                    Sort Key: (substr((customer.c_phone)::text, 1, 2))
                    ->  Nested Loop Anti Join
                          ->  Parallel Seq Scan on customer
                                Filter: ((c_acctbal > (InitPlan expr_1).col1) AND (substr((c_phone)::text, 1, 2) = ANY ('{13,31,23,29,30,18,17}'::text[])))
                          ->  Index Only Scan using order_customer_fkidx on orders
                                Index Cond: (o_custkey = customer.c_custkey)
