You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1301 lines
69 KiB
1301 lines
69 KiB
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
|
|
|