CREATE DATABASE IF NOT EXISTS TPCH; USE TPCH; CREATE TABLE IF NOT EXISTS nation ( N_NATIONKEY INTEGER NOT NULL, N_NAME CHAR(25) NOT NULL, N_REGIONKEY INTEGER NOT NULL, N_COMMENT VARCHAR(152), PRIMARY KEY (N_NATIONKEY)); CREATE TABLE IF NOT EXISTS region ( R_REGIONKEY INTEGER NOT NULL, R_NAME CHAR(25) NOT NULL, R_COMMENT VARCHAR(152), PRIMARY KEY (R_REGIONKEY)); CREATE TABLE IF NOT EXISTS part ( P_PARTKEY INTEGER NOT NULL, P_NAME VARCHAR(55) NOT NULL, P_MFGR CHAR(25) NOT NULL, P_BRAND CHAR(10) NOT NULL, P_TYPE VARCHAR(25) NOT NULL, P_SIZE INTEGER NOT NULL, P_CONTAINER CHAR(10) NOT NULL, P_RETAILPRICE DECIMAL(15,2) NOT NULL, P_COMMENT VARCHAR(23) NOT NULL, PRIMARY KEY (P_PARTKEY)); CREATE TABLE IF NOT EXISTS supplier ( S_SUPPKEY INTEGER NOT NULL, S_NAME CHAR(25) NOT NULL, S_ADDRESS VARCHAR(40) NOT NULL, S_NATIONKEY INTEGER NOT NULL, S_PHONE CHAR(15) NOT NULL, S_ACCTBAL DECIMAL(15,2) NOT NULL, S_COMMENT VARCHAR(101) NOT NULL, PRIMARY KEY (S_SUPPKEY), CONSTRAINT FOREIGN KEY SUPPLIER_FK1 (S_NATIONKEY) references nation(N_NATIONKEY)); CREATE TABLE IF NOT EXISTS partsupp ( PS_PARTKEY INTEGER NOT NULL, PS_SUPPKEY INTEGER NOT NULL, PS_AVAILQTY INTEGER NOT NULL, PS_SUPPLYCOST DECIMAL(15,2) NOT NULL, PS_COMMENT VARCHAR(199) NOT NULL, PRIMARY KEY (PS_PARTKEY,PS_SUPPKEY), CONSTRAINT FOREIGN KEY PARTSUPP_FK1 (PS_SUPPKEY) references supplier(S_SUPPKEY), CONSTRAINT FOREIGN KEY PARTSUPP_FK2 (PS_PARTKEY) references part(P_PARTKEY)); CREATE TABLE IF NOT EXISTS customer ( C_CUSTKEY INTEGER NOT NULL, C_NAME VARCHAR(25) NOT NULL, C_ADDRESS VARCHAR(40) NOT NULL, C_NATIONKEY INTEGER NOT NULL, C_PHONE CHAR(15) NOT NULL, C_ACCTBAL DECIMAL(15,2) NOT NULL, C_MKTSEGMENT CHAR(10) NOT NULL, C_COMMENT VARCHAR(117) NOT NULL, PRIMARY KEY (C_CUSTKEY), CONSTRAINT FOREIGN KEY CUSTOMER_FK1 (C_NATIONKEY) references nation(N_NATIONKEY)); CREATE TABLE IF NOT EXISTS orders ( O_ORDERKEY INTEGER NOT NULL, O_CUSTKEY INTEGER NOT NULL, O_ORDERSTATUS CHAR(1) NOT NULL, O_TOTALPRICE DECIMAL(15,2) NOT NULL, O_ORDERDATE DATE NOT NULL, O_ORDERPRIORITY CHAR(15) NOT NULL, O_CLERK CHAR(15) NOT NULL, O_SHIPPRIORITY INTEGER NOT NULL, O_COMMENT VARCHAR(79) NOT NULL, PRIMARY KEY (O_ORDERKEY), CONSTRAINT FOREIGN KEY ORDERS_FK1 (O_CUSTKEY) references customer(C_CUSTKEY)); CREATE TABLE IF NOT EXISTS lineitem ( L_ORDERKEY INTEGER NOT NULL, L_PARTKEY INTEGER NOT NULL, L_SUPPKEY INTEGER NOT NULL, L_LINENUMBER INTEGER NOT NULL, L_QUANTITY DECIMAL(15,2) NOT NULL, L_EXTENDEDPRICE DECIMAL(15,2) NOT NULL, L_DISCOUNT DECIMAL(15,2) NOT NULL, L_TAX DECIMAL(15,2) NOT NULL, L_RETURNFLAG CHAR(1) NOT NULL, L_LINESTATUS CHAR(1) NOT NULL, L_SHIPDATE DATE NOT NULL, L_COMMITDATE DATE NOT NULL, L_RECEIPTDATE DATE NOT NULL, L_SHIPINSTRUCT CHAR(25) NOT NULL, L_SHIPMODE CHAR(10) NOT NULL, L_COMMENT VARCHAR(44) NOT NULL, PRIMARY KEY (L_ORDERKEY,L_LINENUMBER), CONSTRAINT FOREIGN KEY LINEITEM_FK1 (L_ORDERKEY) references orders(O_ORDERKEY), CONSTRAINT FOREIGN KEY LINEITEM_FK2 (L_PARTKEY,L_SUPPKEY) references partsupp(PS_PARTKEY, PS_SUPPKEY)); load stats 's/tpch_stats/nation.json'; load stats 's/tpch_stats/region.json'; load stats 's/tpch_stats/part.json'; load stats 's/tpch_stats/supplier.json'; load stats 's/tpch_stats/partsupp.json'; load stats 's/tpch_stats/customer.json'; load stats 's/tpch_stats/orders.json'; load stats 's/tpch_stats/lineitem.json'; set @@session.tidb_opt_agg_push_down = 0; /* Q1 Pricing Summary Report This query reports the amount of business that was billed, shipped, and returned. The Pricing Summary Report Query provides a summary pricing report for all lineitems shipped as of a given date. The date is within 60 - 120 days of the greatest ship date contained in the database. The query lists totals for extended price, discounted extended price, discounted extended price plus tax, average quantity, average extended price, and average discount. These aggregates are grouped by RETURNFLAG and LINESTATUS, and listed in ascending order of RETURNFLAG and LINESTATUS. A count of the number of lineitems in each group is included. Planner enhancement: none. */ explain select l_returnflag, l_linestatus, sum(l_quantity) as sum_qty, sum(l_extendedprice) as sum_base_price, sum(l_extendedprice * (1 - l_discount)) as sum_disc_price, sum(l_extendedprice * (1 - l_discount) * (1 + l_tax)) as sum_charge, avg(l_quantity) as avg_qty, avg(l_extendedprice) as avg_price, avg(l_discount) as avg_disc, count(*) as count_order from lineitem where l_shipdate <= date_sub('1998-12-01', interval 108 day) group by l_returnflag, l_linestatus order by l_returnflag, l_linestatus; id estRows task access object operator info Sort_6 2.94 root tpch.lineitem.l_returnflag:asc, tpch.lineitem.l_linestatus:asc └─Projection_8 2.94 root tpch.lineitem.l_returnflag, tpch.lineitem.l_linestatus, Column#18, Column#19, Column#20, Column#21, Column#22, Column#23, Column#24, Column#25 └─HashAgg_14 2.94 root group by:tpch.lineitem.l_linestatus, tpch.lineitem.l_returnflag, funcs:sum(Column#26)->Column#18, funcs:sum(Column#27)->Column#19, funcs:sum(Column#28)->Column#20, funcs:sum(Column#29)->Column#21, funcs:avg(Column#30, Column#31)->Column#22, funcs:avg(Column#32, Column#33)->Column#23, funcs:avg(Column#34, Column#35)->Column#24, funcs:count(Column#36)->Column#25, funcs:firstrow(tpch.lineitem.l_returnflag)->tpch.lineitem.l_returnflag, funcs:firstrow(tpch.lineitem.l_linestatus)->tpch.lineitem.l_linestatus └─TableReader_15 2.94 root data:HashAgg_9 └─HashAgg_9 2.94 cop[tikv] group by:tpch.lineitem.l_linestatus, tpch.lineitem.l_returnflag, funcs:sum(tpch.lineitem.l_quantity)->Column#26, funcs:sum(tpch.lineitem.l_extendedprice)->Column#27, funcs:sum(mul(tpch.lineitem.l_extendedprice, minus(1, tpch.lineitem.l_discount)))->Column#28, funcs:sum(mul(mul(tpch.lineitem.l_extendedprice, minus(1, tpch.lineitem.l_discount)), plus(1, tpch.lineitem.l_tax)))->Column#29, funcs:count(tpch.lineitem.l_quantity)->Column#30, funcs:sum(tpch.lineitem.l_quantity)->Column#31, funcs:count(tpch.lineitem.l_extendedprice)->Column#32, funcs:sum(tpch.lineitem.l_extendedprice)->Column#33, funcs:count(tpch.lineitem.l_discount)->Column#34, funcs:sum(tpch.lineitem.l_discount)->Column#35, funcs:count(1)->Column#36 └─Selection_13 293795345.00 cop[tikv] le(tpch.lineitem.l_shipdate, 1998-08-15) └─TableFullScan_12 300005811.00 cop[tikv] table:lineitem keep order:false /* Q2 Minimum Cost Supplier Query This query finds which supplier should be selected to place an order for a given part in a given region. The Minimum Cost Supplier Query finds, in a given region, for each part of a certain type and size, the supplier who can supply it at minimum cost. If several suppliers in that region offer the desired part type and size at the same (minimum) cost, the query lists the parts from suppliers with the 100 highest account balances. For each supplier, the query lists the supplier's account balance, name and nation; the part's number and manufacturer; the supplier's address, phone number and comment information. Planner enhancement: join reorder. */ explain select s_acctbal, s_name, n_name, p_partkey, p_mfgr, s_address, s_phone, s_comment from part, supplier, partsupp, nation, region where p_partkey = ps_partkey and s_suppkey = ps_suppkey and p_size = 30 and p_type like '%STEEL' and s_nationkey = n_nationkey and n_regionkey = r_regionkey and r_name = 'ASIA' and ps_supplycost = ( select min(ps_supplycost) from partsupp, supplier, nation, region where p_partkey = ps_partkey and s_suppkey = ps_suppkey and s_nationkey = n_nationkey and n_regionkey = r_regionkey and r_name = 'ASIA' ) order by s_acctbal desc, n_name, s_name, p_partkey limit 100; id estRows task access object operator info Projection_37 100.00 root tpch.supplier.s_acctbal, tpch.supplier.s_name, tpch.nation.n_name, tpch.part.p_partkey, tpch.part.p_mfgr, tpch.supplier.s_address, tpch.supplier.s_phone, tpch.supplier.s_comment └─TopN_40 100.00 root tpch.supplier.s_acctbal:desc, tpch.nation.n_name:asc, tpch.supplier.s_name:asc, tpch.part.p_partkey:asc, offset:0, count:100 └─HashJoin_45 155496.00 root inner join, equal:[eq(tpch.part.p_partkey, tpch.partsupp.ps_partkey) eq(tpch.partsupp.ps_supplycost, Column#50)] ├─HashJoin_53(Build) 155496.00 root inner join, equal:[eq(tpch.partsupp.ps_partkey, tpch.part.p_partkey)] │ ├─TableReader_78(Build) 155496.00 root data:Selection_77 │ │ └─Selection_77 155496.00 cop[tikv] eq(tpch.part.p_size, 30), like(tpch.part.p_type, "%STEEL", 92) │ │ └─TableFullScan_76 10000000.00 cop[tikv] table:part keep order:false │ └─HashJoin_56(Probe) 8155010.44 root inner join, equal:[eq(tpch.supplier.s_suppkey, tpch.partsupp.ps_suppkey)] │ ├─HashJoin_58(Build) 100000.00 root inner join, equal:[eq(tpch.nation.n_nationkey, tpch.supplier.s_nationkey)] │ │ ├─HashJoin_66(Build) 5.00 root inner join, equal:[eq(tpch.region.r_regionkey, tpch.nation.n_regionkey)] │ │ │ ├─TableReader_71(Build) 1.00 root data:Selection_70 │ │ │ │ └─Selection_70 1.00 cop[tikv] eq(tpch.region.r_name, "ASIA") │ │ │ │ └─TableFullScan_69 5.00 cop[tikv] table:region keep order:false │ │ │ └─TableReader_68(Probe) 25.00 root data:TableFullScan_67 │ │ │ └─TableFullScan_67 25.00 cop[tikv] table:nation keep order:false │ │ └─TableReader_73(Probe) 500000.00 root data:TableFullScan_72 │ │ └─TableFullScan_72 500000.00 cop[tikv] table:supplier keep order:false │ └─TableReader_75(Probe) 40000000.00 root data:TableFullScan_74 │ └─TableFullScan_74 40000000.00 cop[tikv] table:partsupp keep order:false └─Selection_79(Probe) 6524008.35 root not(isnull(Column#50)) └─HashAgg_82 8155010.44 root group by:tpch.partsupp.ps_partkey, funcs:min(tpch.partsupp.ps_supplycost)->Column#50, funcs:firstrow(tpch.partsupp.ps_partkey)->tpch.partsupp.ps_partkey └─HashJoin_86 8155010.44 root inner join, equal:[eq(tpch.supplier.s_suppkey, tpch.partsupp.ps_suppkey)] ├─HashJoin_88(Build) 100000.00 root inner join, equal:[eq(tpch.nation.n_nationkey, tpch.supplier.s_nationkey)] │ ├─HashJoin_96(Build) 5.00 root inner join, equal:[eq(tpch.region.r_regionkey, tpch.nation.n_regionkey)] │ │ ├─TableReader_101(Build) 1.00 root data:Selection_100 │ │ │ └─Selection_100 1.00 cop[tikv] eq(tpch.region.r_name, "ASIA") │ │ │ └─TableFullScan_99 5.00 cop[tikv] table:region keep order:false │ │ └─TableReader_98(Probe) 25.00 root data:TableFullScan_97 │ │ └─TableFullScan_97 25.00 cop[tikv] table:nation keep order:false │ └─TableReader_103(Probe) 500000.00 root data:TableFullScan_102 │ └─TableFullScan_102 500000.00 cop[tikv] table:supplier keep order:false └─TableReader_105(Probe) 40000000.00 root data:TableFullScan_104 └─TableFullScan_104 40000000.00 cop[tikv] table:partsupp keep order:false /* Q3 Shipping Priority Query This query retrieves the 10 unshipped orders with the highest value. The Shipping Priority Query retrieves the shipping priority and potential revenue, defined as the sum of l_extendedprice * (1-l_discount), of the orders having the largest revenue among those that had not been shipped as of a given date. Orders are listed in decreasing order of revenue. If more than 10 unshipped orders exist, only the 10 orders with the largest revenue are listed. planner enhancement: if group-by item have primary key, non-priamry key is useless. */ explain select l_orderkey, sum(l_extendedprice * (1 - l_discount)) as revenue, o_orderdate, o_shippriority from customer, orders, lineitem where c_mktsegment = 'AUTOMOBILE' and c_custkey = o_custkey and l_orderkey = o_orderkey and o_orderdate < '1995-03-13' and l_shipdate > '1995-03-13' group by l_orderkey, o_orderdate, o_shippriority order by revenue desc, o_orderdate limit 10; id estRows task access object operator info Projection_14 10.00 root tpch.lineitem.l_orderkey, Column#35, tpch.orders.o_orderdate, tpch.orders.o_shippriority └─TopN_17 10.00 root Column#35:desc, tpch.orders.o_orderdate:asc, offset:0, count:10 └─HashAgg_23 40252367.98 root group by:Column#45, Column#46, Column#47, funcs:sum(Column#41)->Column#35, funcs:firstrow(Column#42)->tpch.orders.o_orderdate, funcs:firstrow(Column#43)->tpch.orders.o_shippriority, funcs:firstrow(Column#44)->tpch.lineitem.l_orderkey └─Projection_65 91515927.49 root mul(tpch.lineitem.l_extendedprice, minus(1, tpch.lineitem.l_discount))->Column#41, tpch.orders.o_orderdate, tpch.orders.o_shippriority, tpch.lineitem.l_orderkey, tpch.lineitem.l_orderkey, tpch.orders.o_orderdate, tpch.orders.o_shippriority └─HashJoin_33 91515927.49 root inner join, equal:[eq(tpch.orders.o_orderkey, tpch.lineitem.l_orderkey)] ├─HashJoin_55(Build) 22592975.51 root inner join, equal:[eq(tpch.customer.c_custkey, tpch.orders.o_custkey)] │ ├─TableReader_61(Build) 1498236.00 root data:Selection_60 │ │ └─Selection_60 1498236.00 cop[tikv] eq(tpch.customer.c_mktsegment, "AUTOMOBILE") │ │ └─TableFullScan_59 7500000.00 cop[tikv] table:customer keep order:false │ └─TableReader_58(Probe) 36870000.00 root data:Selection_57 │ └─Selection_57 36870000.00 cop[tikv] lt(tpch.orders.o_orderdate, 1995-03-13 00:00:00.000000) │ └─TableFullScan_56 75000000.00 cop[tikv] table:orders keep order:false └─TableReader_64(Probe) 163047704.27 root data:Selection_63 └─Selection_63 163047704.27 cop[tikv] gt(tpch.lineitem.l_shipdate, 1995-03-13 00:00:00.000000) └─TableFullScan_62 300005811.00 cop[tikv] table:lineitem keep order:false /* Q4 Order Priority Checking Query This query determines how well the order priority system is working and gives an assessment of customer satisfaction. The Order Priority Checking Query counts the number of orders ordered in a given quarter of a given year in which at least one lineitem was received by the customer later than its committed date. The query lists the count of such orders for each order priority sorted in ascending priority order. */ explain select o_orderpriority, count(*) as order_count from orders where o_orderdate >= '1995-01-01' and o_orderdate < date_add('1995-01-01', interval '3' month) and exists ( select * from lineitem where l_orderkey = o_orderkey and l_commitdate < l_receiptdate ) group by o_orderpriority order by o_orderpriority; id estRows task access object operator info Sort_10 1.00 root tpch.orders.o_orderpriority:asc └─Projection_12 1.00 root tpch.orders.o_orderpriority, Column#27 └─HashAgg_15 1.00 root group by:tpch.orders.o_orderpriority, funcs:count(1)->Column#27, funcs:firstrow(tpch.orders.o_orderpriority)->tpch.orders.o_orderpriority └─IndexHashJoin_23 2340750.00 root semi join, inner:IndexLookUp_20, outer key:tpch.orders.o_orderkey, inner key:tpch.lineitem.l_orderkey, equal cond:eq(tpch.orders.o_orderkey, tpch.lineitem.l_orderkey) ├─TableReader_35(Build) 2925937.50 root data:Selection_34 │ └─Selection_34 2925937.50 cop[tikv] ge(tpch.orders.o_orderdate, 1995-01-01 00:00:00.000000), lt(tpch.orders.o_orderdate, 1995-04-01) │ └─TableFullScan_33 75000000.00 cop[tikv] table:orders keep order:false └─IndexLookUp_20(Probe) 4.05 root ├─IndexRangeScan_17(Build) 5.06 cop[tikv] table:lineitem, index:PRIMARY(L_ORDERKEY, L_LINENUMBER) range: decided by [eq(tpch.lineitem.l_orderkey, tpch.orders.o_orderkey)], keep order:false └─Selection_19(Probe) 4.05 cop[tikv] lt(tpch.lineitem.l_commitdate, tpch.lineitem.l_receiptdate) └─TableRowIDScan_18 5.06 cop[tikv] table:lineitem keep order:false /* Q5 Local Supplier Volume Query This query lists the revenue volume done through local suppliers. The Local Supplier Volume Query lists for each nation in a region the revenue volume that resulted from lineitem transactions in which the customer ordering parts and the supplier filling them were both within that nation. The query is run in order to determine whether to institute local distribution centers in a given region. The query considers only parts ordered in a given year. The query displays the nations and revenue volume in descending order by revenue. Revenue volume for all qualifying lineitems in a particular nation is defined as sum(l_extendedprice * (1 - l_discount)). Planner enhancement: join reorder. */ explain select n_name, sum(l_extendedprice * (1 - l_discount)) as revenue from customer, orders, lineitem, supplier, nation, region where c_custkey = o_custkey and l_orderkey = o_orderkey and l_suppkey = s_suppkey and c_nationkey = s_nationkey and s_nationkey = n_nationkey and n_regionkey = r_regionkey and r_name = 'MIDDLE EAST' and o_orderdate >= '1994-01-01' and o_orderdate < date_add('1994-01-01', interval '1' year) group by n_name order by revenue desc; id estRows task access object operator info Sort_23 5.00 root Column#49:desc └─Projection_25 5.00 root tpch.nation.n_name, Column#49 └─HashAgg_28 5.00 root group by:Column#52, funcs:sum(Column#50)->Column#49, funcs:firstrow(Column#51)->tpch.nation.n_name └─Projection_72 11822812.50 root mul(tpch.lineitem.l_extendedprice, minus(1, tpch.lineitem.l_discount))->Column#50, tpch.nation.n_name, tpch.nation.n_name └─HashJoin_34 11822812.50 root inner join, equal:[eq(tpch.supplier.s_nationkey, tpch.customer.c_nationkey) eq(tpch.orders.o_custkey, tpch.customer.c_custkey)] ├─TableReader_70(Build) 7500000.00 root data:TableFullScan_69 │ └─TableFullScan_69 7500000.00 cop[tikv] table:customer keep order:false └─HashJoin_43(Probe) 11822812.50 root inner join, equal:[eq(tpch.lineitem.l_orderkey, tpch.orders.o_orderkey)] ├─TableReader_68(Build) 11822812.50 root data:Selection_67 │ └─Selection_67 11822812.50 cop[tikv] ge(tpch.orders.o_orderdate, 1994-01-01 00:00:00.000000), lt(tpch.orders.o_orderdate, 1995-01-01) │ └─TableFullScan_66 75000000.00 cop[tikv] table:orders keep order:false └─HashJoin_46(Probe) 61163763.01 root inner join, equal:[eq(tpch.supplier.s_suppkey, tpch.lineitem.l_suppkey)] ├─HashJoin_48(Build) 100000.00 root inner join, equal:[eq(tpch.nation.n_nationkey, tpch.supplier.s_nationkey)] │ ├─HashJoin_56(Build) 5.00 root inner join, equal:[eq(tpch.region.r_regionkey, tpch.nation.n_regionkey)] │ │ ├─TableReader_61(Build) 1.00 root data:Selection_60 │ │ │ └─Selection_60 1.00 cop[tikv] eq(tpch.region.r_name, "MIDDLE EAST") │ │ │ └─TableFullScan_59 5.00 cop[tikv] table:region keep order:false │ │ └─TableReader_58(Probe) 25.00 root data:TableFullScan_57 │ │ └─TableFullScan_57 25.00 cop[tikv] table:nation keep order:false │ └─TableReader_63(Probe) 500000.00 root data:TableFullScan_62 │ └─TableFullScan_62 500000.00 cop[tikv] table:supplier keep order:false └─TableReader_65(Probe) 300005811.00 root data:TableFullScan_64 └─TableFullScan_64 300005811.00 cop[tikv] table:lineitem keep order:false /* Q6 Forecasting Revenue Change Query This query quantifies the amount of revenue increase that would have resulted from eliminating certain companywide discounts in a given percentage range in a given year. Asking this type of "what if" query can be used to look for ways to increase revenues. The Forecasting Revenue Change Query considers all the lineitems shipped in a given year with discounts between DISCOUNT-0.01 and DISCOUNT+0.01. The query lists the amount by which the total revenue would have increased if these discounts had been eliminated for lineitems with l_quantity less than quantity. Note that the potential revenue increase is equal to the sum of [l_extendedprice * l_discount] for all lineitems with discounts and quantities in the qualifying range. */ explain select sum(l_extendedprice * l_discount) as revenue from lineitem where l_shipdate >= '1994-01-01' and l_shipdate < date_add('1994-01-01', interval '1' year) and l_discount between 0.06 - 0.01 and 0.06 + 0.01 and l_quantity < 24; id estRows task access object operator info StreamAgg_20 1.00 root funcs:sum(Column#20)->Column#18 └─TableReader_21 1.00 root data:StreamAgg_9 └─StreamAgg_9 1.00 cop[tikv] funcs:sum(mul(tpch.lineitem.l_extendedprice, tpch.lineitem.l_discount))->Column#20 └─Selection_19 3713857.91 cop[tikv] ge(tpch.lineitem.l_discount, 0.05), ge(tpch.lineitem.l_shipdate, 1994-01-01 00:00:00.000000), le(tpch.lineitem.l_discount, 0.07), lt(tpch.lineitem.l_quantity, 24), lt(tpch.lineitem.l_shipdate, 1995-01-01) └─TableFullScan_18 300005811.00 cop[tikv] table:lineitem keep order:false /* Q7 Volume Shipping Query This query determines the value of goods shipped between certain nations to help in the re-negotiation of shipping contracts. The Volume Shipping Query finds, for two given nations, the gross discounted revenues derived from lineitems in which parts were shipped from a supplier in either nation to a customer in the other nation during 1995 and 1996. The query lists the supplier nation, the customer nation, the year, and the revenue from shipments that took place in that year. The query orders the answer by Supplier nation, Customer nation, and year (all ascending). Planner enahancement: join reorder. */ explain select supp_nation, cust_nation, l_year, sum(volume) as revenue from ( select n1.n_name as supp_nation, n2.n_name as cust_nation, extract(year from l_shipdate) as l_year, l_extendedprice * (1 - l_discount) as volume from supplier, lineitem, orders, customer, nation n1, nation n2 where s_suppkey = l_suppkey and o_orderkey = l_orderkey and c_custkey = o_custkey and s_nationkey = n1.n_nationkey and c_nationkey = n2.n_nationkey and ( (n1.n_name = 'JAPAN' and n2.n_name = 'INDIA') or (n1.n_name = 'INDIA' and n2.n_name = 'JAPAN') ) and l_shipdate between '1995-01-01' and '1996-12-31' ) as shipping group by supp_nation, cust_nation, l_year order by supp_nation, cust_nation, l_year; id estRows task access object operator info Sort_22 769.96 root tpch.nation.n_name:asc, tpch.nation.n_name:asc, Column#50:asc └─Projection_24 769.96 root tpch.nation.n_name, tpch.nation.n_name, Column#50, Column#52 └─HashAgg_27 769.96 root group by:Column#50, tpch.nation.n_name, tpch.nation.n_name, funcs:sum(Column#51)->Column#52, funcs:firstrow(tpch.nation.n_name)->tpch.nation.n_name, funcs:firstrow(tpch.nation.n_name)->tpch.nation.n_name, funcs:firstrow(Column#50)->Column#50 └─Projection_28 1957240.42 root tpch.nation.n_name, tpch.nation.n_name, extract(YEAR, tpch.lineitem.l_shipdate)->Column#50, mul(tpch.lineitem.l_extendedprice, minus(1, tpch.lineitem.l_discount))->Column#51 └─HashJoin_35 1957240.42 root inner join, equal:[eq(tpch.customer.c_nationkey, tpch.nation.n_nationkey)], other cond:or(and(eq(tpch.nation.n_name, "JAPAN"), eq(tpch.nation.n_name, "INDIA")), and(eq(tpch.nation.n_name, "INDIA"), eq(tpch.nation.n_name, "JAPAN"))) ├─TableReader_76(Build) 2.00 root data:Selection_75 │ └─Selection_75 2.00 cop[tikv] or(eq(tpch.nation.n_name, "INDIA"), eq(tpch.nation.n_name, "JAPAN")) │ └─TableFullScan_74 25.00 cop[tikv] table:n2 keep order:false └─HashJoin_42(Probe) 24465505.20 root inner join, equal:[eq(tpch.orders.o_custkey, tpch.customer.c_custkey)] ├─TableReader_73(Build) 7500000.00 root data:TableFullScan_72 │ └─TableFullScan_72 7500000.00 cop[tikv] table:customer keep order:false └─IndexJoin_47(Probe) 24465505.20 root inner join, inner:TableReader_46, outer key:tpch.lineitem.l_orderkey, inner key:tpch.orders.o_orderkey, equal cond:eq(tpch.lineitem.l_orderkey, tpch.orders.o_orderkey) ├─HashJoin_53(Build) 24465505.20 root inner join, equal:[eq(tpch.supplier.s_suppkey, tpch.lineitem.l_suppkey)] │ ├─HashJoin_61(Build) 40000.00 root inner join, equal:[eq(tpch.nation.n_nationkey, tpch.supplier.s_nationkey)] │ │ ├─TableReader_66(Build) 2.00 root data:Selection_65 │ │ │ └─Selection_65 2.00 cop[tikv] or(eq(tpch.nation.n_name, "JAPAN"), eq(tpch.nation.n_name, "INDIA")) │ │ │ └─TableFullScan_64 25.00 cop[tikv] table:n1 keep order:false │ │ └─TableReader_63(Probe) 500000.00 root data:TableFullScan_62 │ │ └─TableFullScan_62 500000.00 cop[tikv] table:supplier keep order:false │ └─TableReader_69(Probe) 91446230.29 root data:Selection_68 │ └─Selection_68 91446230.29 cop[tikv] ge(tpch.lineitem.l_shipdate, 1995-01-01 00:00:00.000000), le(tpch.lineitem.l_shipdate, 1996-12-31 00:00:00.000000) │ └─TableFullScan_67 300005811.00 cop[tikv] table:lineitem keep order:false └─TableReader_46(Probe) 1.00 root data:TableRangeScan_45 └─TableRangeScan_45 1.00 cop[tikv] table:orders range: decided by [tpch.lineitem.l_orderkey], keep order:false /* Q8 National Market Share Query This query determines how the market share of a given nation within a given region has changed over two years for a given part type. The market share for a given nation within a given region is defined as the fraction of the revenue, the sum of [l_extendedprice * (1-l_discount)], from the products of a specified type in that region that was supplied by suppliers from the given nation. The query determines this for the years 1995 and 1996 presented in this order. Planner enhancement: join reorder. */ explain select o_year, sum(case when nation = 'INDIA' then volume else 0 end) / sum(volume) as mkt_share from ( select extract(year from o_orderdate) as o_year, l_extendedprice * (1 - l_discount) as volume, n2.n_name as nation from part, supplier, lineitem, orders, customer, nation n1, nation n2, region where p_partkey = l_partkey and s_suppkey = l_suppkey and l_orderkey = o_orderkey and o_custkey = c_custkey and c_nationkey = n1.n_nationkey and n1.n_regionkey = r_regionkey and r_name = 'ASIA' and s_nationkey = n2.n_nationkey and o_orderdate between '1995-01-01' and '1996-12-31' and p_type = 'SMALL PLATED COPPER' ) as all_nations group by o_year order by o_year; id estRows task access object operator info Sort_29 719.02 root Column#62:asc └─Projection_31 719.02 root Column#62, div(Column#64, Column#65)->Column#66 └─HashAgg_34 719.02 root group by:Column#75, funcs:sum(Column#72)->Column#64, funcs:sum(Column#73)->Column#65, funcs:firstrow(Column#74)->Column#62 └─Projection_99 563136.02 root case(eq(tpch.nation.n_name, INDIA), Column#63, 0)->Column#72, Column#63, Column#62, Column#62 └─Projection_35 563136.02 root extract(YEAR, tpch.orders.o_orderdate)->Column#62, mul(tpch.lineitem.l_extendedprice, minus(1, tpch.lineitem.l_discount))->Column#63, tpch.nation.n_name └─HashJoin_41 563136.02 root inner join, equal:[eq(tpch.supplier.s_nationkey, tpch.nation.n_nationkey)] ├─TableReader_97(Build) 25.00 root data:TableFullScan_96 │ └─TableFullScan_96 25.00 cop[tikv] table:n2 keep order:false └─HashJoin_48(Probe) 563136.02 root inner join, equal:[eq(tpch.lineitem.l_suppkey, tpch.supplier.s_suppkey)] ├─TableReader_95(Build) 500000.00 root data:TableFullScan_94 │ └─TableFullScan_94 500000.00 cop[tikv] table:supplier keep order:false └─HashJoin_56(Probe) 563136.02 root inner join, equal:[eq(tpch.lineitem.l_partkey, tpch.part.p_partkey)] ├─TableReader_93(Build) 61674.00 root data:Selection_92 │ └─Selection_92 61674.00 cop[tikv] eq(tpch.part.p_type, "SMALL PLATED COPPER") │ └─TableFullScan_91 10000000.00 cop[tikv] table:part keep order:false └─IndexHashJoin_64(Probe) 90788402.51 root inner join, inner:IndexLookUp_61, outer key:tpch.orders.o_orderkey, inner key:tpch.lineitem.l_orderkey, equal cond:eq(tpch.orders.o_orderkey, tpch.lineitem.l_orderkey) ├─HashJoin_68(Build) 22413367.93 root inner join, equal:[eq(tpch.customer.c_custkey, tpch.orders.o_custkey)] │ ├─HashJoin_70(Build) 1500000.00 root inner join, equal:[eq(tpch.nation.n_nationkey, tpch.customer.c_nationkey)] │ │ ├─HashJoin_78(Build) 5.00 root inner join, equal:[eq(tpch.region.r_regionkey, tpch.nation.n_regionkey)] │ │ │ ├─TableReader_83(Build) 1.00 root data:Selection_82 │ │ │ │ └─Selection_82 1.00 cop[tikv] eq(tpch.region.r_name, "ASIA") │ │ │ │ └─TableFullScan_81 5.00 cop[tikv] table:region keep order:false │ │ │ └─TableReader_80(Probe) 25.00 root data:TableFullScan_79 │ │ │ └─TableFullScan_79 25.00 cop[tikv] table:n1 keep order:false │ │ └─TableReader_85(Probe) 7500000.00 root data:TableFullScan_84 │ │ └─TableFullScan_84 7500000.00 cop[tikv] table:customer keep order:false │ └─TableReader_88(Probe) 22413367.93 root data:Selection_87 │ └─Selection_87 22413367.93 cop[tikv] ge(tpch.orders.o_orderdate, 1995-01-01 00:00:00.000000), le(tpch.orders.o_orderdate, 1996-12-31 00:00:00.000000) │ └─TableFullScan_86 75000000.00 cop[tikv] table:orders keep order:false └─IndexLookUp_61(Probe) 4.05 root ├─IndexRangeScan_59(Build) 4.05 cop[tikv] table:lineitem, index:PRIMARY(L_ORDERKEY, L_LINENUMBER) range: decided by [eq(tpch.lineitem.l_orderkey, tpch.orders.o_orderkey)], keep order:false └─TableRowIDScan_60(Probe) 4.05 cop[tikv] table:lineitem keep order:false /* Q9 Product Type Profit Measure Query This query determines how much profit is made on a given line of parts, broken out by supplier nation and year. The Product Type Profit Measure Query finds, for each nation and each year, the profit for all parts ordered in that year that contain a specified substring in their names and that were filled by a supplier in that nation. The profit is defined as the sum of [(l_extendedprice*(1-l_discount)) - (ps_supplycost * l_quantity)] for all lineitems describing parts in the specified line. The query lists the nations in ascending alphabetical order and, for each nation, the year and profit in descending order by year (most recent first). Planner enhancement: join reorder. */ explain select nation, o_year, sum(amount) as sum_profit from ( select n_name as nation, extract(year from o_orderdate) as o_year, l_extendedprice * (1 - l_discount) - ps_supplycost * l_quantity as amount from part, supplier, lineitem, partsupp, orders, nation where s_suppkey = l_suppkey and ps_suppkey = l_suppkey and ps_partkey = l_partkey and p_partkey = l_partkey and o_orderkey = l_orderkey and s_nationkey = n_nationkey and p_name like '%dim%' ) as profit group by nation, o_year order by nation, o_year desc; id estRows task access object operator info Sort_25 2406.00 root tpch.nation.n_name:asc, Column#53:desc └─Projection_27 2406.00 root tpch.nation.n_name, Column#53, Column#55 └─HashAgg_30 2406.00 root group by:Column#53, tpch.nation.n_name, funcs:sum(Column#54)->Column#55, funcs:firstrow(tpch.nation.n_name)->tpch.nation.n_name, funcs:firstrow(Column#53)->Column#53 └─Projection_31 971049283.51 root tpch.nation.n_name, extract(YEAR, tpch.orders.o_orderdate)->Column#53, minus(mul(tpch.lineitem.l_extendedprice, minus(1, tpch.lineitem.l_discount)), mul(tpch.partsupp.ps_supplycost, tpch.lineitem.l_quantity))->Column#54 └─HashJoin_38 971049283.51 root inner join, equal:[eq(tpch.lineitem.l_suppkey, tpch.partsupp.ps_suppkey) eq(tpch.lineitem.l_partkey, tpch.partsupp.ps_partkey)] ├─TableReader_83(Build) 40000000.00 root data:TableFullScan_82 │ └─TableFullScan_82 40000000.00 cop[tikv] table:partsupp keep order:false └─HashJoin_46(Probe) 241379546.70 root inner join, equal:[eq(tpch.lineitem.l_orderkey, tpch.orders.o_orderkey)] ├─TableReader_81(Build) 75000000.00 root data:TableFullScan_80 │ └─TableFullScan_80 75000000.00 cop[tikv] table:orders keep order:false └─HashJoin_60(Probe) 241379546.70 root inner join, equal:[eq(tpch.lineitem.l_partkey, tpch.part.p_partkey)] ├─TableReader_79(Build) 8000000.00 root data:Selection_78 │ └─Selection_78 8000000.00 cop[tikv] like(tpch.part.p_name, "%dim%", 92) │ └─TableFullScan_77 10000000.00 cop[tikv] table:part keep order:false └─HashJoin_63(Probe) 300005811.00 root inner join, equal:[eq(tpch.supplier.s_suppkey, tpch.lineitem.l_suppkey)] ├─HashJoin_70(Build) 500000.00 root inner join, equal:[eq(tpch.nation.n_nationkey, tpch.supplier.s_nationkey)] │ ├─TableReader_74(Build) 25.00 root data:TableFullScan_73 │ │ └─TableFullScan_73 25.00 cop[tikv] table:nation keep order:false │ └─TableReader_72(Probe) 500000.00 root data:TableFullScan_71 │ └─TableFullScan_71 500000.00 cop[tikv] table:supplier keep order:false └─TableReader_76(Probe) 300005811.00 root data:TableFullScan_75 └─TableFullScan_75 300005811.00 cop[tikv] table:lineitem keep order:false /* Q10 Returned Item Reporting Query The query identifies customers who might be having problems with the parts that are shipped to them. The Returned Item Reporting Query finds the top 20 customers, in terms of their effect on lost revenue for a given quarter, who have returned parts. The query considers only parts that were ordered in the specified quarter. The query lists the customer's name, address, nation, phone number, account balance, comment information and revenue lost. The customers are listed in descending order of lost revenue. Revenue lost is defined as sum(l_extendedprice*(1-l_discount)) for all qualifying lineitems. Planner enhancement: join reorder, if group-by item have primary key, non-priamry key is useless. */ explain select c_custkey, c_name, sum(l_extendedprice * (1 - l_discount)) as revenue, c_acctbal, n_name, c_address, c_phone, c_comment from customer, orders, lineitem, nation where c_custkey = o_custkey and l_orderkey = o_orderkey and o_orderdate >= '1993-08-01' and o_orderdate < date_add('1993-08-01', interval '3' month) and l_returnflag = 'R' and c_nationkey = n_nationkey group by c_custkey, c_name, c_acctbal, c_phone, n_name, c_address, c_comment order by revenue desc limit 20; id estRows task access object operator info Projection_17 20.00 root tpch.customer.c_custkey, tpch.customer.c_name, Column#39, tpch.customer.c_acctbal, tpch.nation.n_name, tpch.customer.c_address, tpch.customer.c_phone, tpch.customer.c_comment └─TopN_20 20.00 root Column#39:desc, offset:0, count:20 └─HashAgg_26 3017307.69 root group by:Column#50, Column#51, Column#52, Column#53, Column#54, Column#55, Column#56, funcs:sum(Column#42)->Column#39, funcs:firstrow(Column#43)->tpch.customer.c_custkey, funcs:firstrow(Column#44)->tpch.customer.c_name, funcs:firstrow(Column#45)->tpch.customer.c_address, funcs:firstrow(Column#46)->tpch.customer.c_phone, funcs:firstrow(Column#47)->tpch.customer.c_acctbal, funcs:firstrow(Column#48)->tpch.customer.c_comment, funcs:firstrow(Column#49)->tpch.nation.n_name └─Projection_56 12222016.17 root mul(tpch.lineitem.l_extendedprice, minus(1, tpch.lineitem.l_discount))->Column#42, tpch.customer.c_custkey, tpch.customer.c_name, tpch.customer.c_address, tpch.customer.c_phone, tpch.customer.c_acctbal, tpch.customer.c_comment, tpch.nation.n_name, tpch.customer.c_custkey, tpch.customer.c_name, tpch.customer.c_acctbal, tpch.customer.c_phone, tpch.nation.n_name, tpch.customer.c_address, tpch.customer.c_comment └─IndexHashJoin_34 12222016.17 root inner join, inner:IndexLookUp_31, outer key:tpch.orders.o_orderkey, inner key:tpch.lineitem.l_orderkey, equal cond:eq(tpch.orders.o_orderkey, tpch.lineitem.l_orderkey) ├─HashJoin_37(Build) 3017307.69 root inner join, equal:[eq(tpch.customer.c_custkey, tpch.orders.o_custkey)] │ ├─TableReader_52(Build) 3017307.69 root data:Selection_51 │ │ └─Selection_51 3017307.69 cop[tikv] ge(tpch.orders.o_orderdate, 1993-08-01 00:00:00.000000), lt(tpch.orders.o_orderdate, 1993-11-01) │ │ └─TableFullScan_50 75000000.00 cop[tikv] table:orders keep order:false │ └─HashJoin_45(Probe) 7500000.00 root inner join, equal:[eq(tpch.nation.n_nationkey, tpch.customer.c_nationkey)] │ ├─TableReader_49(Build) 25.00 root data:TableFullScan_48 │ │ └─TableFullScan_48 25.00 cop[tikv] table:nation keep order:false │ └─TableReader_47(Probe) 7500000.00 root data:TableFullScan_46 │ └─TableFullScan_46 7500000.00 cop[tikv] table:customer keep order:false └─IndexLookUp_31(Probe) 4.05 root ├─IndexRangeScan_28(Build) 16.44 cop[tikv] table:lineitem, index:PRIMARY(L_ORDERKEY, L_LINENUMBER) range: decided by [eq(tpch.lineitem.l_orderkey, tpch.orders.o_orderkey)], keep order:false └─Selection_30(Probe) 4.05 cop[tikv] eq(tpch.lineitem.l_returnflag, "R") └─TableRowIDScan_29 16.44 cop[tikv] table:lineitem keep order:false /* Q11 Important Stock Identification Query This query finds the most important subset of suppliers' stock in a given nation. The Important Stock Identification Query finds, from scanning the available stock of suppliers in a given nation, all the parts that represent a significant percentage of the total value of all available parts. The query displays the part number and the value of those parts in descending order of value. */ explain select ps_partkey, sum(ps_supplycost * ps_availqty) as value from partsupp, supplier, nation where ps_suppkey = s_suppkey and s_nationkey = n_nationkey and n_name = 'MOZAMBIQUE' group by ps_partkey having sum(ps_supplycost * ps_availqty) > ( select sum(ps_supplycost * ps_availqty) * 0.0001000000 from partsupp, supplier, nation where ps_suppkey = s_suppkey and s_nationkey = n_nationkey and n_name = 'MOZAMBIQUE' ) order by value desc; id estRows task access object operator info Projection_52 1304801.67 root tpch.partsupp.ps_partkey, Column#18 └─Sort_53 1304801.67 root Column#18:desc └─Selection_55 1304801.67 root gt(Column#18, NULL) └─HashAgg_58 1631002.09 root group by:Column#44, funcs:sum(Column#42)->Column#18, funcs:firstrow(Column#43)->tpch.partsupp.ps_partkey └─Projection_79 1631002.09 root mul(tpch.partsupp.ps_supplycost, cast(tpch.partsupp.ps_availqty, decimal(20,0) BINARY))->Column#42, tpch.partsupp.ps_partkey, tpch.partsupp.ps_partkey └─HashJoin_62 1631002.09 root inner join, equal:[eq(tpch.supplier.s_suppkey, tpch.partsupp.ps_suppkey)] ├─HashJoin_70(Build) 20000.00 root inner join, equal:[eq(tpch.nation.n_nationkey, tpch.supplier.s_nationkey)] │ ├─TableReader_75(Build) 1.00 root data:Selection_74 │ │ └─Selection_74 1.00 cop[tikv] eq(tpch.nation.n_name, "MOZAMBIQUE") │ │ └─TableFullScan_73 25.00 cop[tikv] table:nation keep order:false │ └─TableReader_72(Probe) 500000.00 root data:TableFullScan_71 │ └─TableFullScan_71 500000.00 cop[tikv] table:supplier keep order:false └─TableReader_77(Probe) 40000000.00 root data:TableFullScan_76 └─TableFullScan_76 40000000.00 cop[tikv] table:partsupp keep order:false /* Q12 Shipping Modes and Order Priority Query This query determines whether selecting less expensive modes of shipping is negatively affecting the critical-priority orders by causing more parts to be received by customers after the committed date. The Shipping Modes and Order Priority Query counts, by ship mode, for lineitems actually received by customers in a given year, the number of lineitems belonging to orders for which the l_receiptdate exceeds the l_commitdate for two different specified ship modes. Only lineitems that were actually shipped before the l_commitdate are considered. The late lineitems are partitioned into two groups, those with priority URGENT or HIGH, and those with a priority other than URGENT or HIGH. */ explain select l_shipmode, sum(case when o_orderpriority = '1-URGENT' or o_orderpriority = '2-HIGH' then 1 else 0 end) as high_line_count, sum(case when o_orderpriority <> '1-URGENT' and o_orderpriority <> '2-HIGH' then 1 else 0 end) as low_line_count from orders, lineitem where o_orderkey = l_orderkey and l_shipmode in ('RAIL', 'FOB') and l_commitdate < l_receiptdate and l_shipdate < l_commitdate and l_receiptdate >= '1997-01-01' and l_receiptdate < date_add('1997-01-01', interval '1' year) group by l_shipmode order by l_shipmode; id estRows task access object operator info Sort_9 1.00 root tpch.lineitem.l_shipmode:asc └─Projection_11 1.00 root tpch.lineitem.l_shipmode, Column#27, Column#28 └─HashAgg_14 1.00 root group by:Column#37, funcs:sum(Column#34)->Column#27, funcs:sum(Column#35)->Column#28, funcs:firstrow(Column#36)->tpch.lineitem.l_shipmode └─Projection_43 10023369.01 root cast(case(or(eq(tpch.orders.o_orderpriority, 1-URGENT), eq(tpch.orders.o_orderpriority, 2-HIGH)), 1, 0), decimal(65,0) BINARY)->Column#34, cast(case(and(ne(tpch.orders.o_orderpriority, 1-URGENT), ne(tpch.orders.o_orderpriority, 2-HIGH)), 1, 0), decimal(65,0) BINARY)->Column#35, tpch.lineitem.l_shipmode, tpch.lineitem.l_shipmode └─IndexJoin_18 10023369.01 root inner join, inner:TableReader_17, outer key:tpch.lineitem.l_orderkey, inner key:tpch.orders.o_orderkey, equal cond:eq(tpch.lineitem.l_orderkey, tpch.orders.o_orderkey) ├─TableReader_39(Build) 10023369.01 root data:Selection_38 │ └─Selection_38 10023369.01 cop[tikv] ge(tpch.lineitem.l_receiptdate, 1997-01-01 00:00:00.000000), in(tpch.lineitem.l_shipmode, "RAIL", "FOB"), lt(tpch.lineitem.l_commitdate, tpch.lineitem.l_receiptdate), lt(tpch.lineitem.l_receiptdate, 1998-01-01), lt(tpch.lineitem.l_shipdate, tpch.lineitem.l_commitdate) │ └─TableFullScan_37 300005811.00 cop[tikv] table:lineitem keep order:false └─TableReader_17(Probe) 1.00 root data:TableRangeScan_16 └─TableRangeScan_16 1.00 cop[tikv] table:orders range: decided by [tpch.lineitem.l_orderkey], keep order:false /* Q13 Customer Distribution Query This query seeks relationships between customers and the size of their orders. This query determines the distribution of customers by the number of orders they have made, including customers who have no record of orders, past or present. It counts and reports how many customers have no orders, how many have 1, 2, 3, etc. A check is made to ensure that the orders counted do not fall into one of several special categories of orders. Special categories are identified in the order comment column by looking for a particular pattern. */ explain select c_count, count(*) as custdist from ( select c_custkey, count(o_orderkey) as c_count from customer left outer join orders on c_custkey = o_custkey and o_comment not like '%pending%deposits%' group by c_custkey ) c_orders group by c_count order by custdist desc, c_count desc; id estRows task access object operator info Sort_9 7500000.00 root Column#19:desc, Column#18:desc └─Projection_11 7500000.00 root Column#18, Column#19 └─HashAgg_14 7500000.00 root group by:Column#18, funcs:count(1)->Column#19, funcs:firstrow(Column#18)->Column#18 └─HashAgg_17 7500000.00 root group by:tpch.customer.c_custkey, funcs:count(tpch.orders.o_orderkey)->Column#18 └─HashJoin_21 60000000.00 root left outer join, equal:[eq(tpch.customer.c_custkey, tpch.orders.o_custkey)] ├─TableReader_23(Build) 7500000.00 root data:TableFullScan_22 │ └─TableFullScan_22 7500000.00 cop[tikv] table:customer keep order:false └─TableReader_26(Probe) 60000000.00 root data:Selection_25 └─Selection_25 60000000.00 cop[tikv] not(like(tpch.orders.o_comment, "%pending%deposits%", 92)) └─TableFullScan_24 75000000.00 cop[tikv] table:orders keep order:false /* Q14 Promotion Effect Query This query monitors the market response to a promotion such as TV advertisements or a special campaign. The Promotion Effect Query determines what percentage of the revenue in a given year and month was derived from promotional parts. The query considers only parts actually shipped in that month and gives the percentage. Revenue is defined as (l_extendedprice * (1-l_discount)). */ explain select 100.00 * sum(case when p_type like 'PROMO%' then l_extendedprice * (1 - l_discount) else 0 end) / sum(l_extendedprice * (1 - l_discount)) as promo_revenue from lineitem, part where l_partkey = p_partkey and l_shipdate >= '1996-12-01' and l_shipdate < date_add('1996-12-01', interval '1' month); id estRows task access object operator info Projection_8 1.00 root div(mul(100.00, Column#27), Column#28)->Column#29 └─StreamAgg_13 1.00 root funcs:sum(Column#31)->Column#27, funcs:sum(Column#32)->Column#28 └─Projection_33 4121984.49 root case(like(tpch.part.p_type, PROMO%, 92), mul(tpch.lineitem.l_extendedprice, minus(1, tpch.lineitem.l_discount)), 0)->Column#31, mul(tpch.lineitem.l_extendedprice, minus(1, tpch.lineitem.l_discount))->Column#32 └─IndexJoin_28 4121984.49 root inner join, inner:TableReader_27, outer key:tpch.lineitem.l_partkey, inner key:tpch.part.p_partkey, equal cond:eq(tpch.lineitem.l_partkey, tpch.part.p_partkey) ├─TableReader_23(Build) 4121984.49 root data:Selection_22 │ └─Selection_22 4121984.49 cop[tikv] ge(tpch.lineitem.l_shipdate, 1996-12-01 00:00:00.000000), lt(tpch.lineitem.l_shipdate, 1997-01-01) │ └─TableFullScan_21 300005811.00 cop[tikv] table:lineitem keep order:false └─TableReader_27(Probe) 1.00 root data:TableRangeScan_26 └─TableRangeScan_26 1.00 cop[tikv] table:part range: decided by [tpch.lineitem.l_partkey], keep order:false /* Q15 Top Supplier Query This query determines the top supplier so it can be rewarded, given more business, or identified for special recognition. The Top Supplier Query finds the supplier who contributed the most to the overall revenue for parts shipped during a given quarter of a given year. In case of a tie, the query lists all suppliers whose contribution was equal to the maximum, presented in supplier number order. Planner enhancement: support view. create view revenue0 (supplier_no, total_revenue) as select l_suppkey, sum(l_extendedprice * (1 - l_discount)) from lineitem where l_shipdate >= '1997-07-01' and l_shipdate < date_add('1997-07-01', interval '3' month) group by l_suppkey select s_suppkey, s_name, s_address, s_phone, total_revenue from supplier, revenue0 where s_suppkey = supplier_no and total_revenue = ( select max(total_revenue) from revenue0 ) order by s_suppkey drop view revenue0 */ /* Q16 Parts/Supplier Relationship Query This query finds out how many suppliers can supply parts with given attributes. It might be used, for example, to determine whether there is a sufficient number of suppliers for heavily ordered parts. The Parts/Supplier Relationship Query counts the number of suppliers who can supply parts that satisfy a particular customer's requirements. The customer is interested in parts of eight different sizes as long as they are not of a given type, not of a given brand, and not from a supplier who has had complaints registered at the Better Business Bureau. Results must be presented in descending count and ascending brand, type, and size. */ explain select p_brand, p_type, p_size, count(distinct ps_suppkey) as supplier_cnt from partsupp, part where p_partkey = ps_partkey and p_brand <> 'Brand#34' and p_type not like 'LARGE BRUSHED%' and p_size in (48, 19, 12, 4, 41, 7, 21, 39) and ps_suppkey not in ( select s_suppkey from supplier where s_comment like '%Customer%Complaints%' ) group by p_brand, p_type, p_size order by supplier_cnt desc, p_brand, p_type, p_size; id estRows task access object operator info Sort_13 14.41 root Column#23:desc, tpch.part.p_brand:asc, tpch.part.p_type:asc, tpch.part.p_size:asc └─Projection_15 14.41 root tpch.part.p_brand, tpch.part.p_type, tpch.part.p_size, Column#23 └─HashAgg_16 14.41 root group by:tpch.part.p_brand, tpch.part.p_size, tpch.part.p_type, funcs:count(distinct tpch.partsupp.ps_suppkey)->Column#23, funcs:firstrow(tpch.part.p_brand)->tpch.part.p_brand, funcs:firstrow(tpch.part.p_type)->tpch.part.p_type, funcs:firstrow(tpch.part.p_size)->tpch.part.p_size └─HashJoin_23 3863988.24 root anti semi join, equal:[eq(tpch.partsupp.ps_suppkey, tpch.supplier.s_suppkey)] ├─TableReader_52(Build) 400000.00 root data:Selection_51 │ └─Selection_51 400000.00 cop[tikv] like(tpch.supplier.s_comment, "%Customer%Complaints%", 92) │ └─TableFullScan_50 500000.00 cop[tikv] table:supplier keep order:false └─IndexHashJoin_29(Probe) 4829985.30 root inner join, inner:IndexReader_26, outer key:tpch.part.p_partkey, inner key:tpch.partsupp.ps_partkey, equal cond:eq(tpch.part.p_partkey, tpch.partsupp.ps_partkey) ├─TableReader_45(Build) 1200618.43 root data:Selection_44 │ └─Selection_44 1200618.43 cop[tikv] in(tpch.part.p_size, 48, 19, 12, 4, 41, 7, 21, 39), ne(tpch.part.p_brand, "Brand#34"), not(like(tpch.part.p_type, "LARGE BRUSHED%", 92)) │ └─TableFullScan_43 10000000.00 cop[tikv] table:part keep order:false └─IndexReader_26(Probe) 4.02 root index:IndexRangeScan_25 └─IndexRangeScan_25 4.02 cop[tikv] table:partsupp, index:PRIMARY(PS_PARTKEY, PS_SUPPKEY) range: decided by [eq(tpch.partsupp.ps_partkey, tpch.part.p_partkey)], keep order:false /* Q17 Small-Quantity-Order Revenue Query This query determines how much average yearly revenue would be lost if orders were no longer filled for small quantities of certain parts. This may reduce overhead expenses by concentrating sales on larger shipments. The Small-Quantity-Order Revenue Query considers parts of a given brand and with a given container type and determines the average lineitem quantity of such parts ordered for all orders (past and pending) in the 7-year database. What would be the average yearly gross (undiscounted) loss in revenue if orders for these parts with a quantity of less than 20% of this average were no longer taken? Planner enahancement: aggregation pull up through join. */ explain select sum(l_extendedprice) / 7.0 as avg_yearly from lineitem, part where p_partkey = l_partkey and p_brand = 'Brand#44' and p_container = 'WRAP PKG' and l_quantity < ( select 0.2 * avg(l_quantity) from lineitem where l_partkey = p_partkey ); id estRows task access object operator info Projection_16 1.00 root div(Column#46, 7.0)->Column#47 └─StreamAgg_21 1.00 root funcs:sum(tpch.lineitem.l_extendedprice)->Column#46 └─HashJoin_48 293773.83 root inner join, equal:[eq(tpch.part.p_partkey, tpch.lineitem.l_partkey)], other cond:lt(tpch.lineitem.l_quantity, mul(0.2, Column#44)) ├─HashJoin_32(Build) 293773.83 root inner join, equal:[eq(tpch.part.p_partkey, tpch.lineitem.l_partkey)] │ ├─TableReader_37(Build) 9736.49 root data:Selection_36 │ │ └─Selection_36 9736.49 cop[tikv] eq(tpch.part.p_brand, "Brand#44"), eq(tpch.part.p_container, "WRAP PKG") │ │ └─TableFullScan_35 10000000.00 cop[tikv] table:part keep order:false │ └─TableReader_34(Probe) 300005811.00 root data:TableFullScan_33 │ └─TableFullScan_33 300005811.00 cop[tikv] table:lineitem keep order:false └─HashAgg_42(Probe) 9943040.00 root group by:tpch.lineitem.l_partkey, funcs:avg(Column#50, Column#51)->Column#44, funcs:firstrow(tpch.lineitem.l_partkey)->tpch.lineitem.l_partkey └─TableReader_43 9943040.00 root data:HashAgg_38 └─HashAgg_38 9943040.00 cop[tikv] group by:tpch.lineitem.l_partkey, funcs:count(tpch.lineitem.l_quantity)->Column#50, funcs:sum(tpch.lineitem.l_quantity)->Column#51 └─TableFullScan_41 300005811.00 cop[tikv] table:lineitem keep order:false /* Q18 Large Volume Customer Query The Large Volume Customer Query ranks customers based on their having placed a large quantity order. Large quantity orders are defined as those orders whose total quantity is above a certain level. The Large Volume Customer Query finds a list of the top 100 customers who have ever placed large quantity orders. The query lists the customer name, customer key, the order key, date and total price and the quantity for the order. Planner enhancement: cost estimation is not so good, join reorder. The inner subquery's result is only 300+ rows. */ explain select c_name, c_custkey, o_orderkey, o_orderdate, o_totalprice, sum(l_quantity) from customer, orders, lineitem where o_orderkey in ( select l_orderkey from lineitem group by l_orderkey having sum(l_quantity) > 314 ) and c_custkey = o_custkey and o_orderkey = l_orderkey group by c_name, c_custkey, o_orderkey, o_orderdate, o_totalprice order by o_totalprice desc, o_orderdate limit 100; id estRows task access object operator info Projection_24 100.00 root tpch.customer.c_name, tpch.customer.c_custkey, tpch.orders.o_orderkey, tpch.orders.o_orderdate, tpch.orders.o_totalprice, Column#54 └─TopN_27 100.00 root tpch.orders.o_totalprice:desc, tpch.orders.o_orderdate:asc, offset:0, count:100 └─HashAgg_33 59251097.60 root group by:tpch.customer.c_custkey, tpch.customer.c_name, tpch.orders.o_orderdate, tpch.orders.o_orderkey, tpch.orders.o_totalprice, funcs:sum(tpch.lineitem.l_quantity)->Column#54, funcs:firstrow(tpch.customer.c_custkey)->tpch.customer.c_custkey, funcs:firstrow(tpch.customer.c_name)->tpch.customer.c_name, funcs:firstrow(tpch.orders.o_orderkey)->tpch.orders.o_orderkey, funcs:firstrow(tpch.orders.o_totalprice)->tpch.orders.o_totalprice, funcs:firstrow(tpch.orders.o_orderdate)->tpch.orders.o_orderdate └─HashJoin_42 240004648.80 root inner join, equal:[eq(tpch.orders.o_orderkey, tpch.lineitem.l_orderkey)] ├─HashJoin_63(Build) 59251097.60 root inner join, equal:[eq(tpch.orders.o_orderkey, tpch.lineitem.l_orderkey)] │ ├─Selection_76(Build) 59251097.60 root gt(Column#52, 314) │ │ └─HashAgg_83 74063872.00 root group by:tpch.lineitem.l_orderkey, funcs:sum(Column#63)->Column#52, funcs:firstrow(tpch.lineitem.l_orderkey)->tpch.lineitem.l_orderkey │ │ └─TableReader_84 74063872.00 root data:HashAgg_77 │ │ └─HashAgg_77 74063872.00 cop[tikv] group by:tpch.lineitem.l_orderkey, funcs:sum(tpch.lineitem.l_quantity)->Column#63 │ │ └─TableFullScan_82 300005811.00 cop[tikv] table:lineitem keep order:false │ └─HashJoin_71(Probe) 75000000.00 root inner join, equal:[eq(tpch.customer.c_custkey, tpch.orders.o_custkey)] │ ├─TableReader_75(Build) 7500000.00 root data:TableFullScan_74 │ │ └─TableFullScan_74 7500000.00 cop[tikv] table:customer keep order:false │ └─TableReader_73(Probe) 75000000.00 root data:TableFullScan_72 │ └─TableFullScan_72 75000000.00 cop[tikv] table:orders keep order:false └─TableReader_88(Probe) 300005811.00 root data:TableFullScan_87 └─TableFullScan_87 300005811.00 cop[tikv] table:lineitem keep order:false /* Q19 Discounted Revenue Query The Discounted Revenue Query reports the gross discounted revenue attributed to the sale of selected parts handled in a particular manner. This query is an example of code such as might be produced programmatically by a data mining tool. The Discounted Revenue query finds the gross discounted revenue for all orders for three different types of parts that were shipped by air and delivered in person. Parts are selected based on the combination of specific brands, a list of containers, and a range of sizes. */ explain select sum(l_extendedprice* (1 - l_discount)) as revenue from lineitem, part where ( p_partkey = l_partkey and p_brand = 'Brand#52' and p_container in ('SM CASE', 'SM BOX', 'SM PACK', 'SM PKG') and l_quantity >= 4 and l_quantity <= 4 + 10 and p_size between 1 and 5 and l_shipmode in ('AIR', 'AIR REG') and l_shipinstruct = 'DELIVER IN PERSON' ) or ( p_partkey = l_partkey and p_brand = 'Brand#11' and p_container in ('MED BAG', 'MED BOX', 'MED PKG', 'MED PACK') and l_quantity >= 18 and l_quantity <= 18 + 10 and p_size between 1 and 10 and l_shipmode in ('AIR', 'AIR REG') and l_shipinstruct = 'DELIVER IN PERSON' ) or ( p_partkey = l_partkey and p_brand = 'Brand#51' and p_container in ('LG CASE', 'LG BOX', 'LG PACK', 'LG PKG') and l_quantity >= 29 and l_quantity <= 29 + 10 and p_size between 1 and 15 and l_shipmode in ('AIR', 'AIR REG') and l_shipinstruct = 'DELIVER IN PERSON' ); id estRows task access object operator info StreamAgg_13 1.00 root funcs:sum(Column#28)->Column#27 └─Projection_36 6286493.79 root mul(tpch.lineitem.l_extendedprice, minus(1, tpch.lineitem.l_discount))->Column#28 └─IndexJoin_31 6286493.79 root inner join, inner:TableReader_30, outer key:tpch.lineitem.l_partkey, inner key:tpch.part.p_partkey, equal cond:eq(tpch.lineitem.l_partkey, tpch.part.p_partkey), other cond:or(and(and(eq(tpch.part.p_brand, "Brand#52"), in(tpch.part.p_container, "SM CASE", "SM BOX", "SM PACK", "SM PKG")), and(ge(tpch.lineitem.l_quantity, 4), and(le(tpch.lineitem.l_quantity, 14), le(tpch.part.p_size, 5)))), or(and(and(eq(tpch.part.p_brand, "Brand#11"), in(tpch.part.p_container, "MED BAG", "MED BOX", "MED PKG", "MED PACK")), and(ge(tpch.lineitem.l_quantity, 18), and(le(tpch.lineitem.l_quantity, 28), le(tpch.part.p_size, 10)))), and(and(eq(tpch.part.p_brand, "Brand#51"), in(tpch.part.p_container, "LG CASE", "LG BOX", "LG PACK", "LG PKG")), and(ge(tpch.lineitem.l_quantity, 29), and(le(tpch.lineitem.l_quantity, 39), le(tpch.part.p_size, 15)))))) ├─TableReader_24(Build) 6286493.79 root data:Selection_23 │ └─Selection_23 6286493.79 cop[tikv] eq(tpch.lineitem.l_shipinstruct, "DELIVER IN PERSON"), in(tpch.lineitem.l_shipmode, "AIR", "AIR REG"), or(and(ge(tpch.lineitem.l_quantity, 4), le(tpch.lineitem.l_quantity, 14)), or(and(ge(tpch.lineitem.l_quantity, 18), le(tpch.lineitem.l_quantity, 28)), and(ge(tpch.lineitem.l_quantity, 29), le(tpch.lineitem.l_quantity, 39)))) │ └─TableFullScan_22 300005811.00 cop[tikv] table:lineitem keep order:false └─TableReader_30(Probe) 0.80 root data:Selection_29 └─Selection_29 0.80 cop[tikv] ge(tpch.part.p_size, 1), or(and(eq(tpch.part.p_brand, "Brand#52"), and(in(tpch.part.p_container, "SM CASE", "SM BOX", "SM PACK", "SM PKG"), le(tpch.part.p_size, 5))), or(and(eq(tpch.part.p_brand, "Brand#11"), and(in(tpch.part.p_container, "MED BAG", "MED BOX", "MED PKG", "MED PACK"), le(tpch.part.p_size, 10))), and(eq(tpch.part.p_brand, "Brand#51"), and(in(tpch.part.p_container, "LG CASE", "LG BOX", "LG PACK", "LG PKG"), le(tpch.part.p_size, 15))))) └─TableRangeScan_28 1.00 cop[tikv] table:part range: decided by [tpch.lineitem.l_partkey], keep order:false /* Q20 Potential Part Promotion Query The Potential Part Promotion Query identifies suppliers in a particular nation having selected parts that may be candidates for a promotional offer. The Potential Part Promotion query identifies suppliers who have an excess of a given part available; an excess is defined to be more than 50% of the parts like the given part that the supplier shipped in a given year for a given nation. Only parts whose names share a certain naming convention are considered. */ explain select s_name, s_address from supplier, nation where s_suppkey in ( select ps_suppkey from partsupp where ps_partkey in ( select p_partkey from part where p_name like 'green%' ) and ps_availqty > ( select 0.5 * sum(l_quantity) from lineitem where l_partkey = ps_partkey and l_suppkey = ps_suppkey and l_shipdate >= '1993-01-01' and l_shipdate < date_add('1993-01-01', interval '1' year) ) ) and s_nationkey = n_nationkey and n_name = 'ALGERIA' order by s_name; id estRows task access object operator info Sort_28 20000.00 root tpch.supplier.s_name:asc └─HashJoin_32 20000.00 root inner join, equal:[eq(tpch.supplier.s_suppkey, tpch.partsupp.ps_suppkey)] ├─HashJoin_40(Build) 20000.00 root inner join, equal:[eq(tpch.nation.n_nationkey, tpch.supplier.s_nationkey)] │ ├─TableReader_45(Build) 1.00 root data:Selection_44 │ │ └─Selection_44 1.00 cop[tikv] eq(tpch.nation.n_name, "ALGERIA") │ │ └─TableFullScan_43 25.00 cop[tikv] table:nation keep order:false │ └─TableReader_42(Probe) 500000.00 root data:TableFullScan_41 │ └─TableFullScan_41 500000.00 cop[tikv] table:supplier keep order:false └─HashAgg_48(Probe) 257492.04 root group by:tpch.partsupp.ps_suppkey, funcs:firstrow(tpch.partsupp.ps_suppkey)->tpch.partsupp.ps_suppkey └─Projection_49 257492.04 root tpch.partsupp.ps_suppkey └─Selection_50 257492.04 root gt(cast(tpch.partsupp.ps_availqty), mul(0.5, Column#44)) └─HashAgg_53 321865.05 root group by:tpch.partsupp.ps_partkey, tpch.partsupp.ps_suppkey, funcs:firstrow(tpch.partsupp.ps_suppkey)->tpch.partsupp.ps_suppkey, funcs:firstrow(tpch.partsupp.ps_availqty)->tpch.partsupp.ps_availqty, funcs:sum(tpch.lineitem.l_quantity)->Column#44 └─HashJoin_57 9711455.06 root left outer join, equal:[eq(tpch.partsupp.ps_partkey, tpch.lineitem.l_partkey) eq(tpch.partsupp.ps_suppkey, tpch.lineitem.l_suppkey)] ├─IndexHashJoin_64(Build) 321865.05 root inner join, inner:IndexLookUp_61, outer key:tpch.part.p_partkey, inner key:tpch.partsupp.ps_partkey, equal cond:eq(tpch.part.p_partkey, tpch.partsupp.ps_partkey) │ ├─TableReader_82(Build) 80007.93 root data:Selection_81 │ │ └─Selection_81 80007.93 cop[tikv] like(tpch.part.p_name, "green%", 92) │ │ └─TableFullScan_80 10000000.00 cop[tikv] table:part keep order:false │ └─IndexLookUp_61(Probe) 4.02 root │ ├─IndexRangeScan_59(Build) 4.02 cop[tikv] table:partsupp, index:PRIMARY(PS_PARTKEY, PS_SUPPKEY) range: decided by [eq(tpch.partsupp.ps_partkey, tpch.part.p_partkey)], keep order:false │ └─TableRowIDScan_60(Probe) 4.02 cop[tikv] table:partsupp keep order:false └─TableReader_87(Probe) 44189356.65 root data:Selection_86 └─Selection_86 44189356.65 cop[tikv] ge(tpch.lineitem.l_shipdate, 1993-01-01 00:00:00.000000), lt(tpch.lineitem.l_shipdate, 1994-01-01) └─TableFullScan_85 300005811.00 cop[tikv] table:lineitem keep order:false /* Q21 Suppliers Who Kept Orders Waiting Query This query identifies certain suppliers who were not able to ship required parts in a timely manner. The Suppliers Who Kept Orders Waiting query identifies suppliers, for a given nation, whose product was part of a multi-supplier order (with current status of 'F') where they were the only supplier who failed to meet the committed delivery date. */ explain select s_name, count(*) as numwait from supplier, lineitem l1, orders, nation where s_suppkey = l1.l_suppkey and o_orderkey = l1.l_orderkey and o_orderstatus = 'F' and l1.l_receiptdate > l1.l_commitdate and exists ( select * from lineitem l2 where l2.l_orderkey = l1.l_orderkey and l2.l_suppkey <> l1.l_suppkey ) and not exists ( select * from lineitem l3 where l3.l_orderkey = l1.l_orderkey and l3.l_suppkey <> l1.l_suppkey and l3.l_receiptdate > l3.l_commitdate ) and s_nationkey = n_nationkey and n_name = 'EGYPT' group by s_name order by numwait desc, s_name limit 100; id estRows task access object operator info Projection_25 100.00 root tpch.supplier.s_name, Column#72 └─TopN_28 100.00 root Column#72:desc, tpch.supplier.s_name:asc, offset:0, count:100 └─HashAgg_34 12800.00 root group by:tpch.supplier.s_name, funcs:count(1)->Column#72, funcs:firstrow(tpch.supplier.s_name)->tpch.supplier.s_name └─IndexHashJoin_42 7828961.66 root anti semi join, inner:IndexLookUp_39, outer key:tpch.lineitem.l_orderkey, inner key:tpch.lineitem.l_orderkey, equal cond:eq(tpch.lineitem.l_orderkey, tpch.lineitem.l_orderkey), other cond:ne(tpch.lineitem.l_suppkey, tpch.lineitem.l_suppkey) ├─IndexHashJoin_64(Build) 9786202.08 root semi join, inner:IndexLookUp_61, outer key:tpch.lineitem.l_orderkey, inner key:tpch.lineitem.l_orderkey, equal cond:eq(tpch.lineitem.l_orderkey, tpch.lineitem.l_orderkey), other cond:ne(tpch.lineitem.l_suppkey, tpch.lineitem.l_suppkey), ne(tpch.lineitem.l_suppkey, tpch.supplier.s_suppkey) │ ├─IndexJoin_70(Build) 12232752.60 root inner join, inner:TableReader_69, outer key:tpch.lineitem.l_orderkey, inner key:tpch.orders.o_orderkey, equal cond:eq(tpch.lineitem.l_orderkey, tpch.orders.o_orderkey) │ │ ├─HashJoin_76(Build) 12232752.60 root inner join, equal:[eq(tpch.supplier.s_suppkey, tpch.lineitem.l_suppkey)] │ │ │ ├─HashJoin_84(Build) 20000.00 root inner join, equal:[eq(tpch.nation.n_nationkey, tpch.supplier.s_nationkey)] │ │ │ │ ├─TableReader_89(Build) 1.00 root data:Selection_88 │ │ │ │ │ └─Selection_88 1.00 cop[tikv] eq(tpch.nation.n_name, "EGYPT") │ │ │ │ │ └─TableFullScan_87 25.00 cop[tikv] table:nation keep order:false │ │ │ │ └─TableReader_86(Probe) 500000.00 root data:TableFullScan_85 │ │ │ │ └─TableFullScan_85 500000.00 cop[tikv] table:supplier keep order:false │ │ │ └─TableReader_92(Probe) 240004648.80 root data:Selection_91 │ │ │ └─Selection_91 240004648.80 cop[tikv] gt(tpch.lineitem.l_receiptdate, tpch.lineitem.l_commitdate) │ │ │ └─TableFullScan_90 300005811.00 cop[tikv] table:l1 keep order:false │ │ └─TableReader_69(Probe) 0.49 root data:Selection_68 │ │ └─Selection_68 0.49 cop[tikv] eq(tpch.orders.o_orderstatus, "F") │ │ └─TableRangeScan_67 1.00 cop[tikv] table:orders range: decided by [tpch.lineitem.l_orderkey], keep order:false │ └─IndexLookUp_61(Probe) 4.05 root │ ├─IndexRangeScan_59(Build) 4.05 cop[tikv] table:l2, index:PRIMARY(L_ORDERKEY, L_LINENUMBER) range: decided by [eq(tpch.lineitem.l_orderkey, tpch.lineitem.l_orderkey)], keep order:false │ └─TableRowIDScan_60(Probe) 4.05 cop[tikv] table:l2 keep order:false └─IndexLookUp_39(Probe) 4.05 root ├─IndexRangeScan_36(Build) 5.06 cop[tikv] table:l3, index:PRIMARY(L_ORDERKEY, L_LINENUMBER) range: decided by [eq(tpch.lineitem.l_orderkey, tpch.lineitem.l_orderkey)], keep order:false └─Selection_38(Probe) 4.05 cop[tikv] gt(tpch.lineitem.l_receiptdate, tpch.lineitem.l_commitdate) └─TableRowIDScan_37 5.06 cop[tikv] table:l3 keep order:false /* Q22 Global Sales Opportunity Query The Global Sales Opportunity Query identifies geographies where there are customers who may be likely to make a purchase. This query counts how many customers within a specific range of country codes have not placed orders for 7 years but who have a greater than average “positive” account balance. It also reflects the magnitude of that balance. Country code is defined as the first two characters of c_phone. */ explain select cntrycode, count(*) as numcust, sum(c_acctbal) as totacctbal from ( select substring(c_phone from 1 for 2) as cntrycode, c_acctbal from customer where substring(c_phone from 1 for 2) in ('20', '40', '22', '30', '39', '42', '21') and c_acctbal > ( select avg(c_acctbal) from customer where c_acctbal > 0.00 and substring(c_phone from 1 for 2) in ('20', '40', '22', '30', '39', '42', '21') ) and not exists ( select * from orders where o_custkey = c_custkey ) ) as custsale group by cntrycode order by cntrycode; id estRows task access object operator info Sort_39 1.00 root Column#27:asc └─Projection_41 1.00 root Column#27, Column#28, Column#29 └─HashAgg_44 1.00 root group by:Column#27, funcs:count(1)->Column#28, funcs:sum(tpch.customer.c_acctbal)->Column#29, funcs:firstrow(Column#27)->Column#27 └─Projection_45 0.00 root substring(tpch.customer.c_phone, 1, 2)->Column#27, tpch.customer.c_acctbal └─HashJoin_46 0.00 root anti semi join, equal:[eq(tpch.customer.c_custkey, tpch.orders.o_custkey)] ├─TableReader_52(Build) 75000000.00 root data:TableFullScan_51 │ └─TableFullScan_51 75000000.00 cop[tikv] table:orders keep order:false └─Selection_50(Probe) 0.00 root in(substring(tpch.customer.c_phone, 1, 2), "20", "40", "22", "30", "39", "42", "21") └─TableReader_49 0.00 root data:Selection_48 └─Selection_48 0.00 cop[tikv] gt(tpch.customer.c_acctbal, NULL) └─TableFullScan_47 7500000.00 cop[tikv] table:customer keep order:false