1302 lines
70 KiB
Plaintext
1302 lines
70 KiB
Plaintext
CREATE DATABASE IF NOT EXISTS TPCH50;
|
|
USE TPCH50;
|
|
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));
|
|
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));
|
|
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));
|
|
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));
|
|
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));
|
|
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 format = 'brief'
|
|
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 2.94 root tpch50.lineitem.l_returnflag, tpch50.lineitem.l_linestatus
|
|
└─Projection 2.94 root tpch50.lineitem.l_returnflag, tpch50.lineitem.l_linestatus, Column#18, Column#19, Column#20, Column#21, Column#22, Column#23, Column#24, Column#25
|
|
└─HashAgg 2.94 root group by:tpch50.lineitem.l_linestatus, tpch50.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(tpch50.lineitem.l_returnflag)->tpch50.lineitem.l_returnflag, funcs:firstrow(tpch50.lineitem.l_linestatus)->tpch50.lineitem.l_linestatus
|
|
└─TableReader 2.94 root data:HashAgg
|
|
└─HashAgg 2.94 cop[tikv] group by:tpch50.lineitem.l_linestatus, tpch50.lineitem.l_returnflag, funcs:sum(tpch50.lineitem.l_quantity)->Column#26, funcs:sum(tpch50.lineitem.l_extendedprice)->Column#27, funcs:sum(mul(tpch50.lineitem.l_extendedprice, minus(1, tpch50.lineitem.l_discount)))->Column#28, funcs:sum(mul(mul(tpch50.lineitem.l_extendedprice, minus(1, tpch50.lineitem.l_discount)), plus(1, tpch50.lineitem.l_tax)))->Column#29, funcs:count(tpch50.lineitem.l_quantity)->Column#30, funcs:sum(tpch50.lineitem.l_quantity)->Column#31, funcs:count(tpch50.lineitem.l_extendedprice)->Column#32, funcs:sum(tpch50.lineitem.l_extendedprice)->Column#33, funcs:count(tpch50.lineitem.l_discount)->Column#34, funcs:sum(tpch50.lineitem.l_discount)->Column#35, funcs:count(1)->Column#36
|
|
└─Selection 293797075.24 cop[tikv] le(tpch50.lineitem.l_shipdate, 1998-08-15 00:00:00.000000)
|
|
└─TableFullScan 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 format = 'brief'
|
|
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 100.00 root tpch50.supplier.s_acctbal, tpch50.supplier.s_name, tpch50.nation.n_name, tpch50.part.p_partkey, tpch50.part.p_mfgr, tpch50.supplier.s_address, tpch50.supplier.s_phone, tpch50.supplier.s_comment
|
|
└─TopN 100.00 root tpch50.supplier.s_acctbal:desc, tpch50.nation.n_name, tpch50.supplier.s_name, tpch50.part.p_partkey, offset:0, count:100
|
|
└─Projection 161842.84 root tpch50.part.p_partkey, tpch50.part.p_mfgr, tpch50.supplier.s_name, tpch50.supplier.s_address, tpch50.supplier.s_phone, tpch50.supplier.s_acctbal, tpch50.supplier.s_comment, tpch50.nation.n_name
|
|
└─HashJoin 161842.84 root inner join, equal:[eq(tpch50.part.p_partkey, tpch50.partsupp.ps_partkey) eq(tpch50.partsupp.ps_supplycost, Column#50)]
|
|
├─HashJoin(Build) 161842.84 root inner join, equal:[eq(tpch50.partsupp.ps_partkey, tpch50.part.p_partkey)]
|
|
│ ├─TableReader(Build) 161842.84 root data:Selection
|
|
│ │ └─Selection 161842.84 cop[tikv] eq(tpch50.part.p_size, 30), like(tpch50.part.p_type, "%STEEL", 92)
|
|
│ │ └─TableFullScan 10000000.00 cop[tikv] table:part keep order:false
|
|
│ └─HashJoin(Probe) 8021852.14 root inner join, equal:[eq(tpch50.supplier.s_suppkey, tpch50.partsupp.ps_suppkey)]
|
|
│ ├─HashJoin(Build) 99997.20 root inner join, equal:[eq(tpch50.nation.n_nationkey, tpch50.supplier.s_nationkey)]
|
|
│ │ ├─HashJoin(Build) 5.00 root inner join, equal:[eq(tpch50.region.r_regionkey, tpch50.nation.n_regionkey)]
|
|
│ │ │ ├─TableReader(Build) 1.00 root data:Selection
|
|
│ │ │ │ └─Selection 1.00 cop[tikv] eq(tpch50.region.r_name, "ASIA")
|
|
│ │ │ │ └─TableFullScan 5.00 cop[tikv] table:region keep order:false
|
|
│ │ │ └─TableReader(Probe) 25.00 root data:TableFullScan
|
|
│ │ │ └─TableFullScan 25.00 cop[tikv] table:nation keep order:false
|
|
│ │ └─TableReader(Probe) 500000.00 root data:TableFullScan
|
|
│ │ └─TableFullScan 500000.00 cop[tikv] table:supplier keep order:false
|
|
│ └─TableReader(Probe) 40000000.00 root data:TableFullScan
|
|
│ └─TableFullScan 40000000.00 cop[tikv] table:partsupp keep order:false
|
|
└─Selection(Probe) 6417481.71 root not(isnull(Column#50))
|
|
└─HashAgg 8021852.14 root group by:tpch50.partsupp.ps_partkey, funcs:min(tpch50.partsupp.ps_supplycost)->Column#50, funcs:firstrow(tpch50.partsupp.ps_partkey)->tpch50.partsupp.ps_partkey
|
|
└─HashJoin 8021852.14 root inner join, equal:[eq(tpch50.supplier.s_suppkey, tpch50.partsupp.ps_suppkey)]
|
|
├─HashJoin(Build) 99997.20 root inner join, equal:[eq(tpch50.nation.n_nationkey, tpch50.supplier.s_nationkey)]
|
|
│ ├─HashJoin(Build) 5.00 root inner join, equal:[eq(tpch50.region.r_regionkey, tpch50.nation.n_regionkey)]
|
|
│ │ ├─TableReader(Build) 1.00 root data:Selection
|
|
│ │ │ └─Selection 1.00 cop[tikv] eq(tpch50.region.r_name, "ASIA")
|
|
│ │ │ └─TableFullScan 5.00 cop[tikv] table:region keep order:false
|
|
│ │ └─TableReader(Probe) 25.00 root data:TableFullScan
|
|
│ │ └─TableFullScan 25.00 cop[tikv] table:nation keep order:false
|
|
│ └─TableReader(Probe) 500000.00 root data:TableFullScan
|
|
│ └─TableFullScan 500000.00 cop[tikv] table:supplier keep order:false
|
|
└─TableReader(Probe) 40000000.00 root data:TableFullScan
|
|
└─TableFullScan 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 format = 'brief'
|
|
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 10.00 root tpch50.lineitem.l_orderkey, Column#35, tpch50.orders.o_orderdate, tpch50.orders.o_shippriority
|
|
└─TopN 10.00 root Column#35:desc, tpch50.orders.o_orderdate, offset:0, count:10
|
|
└─HashAgg 39877917.22 root group by:Column#45, Column#46, Column#47, funcs:sum(Column#44)->Column#35, funcs:firstrow(Column#45)->tpch50.orders.o_orderdate, funcs:firstrow(Column#46)->tpch50.orders.o_shippriority, funcs:firstrow(Column#47)->tpch50.lineitem.l_orderkey
|
|
└─Projection 93262952.04 root mul(tpch50.lineitem.l_extendedprice, minus(1, tpch50.lineitem.l_discount))->Column#44, tpch50.orders.o_orderdate->Column#45, tpch50.orders.o_shippriority->Column#46, tpch50.lineitem.l_orderkey->Column#47
|
|
└─IndexHashJoin 93262952.04 root inner join, inner:IndexLookUp, outer key:tpch50.orders.o_orderkey, inner key:tpch50.lineitem.l_orderkey, equal cond:eq(tpch50.orders.o_orderkey, tpch50.lineitem.l_orderkey)
|
|
├─HashJoin(Build) 22975885.46 root inner join, equal:[eq(tpch50.customer.c_custkey, tpch50.orders.o_custkey)]
|
|
│ ├─TableReader(Build) 1508884.60 root data:Selection
|
|
│ │ └─Selection 1508884.60 cop[tikv] eq(tpch50.customer.c_mktsegment, "AUTOMOBILE")
|
|
│ │ └─TableFullScan 7500000.00 cop[tikv] table:customer keep order:false
|
|
│ └─TableReader(Probe) 36496376.60 root data:Selection
|
|
│ └─Selection 36496376.60 cop[tikv] lt(tpch50.orders.o_orderdate, 1995-03-13 00:00:00.000000)
|
|
│ └─TableFullScan 75000000.00 cop[tikv] table:orders keep order:false
|
|
└─IndexLookUp(Probe) 93262952.04 root
|
|
├─IndexRangeScan(Build) 172850029.03 cop[tikv] table:lineitem, index:PRIMARY(L_ORDERKEY, L_LINENUMBER) range: decided by [eq(tpch50.lineitem.l_orderkey, tpch50.orders.o_orderkey)], keep order:false
|
|
└─Selection(Probe) 93262952.04 cop[tikv] gt(tpch50.lineitem.l_shipdate, 1995-03-13 00:00:00.000000)
|
|
└─TableRowIDScan 172850029.03 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 format = 'brief'
|
|
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 1.00 root tpch50.orders.o_orderpriority
|
|
└─Projection 1.00 root tpch50.orders.o_orderpriority, Column#27
|
|
└─HashAgg 1.00 root group by:tpch50.orders.o_orderpriority, funcs:count(1)->Column#27, funcs:firstrow(tpch50.orders.o_orderpriority)->tpch50.orders.o_orderpriority
|
|
└─IndexHashJoin 2255437.92 root semi join, inner:IndexLookUp, outer key:tpch50.orders.o_orderkey, inner key:tpch50.lineitem.l_orderkey, equal cond:eq(tpch50.orders.o_orderkey, tpch50.lineitem.l_orderkey)
|
|
├─TableReader(Build) 2819297.40 root data:Selection
|
|
│ └─Selection 2819297.40 cop[tikv] ge(tpch50.orders.o_orderdate, 1995-01-01 00:00:00.000000), lt(tpch50.orders.o_orderdate, 1995-04-01 00:00:00.000000)
|
|
│ └─TableFullScan 75000000.00 cop[tikv] table:orders keep order:false
|
|
└─IndexLookUp(Probe) 11443998.48 root
|
|
├─IndexRangeScan(Build) 14304998.10 cop[tikv] table:lineitem, index:PRIMARY(L_ORDERKEY, L_LINENUMBER) range: decided by [eq(tpch50.lineitem.l_orderkey, tpch50.orders.o_orderkey)], keep order:false
|
|
└─Selection(Probe) 11443998.48 cop[tikv] lt(tpch50.lineitem.l_commitdate, tpch50.lineitem.l_receiptdate)
|
|
└─TableRowIDScan 14304998.10 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 format = 'brief'
|
|
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 5.00 root Column#49:desc
|
|
└─Projection 5.00 root tpch50.nation.n_name, Column#49
|
|
└─HashAgg 5.00 root group by:Column#51, funcs:sum(Column#50)->Column#49, funcs:firstrow(Column#51)->tpch50.nation.n_name
|
|
└─Projection 11432277.85 root mul(tpch50.lineitem.l_extendedprice, minus(1, tpch50.lineitem.l_discount))->Column#50, tpch50.nation.n_name->Column#51
|
|
└─Projection 11432277.85 root tpch50.lineitem.l_extendedprice, tpch50.lineitem.l_discount, tpch50.nation.n_name
|
|
└─HashJoin 11432277.85 root inner join, equal:[eq(tpch50.orders.o_custkey, tpch50.customer.c_custkey) eq(tpch50.supplier.s_nationkey, tpch50.customer.c_nationkey)]
|
|
├─TableReader(Build) 7500000.00 root data:TableFullScan
|
|
│ └─TableFullScan 7500000.00 cop[tikv] table:customer keep order:false
|
|
└─HashJoin(Probe) 11432277.85 root inner join, equal:[eq(tpch50.lineitem.l_orderkey, tpch50.orders.o_orderkey)]
|
|
├─TableReader(Build) 11432277.85 root data:Selection
|
|
│ └─Selection 11432277.85 cop[tikv] ge(tpch50.orders.o_orderdate, 1994-01-01 00:00:00.000000), lt(tpch50.orders.o_orderdate, 1995-01-01 00:00:00.000000)
|
|
│ └─TableFullScan 75000000.00 cop[tikv] table:orders keep order:false
|
|
└─HashJoin(Probe) 60165056.40 root inner join, equal:[eq(tpch50.supplier.s_suppkey, tpch50.lineitem.l_suppkey)]
|
|
├─HashJoin(Build) 99997.20 root inner join, equal:[eq(tpch50.nation.n_nationkey, tpch50.supplier.s_nationkey)]
|
|
│ ├─HashJoin(Build) 5.00 root inner join, equal:[eq(tpch50.region.r_regionkey, tpch50.nation.n_regionkey)]
|
|
│ │ ├─TableReader(Build) 1.00 root data:Selection
|
|
│ │ │ └─Selection 1.00 cop[tikv] eq(tpch50.region.r_name, "MIDDLE EAST")
|
|
│ │ │ └─TableFullScan 5.00 cop[tikv] table:region keep order:false
|
|
│ │ └─TableReader(Probe) 25.00 root data:TableFullScan
|
|
│ │ └─TableFullScan 25.00 cop[tikv] table:nation keep order:false
|
|
│ └─TableReader(Probe) 500000.00 root data:TableFullScan
|
|
│ └─TableFullScan 500000.00 cop[tikv] table:supplier keep order:false
|
|
└─TableReader(Probe) 300005811.00 root data:TableFullScan
|
|
└─TableFullScan 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 format = 'brief'
|
|
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
|
|
HashAgg 1.00 root funcs:sum(Column#19)->Column#18
|
|
└─TableReader 1.00 root data:HashAgg
|
|
└─HashAgg 1.00 cop[tikv] funcs:sum(mul(tpch50.lineitem.l_extendedprice, tpch50.lineitem.l_discount))->Column#19
|
|
└─Selection 5664883.88 cop[tikv] ge(tpch50.lineitem.l_discount, 0.05), ge(tpch50.lineitem.l_shipdate, 1994-01-01 00:00:00.000000), le(tpch50.lineitem.l_discount, 0.07), lt(tpch50.lineitem.l_quantity, 24), lt(tpch50.lineitem.l_shipdate, 1995-01-01 00:00:00.000000)
|
|
└─TableFullScan 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 format = 'brief'
|
|
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 766.31 root tpch50.nation.n_name, tpch50.nation.n_name, Column#50
|
|
└─Projection 766.31 root tpch50.nation.n_name, tpch50.nation.n_name, Column#50, Column#52
|
|
└─HashAgg 766.31 root group by:Column#56, Column#57, Column#58, funcs:sum(Column#55)->Column#52, funcs:firstrow(Column#56)->tpch50.nation.n_name, funcs:firstrow(Column#57)->tpch50.nation.n_name, funcs:firstrow(Column#58)->Column#50
|
|
└─Projection 1953718.78 root mul(tpch50.lineitem.l_extendedprice, minus(1, tpch50.lineitem.l_discount))->Column#55, tpch50.nation.n_name->Column#56, tpch50.nation.n_name->Column#57, extract(YEAR, tpch50.lineitem.l_shipdate)->Column#58
|
|
└─Projection 1953718.78 root tpch50.lineitem.l_extendedprice, tpch50.lineitem.l_discount, tpch50.lineitem.l_shipdate, tpch50.nation.n_name, tpch50.nation.n_name
|
|
└─HashJoin 1953718.78 root inner join, equal:[eq(tpch50.customer.c_nationkey, tpch50.nation.n_nationkey)], other cond:or(and(eq(tpch50.nation.n_name, "JAPAN"), eq(tpch50.nation.n_name, "INDIA")), and(eq(tpch50.nation.n_name, "INDIA"), eq(tpch50.nation.n_name, "JAPAN")))
|
|
├─TableReader(Build) 2.00 root data:Selection
|
|
│ └─Selection 2.00 cop[tikv] or(eq(tpch50.nation.n_name, "INDIA"), eq(tpch50.nation.n_name, "JAPAN"))
|
|
│ └─TableFullScan 25.00 cop[tikv] table:n2 keep order:false
|
|
└─HashJoin(Probe) 24421527.06 root inner join, equal:[eq(tpch50.orders.o_custkey, tpch50.customer.c_custkey)]
|
|
├─TableReader(Build) 7500000.00 root data:TableFullScan
|
|
│ └─TableFullScan 7500000.00 cop[tikv] table:customer keep order:false
|
|
└─IndexJoin(Probe) 24421527.06 root inner join, inner:TableReader, outer key:tpch50.lineitem.l_orderkey, inner key:tpch50.orders.o_orderkey, equal cond:eq(tpch50.lineitem.l_orderkey, tpch50.orders.o_orderkey)
|
|
├─HashJoin(Build) 24066022.56 root inner join, equal:[eq(tpch50.supplier.s_suppkey, tpch50.lineitem.l_suppkey)]
|
|
│ ├─HashJoin(Build) 39998.88 root inner join, equal:[eq(tpch50.nation.n_nationkey, tpch50.supplier.s_nationkey)]
|
|
│ │ ├─TableReader(Build) 2.00 root data:Selection
|
|
│ │ │ └─Selection 2.00 cop[tikv] or(eq(tpch50.nation.n_name, "JAPAN"), eq(tpch50.nation.n_name, "INDIA"))
|
|
│ │ │ └─TableFullScan 25.00 cop[tikv] table:n1 keep order:false
|
|
│ │ └─TableReader(Probe) 500000.00 root data:TableFullScan
|
|
│ │ └─TableFullScan 500000.00 cop[tikv] table:supplier keep order:false
|
|
│ └─TableReader(Probe) 91012370.27 root data:Selection
|
|
│ └─Selection 91012370.27 cop[tikv] ge(tpch50.lineitem.l_shipdate, 1995-01-01 00:00:00.000000), le(tpch50.lineitem.l_shipdate, 1996-12-31 00:00:00.000000)
|
|
│ └─TableFullScan 300005811.00 cop[tikv] table:lineitem keep order:false
|
|
└─TableReader(Probe) 24066022.56 root data:TableRangeScan
|
|
└─TableRangeScan 24066022.56 cop[tikv] table:orders range: decided by [tpch50.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 format = 'brief'
|
|
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 724.08 root Column#62
|
|
└─Projection 724.08 root Column#62, div(Column#64, Column#65)->Column#66
|
|
└─HashAgg 724.08 root group by:Column#77, funcs:sum(Column#75)->Column#64, funcs:sum(Column#76)->Column#65, funcs:firstrow(Column#77)->Column#62
|
|
└─Projection 632534.06 root case(eq(tpch50.nation.n_name, INDIA), mul(tpch50.lineitem.l_extendedprice, minus(1, tpch50.lineitem.l_discount)), 0.0000)->Column#75, mul(tpch50.lineitem.l_extendedprice, minus(1, tpch50.lineitem.l_discount))->Column#76, extract(YEAR, tpch50.orders.o_orderdate)->Column#77
|
|
└─Projection 632534.06 root tpch50.lineitem.l_extendedprice, tpch50.lineitem.l_discount, tpch50.orders.o_orderdate, tpch50.nation.n_name
|
|
└─HashJoin 632534.06 root inner join, equal:[eq(tpch50.supplier.s_nationkey, tpch50.nation.n_nationkey)]
|
|
├─TableReader(Build) 25.00 root data:TableFullScan
|
|
│ └─TableFullScan 25.00 cop[tikv] table:n2 keep order:false
|
|
└─HashJoin(Probe) 632551.77 root inner join, equal:[eq(tpch50.lineitem.l_suppkey, tpch50.supplier.s_suppkey)]
|
|
├─TableReader(Build) 500000.00 root data:TableFullScan
|
|
│ └─TableFullScan 500000.00 cop[tikv] table:supplier keep order:false
|
|
└─HashJoin(Probe) 630810.99 root inner join, equal:[eq(tpch50.lineitem.l_partkey, tpch50.part.p_partkey)]
|
|
├─TableReader(Build) 68614.00 root data:Selection
|
|
│ └─Selection 68614.00 cop[tikv] eq(tpch50.part.p_type, "SMALL PLATED COPPER")
|
|
│ └─TableFullScan 10000000.00 cop[tikv] table:part keep order:false
|
|
└─IndexHashJoin(Probe) 91619637.90 root inner join, inner:IndexLookUp, outer key:tpch50.orders.o_orderkey, inner key:tpch50.lineitem.l_orderkey, equal cond:eq(tpch50.orders.o_orderkey, tpch50.lineitem.l_orderkey)
|
|
├─HashJoin(Build) 22571045.20 root inner join, equal:[eq(tpch50.customer.c_custkey, tpch50.orders.o_custkey)]
|
|
│ ├─HashJoin(Build) 1499997.40 root inner join, equal:[eq(tpch50.nation.n_nationkey, tpch50.customer.c_nationkey)]
|
|
│ │ ├─HashJoin(Build) 5.00 root inner join, equal:[eq(tpch50.region.r_regionkey, tpch50.nation.n_regionkey)]
|
|
│ │ │ ├─TableReader(Build) 1.00 root data:Selection
|
|
│ │ │ │ └─Selection 1.00 cop[tikv] eq(tpch50.region.r_name, "ASIA")
|
|
│ │ │ │ └─TableFullScan 5.00 cop[tikv] table:region keep order:false
|
|
│ │ │ └─TableReader(Probe) 25.00 root data:TableFullScan
|
|
│ │ │ └─TableFullScan 25.00 cop[tikv] table:n1 keep order:false
|
|
│ │ └─TableReader(Probe) 7500000.00 root data:TableFullScan
|
|
│ │ └─TableFullScan 7500000.00 cop[tikv] table:customer keep order:false
|
|
│ └─TableReader(Probe) 22571045.20 root data:Selection
|
|
│ └─Selection 22571045.20 cop[tikv] ge(tpch50.orders.o_orderdate, 1995-01-01 00:00:00.000000), le(tpch50.orders.o_orderdate, 1996-12-31 00:00:00.000000)
|
|
│ └─TableFullScan 75000000.00 cop[tikv] table:orders keep order:false
|
|
└─IndexLookUp(Probe) 91619637.90 root
|
|
├─IndexRangeScan(Build) 91619637.90 cop[tikv] table:lineitem, index:PRIMARY(L_ORDERKEY, L_LINENUMBER) range: decided by [eq(tpch50.lineitem.l_orderkey, tpch50.orders.o_orderkey)], keep order:false
|
|
└─TableRowIDScan(Probe) 91619637.90 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 format = 'brief'
|
|
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 2406.00 root tpch50.nation.n_name, Column#53:desc
|
|
└─Projection 2406.00 root tpch50.nation.n_name, Column#53, Column#55
|
|
└─HashAgg 2406.00 root group by:Column#65, Column#66, funcs:sum(Column#64)->Column#55, funcs:firstrow(Column#65)->tpch50.nation.n_name, funcs:firstrow(Column#66)->Column#53
|
|
└─Projection 247789900.85 root minus(mul(tpch50.lineitem.l_extendedprice, minus(1, tpch50.lineitem.l_discount)), mul(tpch50.partsupp.ps_supplycost, tpch50.lineitem.l_quantity))->Column#64, tpch50.nation.n_name->Column#65, extract(YEAR, tpch50.orders.o_orderdate)->Column#66
|
|
└─Projection 247789900.85 root tpch50.lineitem.l_quantity, tpch50.lineitem.l_extendedprice, tpch50.lineitem.l_discount, tpch50.partsupp.ps_supplycost, tpch50.orders.o_orderdate, tpch50.nation.n_name
|
|
└─HashJoin 247789900.85 root inner join, equal:[eq(tpch50.lineitem.l_orderkey, tpch50.orders.o_orderkey)]
|
|
├─TableReader(Build) 75000000.00 root data:TableFullScan
|
|
│ └─TableFullScan 75000000.00 cop[tikv] table:orders keep order:false
|
|
└─HashJoin(Probe) 244182819.96 root inner join, equal:[eq(tpch50.lineitem.l_suppkey, tpch50.partsupp.ps_suppkey) eq(tpch50.lineitem.l_partkey, tpch50.partsupp.ps_partkey)]
|
|
├─TableReader(Build) 40000000.00 root data:TableFullScan
|
|
│ └─TableFullScan 40000000.00 cop[tikv] table:partsupp keep order:false
|
|
└─HashJoin(Probe) 241491729.94 root inner join, equal:[eq(tpch50.lineitem.l_partkey, tpch50.part.p_partkey)]
|
|
├─TableReader(Build) 8000000.00 root data:Selection
|
|
│ └─Selection 8000000.00 cop[tikv] like(tpch50.part.p_name, "%dim%", 92)
|
|
│ └─TableFullScan 10000000.00 cop[tikv] table:part keep order:false
|
|
└─HashJoin(Probe) 300825282.01 root inner join, equal:[eq(tpch50.supplier.s_suppkey, tpch50.lineitem.l_suppkey)]
|
|
├─HashJoin(Build) 499986.00 root inner join, equal:[eq(tpch50.nation.n_nationkey, tpch50.supplier.s_nationkey)]
|
|
│ ├─TableReader(Build) 25.00 root data:TableFullScan
|
|
│ │ └─TableFullScan 25.00 cop[tikv] table:nation keep order:false
|
|
│ └─TableReader(Probe) 500000.00 root data:TableFullScan
|
|
│ └─TableFullScan 500000.00 cop[tikv] table:supplier keep order:false
|
|
└─TableReader(Probe) 300005811.00 root data:TableFullScan
|
|
└─TableFullScan 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 format = 'brief'
|
|
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 20.00 root tpch50.customer.c_custkey, tpch50.customer.c_name, Column#39, tpch50.customer.c_acctbal, tpch50.nation.n_name, tpch50.customer.c_address, tpch50.customer.c_phone, tpch50.customer.c_comment
|
|
└─TopN 20.00 root Column#39:desc, offset:0, count:20
|
|
└─HashAgg 2862424.30 root group by:Column#46, Column#47, Column#48, Column#49, Column#50, Column#51, Column#52, funcs:sum(Column#45)->Column#39, funcs:firstrow(Column#46)->tpch50.customer.c_custkey, funcs:firstrow(Column#47)->tpch50.customer.c_name, funcs:firstrow(Column#48)->tpch50.customer.c_address, funcs:firstrow(Column#49)->tpch50.customer.c_phone, funcs:firstrow(Column#50)->tpch50.customer.c_acctbal, funcs:firstrow(Column#51)->tpch50.customer.c_comment, funcs:firstrow(Column#52)->tpch50.nation.n_name
|
|
└─Projection 11619057.76 root mul(tpch50.lineitem.l_extendedprice, minus(1, tpch50.lineitem.l_discount))->Column#45, tpch50.customer.c_custkey->Column#46, tpch50.customer.c_name->Column#47, tpch50.customer.c_address->Column#48, tpch50.customer.c_phone->Column#49, tpch50.customer.c_acctbal->Column#50, tpch50.customer.c_comment->Column#51, tpch50.nation.n_name->Column#52
|
|
└─Projection 11619057.76 root tpch50.customer.c_custkey, tpch50.customer.c_name, tpch50.customer.c_address, tpch50.customer.c_phone, tpch50.customer.c_acctbal, tpch50.customer.c_comment, tpch50.lineitem.l_extendedprice, tpch50.lineitem.l_discount, tpch50.nation.n_name
|
|
└─IndexHashJoin 11619057.76 root inner join, inner:IndexLookUp, outer key:tpch50.orders.o_orderkey, inner key:tpch50.lineitem.l_orderkey, equal cond:eq(tpch50.orders.o_orderkey, tpch50.lineitem.l_orderkey)
|
|
├─HashJoin(Build) 2862424.30 root inner join, equal:[eq(tpch50.customer.c_custkey, tpch50.orders.o_custkey)]
|
|
│ ├─TableReader(Build) 2862424.30 root data:Selection
|
|
│ │ └─Selection 2862424.30 cop[tikv] ge(tpch50.orders.o_orderdate, 1993-08-01 00:00:00.000000), lt(tpch50.orders.o_orderdate, 1993-11-01 00:00:00.000000)
|
|
│ │ └─TableFullScan 75000000.00 cop[tikv] table:orders keep order:false
|
|
│ └─HashJoin(Probe) 7499987.00 root inner join, equal:[eq(tpch50.nation.n_nationkey, tpch50.customer.c_nationkey)]
|
|
│ ├─TableReader(Build) 25.00 root data:TableFullScan
|
|
│ │ └─TableFullScan 25.00 cop[tikv] table:nation keep order:false
|
|
│ └─TableReader(Probe) 7500000.00 root data:TableFullScan
|
|
│ └─TableFullScan 7500000.00 cop[tikv] table:customer keep order:false
|
|
└─IndexLookUp(Probe) 11619057.76 root
|
|
├─IndexRangeScan(Build) 47063565.11 cop[tikv] table:lineitem, index:PRIMARY(L_ORDERKEY, L_LINENUMBER) range: decided by [eq(tpch50.lineitem.l_orderkey, tpch50.orders.o_orderkey)], keep order:false
|
|
└─Selection(Probe) 11619057.76 cop[tikv] eq(tpch50.lineitem.l_returnflag, "R")
|
|
└─TableRowIDScan 47063565.11 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 format = 'brief'
|
|
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 1283496.34 root tpch50.partsupp.ps_partkey, Column#35->Column#58
|
|
└─Sort 1283496.34 root Column#35:desc
|
|
└─Selection 1283496.34 root gt(Column#35, NULL)
|
|
└─HashAgg 1604370.43 root group by:Column#60, funcs:sum(Column#59)->Column#35, funcs:firstrow(Column#60)->tpch50.partsupp.ps_partkey
|
|
└─Projection 1604370.43 root mul(tpch50.partsupp.ps_supplycost, cast(tpch50.partsupp.ps_availqty, decimal(10,0) BINARY))->Column#59, tpch50.partsupp.ps_partkey->Column#60
|
|
└─HashJoin 1604370.43 root inner join, equal:[eq(tpch50.supplier.s_suppkey, tpch50.partsupp.ps_suppkey)]
|
|
├─HashJoin(Build) 19999.44 root inner join, equal:[eq(tpch50.nation.n_nationkey, tpch50.supplier.s_nationkey)]
|
|
│ ├─TableReader(Build) 1.00 root data:Selection
|
|
│ │ └─Selection 1.00 cop[tikv] eq(tpch50.nation.n_name, "MOZAMBIQUE")
|
|
│ │ └─TableFullScan 25.00 cop[tikv] table:nation keep order:false
|
|
│ └─TableReader(Probe) 500000.00 root data:TableFullScan
|
|
│ └─TableFullScan 500000.00 cop[tikv] table:supplier keep order:false
|
|
└─TableReader(Probe) 40000000.00 root data:TableFullScan
|
|
└─TableFullScan 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 format = 'brief'
|
|
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 1.00 root tpch50.lineitem.l_shipmode
|
|
└─Projection 1.00 root tpch50.lineitem.l_shipmode, Column#27, Column#28
|
|
└─HashAgg 1.00 root group by:Column#39, funcs:sum(Column#37)->Column#27, funcs:sum(Column#38)->Column#28, funcs:firstrow(Column#39)->tpch50.lineitem.l_shipmode
|
|
└─Projection 10682371.54 root cast(case(or(eq(tpch50.orders.o_orderpriority, 1-URGENT), eq(tpch50.orders.o_orderpriority, 2-HIGH)), 1, 0), decimal(20,0) BINARY)->Column#37, cast(case(and(ne(tpch50.orders.o_orderpriority, 1-URGENT), ne(tpch50.orders.o_orderpriority, 2-HIGH)), 1, 0), decimal(20,0) BINARY)->Column#38, tpch50.lineitem.l_shipmode->Column#39
|
|
└─Projection 10682371.54 root tpch50.orders.o_orderpriority, tpch50.lineitem.l_shipmode
|
|
└─IndexJoin 10682371.54 root inner join, inner:TableReader, outer key:tpch50.lineitem.l_orderkey, inner key:tpch50.orders.o_orderkey, equal cond:eq(tpch50.lineitem.l_orderkey, tpch50.orders.o_orderkey)
|
|
├─TableReader(Build) 10526868.11 root data:Selection
|
|
│ └─Selection 10526868.11 cop[tikv] ge(tpch50.lineitem.l_receiptdate, 1997-01-01 00:00:00.000000), in(tpch50.lineitem.l_shipmode, "RAIL", "FOB"), lt(tpch50.lineitem.l_commitdate, tpch50.lineitem.l_receiptdate), lt(tpch50.lineitem.l_receiptdate, 1998-01-01 00:00:00.000000), lt(tpch50.lineitem.l_shipdate, tpch50.lineitem.l_commitdate)
|
|
│ └─TableFullScan 300005811.00 cop[tikv] table:lineitem keep order:false
|
|
└─TableReader(Probe) 10526868.11 root data:TableRangeScan
|
|
└─TableRangeScan 10526868.11 cop[tikv] table:orders range: decided by [tpch50.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 format = 'brief'
|
|
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 7500000.00 root Column#19:desc, Column#18:desc
|
|
└─Projection 7500000.00 root Column#18, Column#19
|
|
└─HashAgg 7500000.00 root group by:Column#18, funcs:count(1)->Column#19, funcs:firstrow(Column#18)->Column#18
|
|
└─HashAgg 7500000.00 root group by:tpch50.customer.c_custkey, funcs:count(tpch50.orders.o_orderkey)->Column#18
|
|
└─HashJoin 60000000.00 root left outer join, equal:[eq(tpch50.customer.c_custkey, tpch50.orders.o_custkey)]
|
|
├─TableReader(Build) 7500000.00 root data:TableFullScan
|
|
│ └─TableFullScan 7500000.00 cop[tikv] table:customer keep order:false
|
|
└─TableReader(Probe) 60000000.00 root data:Selection
|
|
└─Selection 60000000.00 cop[tikv] not(like(tpch50.orders.o_comment, "%pending%deposits%", 92))
|
|
└─TableFullScan 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 format = 'brief'
|
|
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 1.00 root div(mul(100.00, Column#27), Column#28)->Column#29
|
|
└─HashAgg 1.00 root funcs:sum(Column#31)->Column#27, funcs:sum(Column#32)->Column#28
|
|
└─Projection 3844864.41 root case(like(tpch50.part.p_type, PROMO%, 92), mul(tpch50.lineitem.l_extendedprice, minus(1, tpch50.lineitem.l_discount)), 0.0000)->Column#31, mul(tpch50.lineitem.l_extendedprice, minus(1, tpch50.lineitem.l_discount))->Column#32
|
|
└─HashJoin 3844864.41 root inner join, equal:[eq(tpch50.lineitem.l_partkey, tpch50.part.p_partkey)]
|
|
├─TableReader(Build) 10000000.00 root data:TableFullScan
|
|
│ └─TableFullScan 10000000.00 cop[tikv] table:part keep order:false
|
|
└─TableReader(Probe) 3831625.78 root data:Selection
|
|
└─Selection 3831625.78 cop[tikv] ge(tpch50.lineitem.l_shipdate, 1996-12-01 00:00:00.000000), lt(tpch50.lineitem.l_shipdate, 1997-01-01 00:00:00.000000)
|
|
└─TableFullScan 300005811.00 cop[tikv] table:lineitem 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 format = 'brief'
|
|
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 14.46 root Column#23:desc, tpch50.part.p_brand, tpch50.part.p_type, tpch50.part.p_size
|
|
└─Projection 14.46 root tpch50.part.p_brand, tpch50.part.p_type, tpch50.part.p_size, Column#23
|
|
└─HashAgg 14.46 root group by:tpch50.part.p_brand, tpch50.part.p_size, tpch50.part.p_type, funcs:count(distinct tpch50.partsupp.ps_suppkey)->Column#23, funcs:firstrow(tpch50.part.p_brand)->tpch50.part.p_brand, funcs:firstrow(tpch50.part.p_type)->tpch50.part.p_type, funcs:firstrow(tpch50.part.p_size)->tpch50.part.p_size
|
|
└─HashJoin 3870097.51 root anti semi join, equal:[eq(tpch50.partsupp.ps_suppkey, tpch50.supplier.s_suppkey)]
|
|
├─TableReader(Build) 400000.00 root data:Selection
|
|
│ └─Selection 400000.00 cop[tikv] like(tpch50.supplier.s_comment, "%Customer%Complaints%", 92)
|
|
│ └─TableFullScan 500000.00 cop[tikv] table:supplier keep order:false
|
|
└─Projection(Probe) 4837621.89 root tpch50.partsupp.ps_suppkey, tpch50.part.p_brand, tpch50.part.p_type, tpch50.part.p_size
|
|
└─IndexHashJoin 4837621.89 root inner join, inner:IndexReader, outer key:tpch50.part.p_partkey, inner key:tpch50.partsupp.ps_partkey, equal cond:eq(tpch50.part.p_partkey, tpch50.partsupp.ps_partkey)
|
|
├─TableReader(Build) 1205241.25 root data:Selection
|
|
│ └─Selection 1205241.25 cop[tikv] in(tpch50.part.p_size, 48, 19, 12, 4, 41, 7, 21, 39), ne(tpch50.part.p_brand, "Brand#34"), not(like(tpch50.part.p_type, "LARGE BRUSHED%", 92))
|
|
│ └─TableFullScan 10000000.00 cop[tikv] table:part keep order:false
|
|
└─IndexReader(Probe) 4837621.89 root index:IndexRangeScan
|
|
└─IndexRangeScan 4837621.89 cop[tikv] table:partsupp, index:PRIMARY(PS_PARTKEY, PS_SUPPKEY) range: decided by [eq(tpch50.partsupp.ps_partkey, tpch50.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 format = 'brief'
|
|
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 1.00 root div(Column#46, 7.0)->Column#47
|
|
└─HashAgg 1.00 root funcs:sum(tpch50.lineitem.l_extendedprice)->Column#46
|
|
└─HashJoin 306544.42 root inner join, equal:[eq(tpch50.part.p_partkey, tpch50.lineitem.l_partkey)], other cond:lt(tpch50.lineitem.l_quantity, mul(0.2, Column#44))
|
|
├─HashJoin(Build) 306544.42 root inner join, equal:[eq(tpch50.part.p_partkey, tpch50.lineitem.l_partkey)]
|
|
│ ├─TableReader(Build) 10182.77 root data:Selection
|
|
│ │ └─Selection 10182.77 cop[tikv] eq(tpch50.part.p_brand, "Brand#44"), eq(tpch50.part.p_container, "WRAP PKG")
|
|
│ │ └─TableFullScan 10000000.00 cop[tikv] table:part keep order:false
|
|
│ └─TableReader(Probe) 300005811.00 root data:TableFullScan
|
|
│ └─TableFullScan 300005811.00 cop[tikv] table:lineitem keep order:false
|
|
└─HashAgg(Probe) 9965568.00 root group by:tpch50.lineitem.l_partkey, funcs:avg(Column#50, Column#51)->Column#44, funcs:firstrow(tpch50.lineitem.l_partkey)->tpch50.lineitem.l_partkey
|
|
└─TableReader 9965568.00 root data:HashAgg
|
|
└─HashAgg 9965568.00 cop[tikv] group by:tpch50.lineitem.l_partkey, funcs:count(tpch50.lineitem.l_quantity)->Column#50, funcs:sum(tpch50.lineitem.l_quantity)->Column#51
|
|
└─TableFullScan 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 format = 'brief'
|
|
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 100.00 root tpch50.customer.c_name, tpch50.customer.c_custkey, tpch50.orders.o_orderkey, tpch50.orders.o_orderdate, tpch50.orders.o_totalprice, Column#54
|
|
└─TopN 100.00 root tpch50.orders.o_totalprice:desc, tpch50.orders.o_orderdate, offset:0, count:100
|
|
└─HashAgg 60000000.00 root group by:tpch50.customer.c_custkey, tpch50.customer.c_name, tpch50.orders.o_orderdate, tpch50.orders.o_orderkey, tpch50.orders.o_totalprice, funcs:sum(tpch50.lineitem.l_quantity)->Column#54, funcs:firstrow(tpch50.customer.c_custkey)->tpch50.customer.c_custkey, funcs:firstrow(tpch50.customer.c_name)->tpch50.customer.c_name, funcs:firstrow(tpch50.orders.o_orderkey)->tpch50.orders.o_orderkey, funcs:firstrow(tpch50.orders.o_totalprice)->tpch50.orders.o_totalprice, funcs:firstrow(tpch50.orders.o_orderdate)->tpch50.orders.o_orderdate
|
|
└─IndexHashJoin 243550009.54 root inner join, inner:IndexLookUp, outer key:tpch50.orders.o_orderkey, inner key:tpch50.lineitem.l_orderkey, equal cond:eq(tpch50.orders.o_orderkey, tpch50.lineitem.l_orderkey)
|
|
├─HashJoin(Build) 60000000.00 root inner join, equal:[eq(tpch50.orders.o_orderkey, tpch50.lineitem.l_orderkey)]
|
|
│ ├─Selection(Build) 59126579.20 root gt(Column#52, 314)
|
|
│ │ └─HashAgg 73908224.00 root group by:tpch50.lineitem.l_orderkey, funcs:sum(Column#66)->Column#52, funcs:firstrow(tpch50.lineitem.l_orderkey)->tpch50.lineitem.l_orderkey
|
|
│ │ └─TableReader 73908224.00 root data:HashAgg
|
|
│ │ └─HashAgg 73908224.00 cop[tikv] group by:tpch50.lineitem.l_orderkey, funcs:sum(tpch50.lineitem.l_quantity)->Column#66
|
|
│ │ └─TableFullScan 300005811.00 cop[tikv] table:lineitem keep order:false
|
|
│ └─HashJoin(Probe) 75000000.00 root inner join, equal:[eq(tpch50.customer.c_custkey, tpch50.orders.o_custkey)]
|
|
│ ├─TableReader(Build) 7500000.00 root data:TableFullScan
|
|
│ │ └─TableFullScan 7500000.00 cop[tikv] table:customer keep order:false
|
|
│ └─TableReader(Probe) 75000000.00 root data:TableFullScan
|
|
│ └─TableFullScan 75000000.00 cop[tikv] table:orders keep order:false
|
|
└─IndexLookUp(Probe) 243550009.54 root
|
|
├─IndexRangeScan(Build) 243550009.54 cop[tikv] table:lineitem, index:PRIMARY(L_ORDERKEY, L_LINENUMBER) range: decided by [eq(tpch50.lineitem.l_orderkey, tpch50.orders.o_orderkey)], keep order:false
|
|
└─TableRowIDScan(Probe) 243550009.54 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 format = 'brief'
|
|
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
|
|
HashAgg 1.00 root funcs:sum(Column#28)->Column#27
|
|
└─Projection 733674.05 root mul(tpch50.lineitem.l_extendedprice, minus(1, tpch50.lineitem.l_discount))->Column#28
|
|
└─HashJoin 733674.05 root inner join, equal:[eq(tpch50.part.p_partkey, tpch50.lineitem.l_partkey)], other cond:or(and(and(eq(tpch50.part.p_brand, "Brand#52"), in(tpch50.part.p_container, "SM CASE", "SM BOX", "SM PACK", "SM PKG")), and(ge(tpch50.lineitem.l_quantity, 4), and(le(tpch50.lineitem.l_quantity, 14), le(tpch50.part.p_size, 5)))), or(and(and(eq(tpch50.part.p_brand, "Brand#11"), in(tpch50.part.p_container, "MED BAG", "MED BOX", "MED PKG", "MED PACK")), and(ge(tpch50.lineitem.l_quantity, 18), and(le(tpch50.lineitem.l_quantity, 28), le(tpch50.part.p_size, 10)))), and(and(eq(tpch50.part.p_brand, "Brand#51"), in(tpch50.part.p_container, "LG CASE", "LG BOX", "LG PACK", "LG PKG")), and(ge(tpch50.lineitem.l_quantity, 29), and(le(tpch50.lineitem.l_quantity, 39), le(tpch50.part.p_size, 15))))))
|
|
├─TableReader(Build) 24371.12 root data:Selection
|
|
│ └─Selection 24371.12 cop[tikv] ge(tpch50.part.p_size, 1), or(and(eq(tpch50.part.p_brand, "Brand#52"), and(in(tpch50.part.p_container, "SM CASE", "SM BOX", "SM PACK", "SM PKG"), le(tpch50.part.p_size, 5))), or(and(eq(tpch50.part.p_brand, "Brand#11"), and(in(tpch50.part.p_container, "MED BAG", "MED BOX", "MED PKG", "MED PACK"), le(tpch50.part.p_size, 10))), and(eq(tpch50.part.p_brand, "Brand#51"), and(in(tpch50.part.p_container, "LG CASE", "LG BOX", "LG PACK", "LG PKG"), le(tpch50.part.p_size, 15)))))
|
|
│ └─TableFullScan 10000000.00 cop[tikv] table:part keep order:false
|
|
└─TableReader(Probe) 7052102.43 root data:Selection
|
|
└─Selection 7052102.43 cop[tikv] eq(tpch50.lineitem.l_shipinstruct, "DELIVER IN PERSON"), in(tpch50.lineitem.l_shipmode, "AIR", "AIR REG"), or(and(ge(tpch50.lineitem.l_quantity, 4), le(tpch50.lineitem.l_quantity, 14)), or(and(ge(tpch50.lineitem.l_quantity, 18), le(tpch50.lineitem.l_quantity, 28)), and(ge(tpch50.lineitem.l_quantity, 29), le(tpch50.lineitem.l_quantity, 39))))
|
|
└─TableFullScan 300005811.00 cop[tikv] table:lineitem 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 format = 'brief'
|
|
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 19999.44 root tpch50.supplier.s_name
|
|
└─HashJoin 19999.44 root inner join, equal:[eq(tpch50.supplier.s_suppkey, tpch50.partsupp.ps_suppkey)]
|
|
├─HashAgg(Build) 125724.99 root group by:tpch50.partsupp.ps_suppkey, funcs:firstrow(tpch50.partsupp.ps_suppkey)->tpch50.partsupp.ps_suppkey
|
|
│ └─Selection 125724.99 root gt(cast(tpch50.partsupp.ps_availqty, decimal(10,0) BINARY), mul(0.5, Column#44))
|
|
│ └─HashAgg 157156.24 root group by:tpch50.partsupp.ps_partkey, tpch50.partsupp.ps_suppkey, funcs:firstrow(tpch50.partsupp.ps_suppkey)->tpch50.partsupp.ps_suppkey, funcs:firstrow(tpch50.partsupp.ps_availqty)->tpch50.partsupp.ps_availqty, funcs:sum(tpch50.lineitem.l_quantity)->Column#44
|
|
│ └─HashJoin 4731068.54 root left outer join, equal:[eq(tpch50.partsupp.ps_partkey, tpch50.lineitem.l_partkey) eq(tpch50.partsupp.ps_suppkey, tpch50.lineitem.l_suppkey)]
|
|
│ ├─IndexHashJoin(Build) 157156.24 root inner join, inner:IndexLookUp, outer key:tpch50.part.p_partkey, inner key:tpch50.partsupp.ps_partkey, equal cond:eq(tpch50.part.p_partkey, tpch50.partsupp.ps_partkey)
|
|
│ │ ├─TableReader(Build) 39153.78 root data:Selection
|
|
│ │ │ └─Selection 39153.78 cop[tikv] like(tpch50.part.p_name, "green%", 92)
|
|
│ │ │ └─TableFullScan 10000000.00 cop[tikv] table:part keep order:false
|
|
│ │ └─IndexLookUp(Probe) 157156.24 root
|
|
│ │ ├─IndexRangeScan(Build) 157156.24 cop[tikv] table:partsupp, index:PRIMARY(PS_PARTKEY, PS_SUPPKEY) range: decided by [eq(tpch50.partsupp.ps_partkey, tpch50.part.p_partkey)], keep order:false
|
|
│ │ └─TableRowIDScan(Probe) 157156.24 cop[tikv] table:partsupp keep order:false
|
|
│ └─TableReader(Probe) 45476974.50 root data:Selection
|
|
│ └─Selection 45476974.50 cop[tikv] ge(tpch50.lineitem.l_shipdate, 1993-01-01 00:00:00.000000), lt(tpch50.lineitem.l_shipdate, 1994-01-01 00:00:00.000000)
|
|
│ └─TableFullScan 300005811.00 cop[tikv] table:lineitem keep order:false
|
|
└─HashJoin(Probe) 19999.44 root inner join, equal:[eq(tpch50.nation.n_nationkey, tpch50.supplier.s_nationkey)]
|
|
├─TableReader(Build) 1.00 root data:Selection
|
|
│ └─Selection 1.00 cop[tikv] eq(tpch50.nation.n_name, "ALGERIA")
|
|
│ └─TableFullScan 25.00 cop[tikv] table:nation keep order:false
|
|
└─TableReader(Probe) 500000.00 root data:TableFullScan
|
|
└─TableFullScan 500000.00 cop[tikv] table:supplier 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 format = 'brief'
|
|
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 100.00 root tpch50.supplier.s_name, Column#72
|
|
└─TopN 100.00 root Column#72:desc, tpch50.supplier.s_name, offset:0, count:100
|
|
└─HashAgg 12799.64 root group by:tpch50.supplier.s_name, funcs:count(1)->Column#72, funcs:firstrow(tpch50.supplier.s_name)->tpch50.supplier.s_name
|
|
└─IndexHashJoin 7814888.66 root anti semi join, inner:IndexLookUp, outer key:tpch50.lineitem.l_orderkey, inner key:tpch50.lineitem.l_orderkey, equal cond:eq(tpch50.lineitem.l_orderkey, tpch50.lineitem.l_orderkey), other cond:ne(tpch50.lineitem.l_suppkey, tpch50.lineitem.l_suppkey)
|
|
├─IndexHashJoin(Build) 9768610.82 root semi join, inner:IndexLookUp, outer key:tpch50.lineitem.l_orderkey, inner key:tpch50.lineitem.l_orderkey, equal cond:eq(tpch50.lineitem.l_orderkey, tpch50.lineitem.l_orderkey), other cond:ne(tpch50.lineitem.l_suppkey, tpch50.lineitem.l_suppkey), ne(tpch50.lineitem.l_suppkey, tpch50.supplier.s_suppkey)
|
|
│ ├─IndexJoin(Build) 12210763.53 root inner join, inner:TableReader, outer key:tpch50.lineitem.l_orderkey, inner key:tpch50.orders.o_orderkey, equal cond:eq(tpch50.lineitem.l_orderkey, tpch50.orders.o_orderkey)
|
|
│ │ ├─HashJoin(Build) 12033011.28 root inner join, equal:[eq(tpch50.supplier.s_suppkey, tpch50.lineitem.l_suppkey)]
|
|
│ │ │ ├─HashJoin(Build) 19999.44 root inner join, equal:[eq(tpch50.nation.n_nationkey, tpch50.supplier.s_nationkey)]
|
|
│ │ │ │ ├─TableReader(Build) 1.00 root data:Selection
|
|
│ │ │ │ │ └─Selection 1.00 cop[tikv] eq(tpch50.nation.n_name, "EGYPT")
|
|
│ │ │ │ │ └─TableFullScan 25.00 cop[tikv] table:nation keep order:false
|
|
│ │ │ │ └─TableReader(Probe) 500000.00 root data:TableFullScan
|
|
│ │ │ │ └─TableFullScan 500000.00 cop[tikv] table:supplier keep order:false
|
|
│ │ │ └─TableReader(Probe) 240004648.80 root data:Selection
|
|
│ │ │ └─Selection 240004648.80 cop[tikv] gt(tpch50.lineitem.l_receiptdate, tpch50.lineitem.l_commitdate)
|
|
│ │ │ └─TableFullScan 300005811.00 cop[tikv] table:l1 keep order:false
|
|
│ │ └─TableReader(Probe) 5883323.31 root data:Selection
|
|
│ │ └─Selection 5883323.31 cop[tikv] eq(tpch50.orders.o_orderstatus, "F")
|
|
│ │ └─TableRangeScan 12033011.28 cop[tikv] table:orders range: decided by [tpch50.lineitem.l_orderkey], keep order:false
|
|
│ └─IndexLookUp(Probe) 49565526.23 root
|
|
│ ├─IndexRangeScan(Build) 49565526.23 cop[tikv] table:l2, index:PRIMARY(L_ORDERKEY, L_LINENUMBER) range: decided by [eq(tpch50.lineitem.l_orderkey, tpch50.lineitem.l_orderkey)], keep order:false
|
|
│ └─TableRowIDScan(Probe) 49565526.23 cop[tikv] table:l2 keep order:false
|
|
└─IndexLookUp(Probe) 39652420.98 root
|
|
├─IndexRangeScan(Build) 49565526.23 cop[tikv] table:l3, index:PRIMARY(L_ORDERKEY, L_LINENUMBER) range: decided by [eq(tpch50.lineitem.l_orderkey, tpch50.lineitem.l_orderkey)], keep order:false
|
|
└─Selection(Probe) 39652420.98 cop[tikv] gt(tpch50.lineitem.l_receiptdate, tpch50.lineitem.l_commitdate)
|
|
└─TableRowIDScan 49565526.23 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 format = 'brief'
|
|
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 1.00 root Column#31
|
|
└─Projection 1.00 root Column#31, Column#32, Column#33
|
|
└─HashAgg 1.00 root group by:Column#36, funcs:count(1)->Column#32, funcs:sum(Column#35)->Column#33, funcs:firstrow(Column#36)->Column#31
|
|
└─Projection 0.64 root tpch50.customer.c_acctbal->Column#35, substring(tpch50.customer.c_phone, 1, 2)->Column#36
|
|
└─HashJoin 0.64 root anti semi join, equal:[eq(tpch50.customer.c_custkey, tpch50.orders.o_custkey)]
|
|
├─TableReader(Build) 75000000.00 root data:TableFullScan
|
|
│ └─TableFullScan 75000000.00 cop[tikv] table:orders keep order:false
|
|
└─TableReader(Probe) 0.80 root data:Selection
|
|
└─Selection 0.80 cop[tikv] gt(tpch50.customer.c_acctbal, NULL), in(substring(tpch50.customer.c_phone, 1, 2), "20", "40", "22", "30", "39", "42", "21")
|
|
└─TableFullScan 7500000.00 cop[tikv] table:customer keep order:false
|