版權(quán)說明：本文檔由用戶提供并上傳，收益歸屬內(nèi)容提供方，若內(nèi)容存在侵權(quán)，請進(jìn)行舉報(bào)或認(rèn)領(lǐng)
文檔簡介
1案發(fā)現(xiàn)場前幾天，我收到了一封報(bào)警郵件，提示有一條慢查詢SQL。我打開郵件查看了詳情，那條SQL大概是這樣的：SELECT
count(*)
FROM
spu
s1
WHERE
EXISTS
(
SELECT
*
FROM
sku
s2
INNER
JOIN
mall_sku
s3
ON
s3.sku_id
=
s2.id
WHERE
s2.spu_id
=
s1.id
AND
s2.status
=
1
AND
NOT
EXISTS
(
SELECT
*
FROM
supplier_sku
s4
WHERE
s4.mall_sku_id
=
s3.id
AND
s4.supplier_id
=
123456789
AND
s4.status
=
1
)
)這條SQL的含義是統(tǒng)計(jì)id=123456789的供應(yīng)商，未發(fā)布的spu數(shù)量是多少。這條SQL的耗時(shí)竟然達(dá)標(biāo)了8s，必須要做優(yōu)化了。我首先使用explain關(guān)鍵字查詢該SQL的執(zhí)行計(jì)劃，發(fā)現(xiàn)spu表走了type類型的索引，而sku、mall_sku、supplier_sku表都走了ref類型的索引。也就是說，這4張表都走了索引。不是簡單的增加索引就能解決的事情。那么，接下來該如何優(yōu)化呢？2第一次優(yōu)化這條SQL語句，其中兩個(gè)exists關(guān)鍵字引起了我的注意。一個(gè)exists是為了查詢存在某些滿足條件的商品，另一個(gè)notexists是為了查詢出不存在某些商品。這個(gè)SQL是另外一位已離職的同事寫的。不清楚spu表和sku表為什么不用join，而用了exists。我猜測可能是為了只返回spu表的數(shù)據(jù)，而做的一種處理。如果join了sku表，則可能會查出重復(fù)的數(shù)據(jù)，需要做去重處理。從目前看，這種寫性能有瓶頸。因此，我做出了第一次優(yōu)化。使用join
+
groupby組合，將sql優(yōu)化如下：SELECT
count(*)
FROM
(
select
s2.spu_id
from
spu
s1
inner
join
from
sku
s2
inner
join
mall_sku
s3
on
s3.sku_id=s2.id
where
s2.spu_id=s1.id
ans
s2.status=1
and
not
exists
(
select
*
from
supplier_sku
s4
where
s4.mall_sku_id=s3.id
and
s4.supplier_id=...
)
group
by
s2.spu_id
)
a文章中有些相同的條件省略了，由于spu_id在sku表中是增加了索引的，因此groupby的性能其實(shí)是挺快的。這樣優(yōu)化之后，sql的執(zhí)行時(shí)間變成了2.5s。性能提升了3倍多，但還是不夠快，還需要做進(jìn)一步優(yōu)化。3第二次優(yōu)化還有一個(gè)notexists可以優(yōu)化一下。如果是小表驅(qū)動大表的時(shí)候，使用notexists確實(shí)可以提升性能。但如果是大表驅(qū)動小表的時(shí)候，使用notexists可能有點(diǎn)弄巧成拙。這里exists右邊的sql的含義是查詢某供應(yīng)商的商品數(shù)據(jù)，而目前我們平臺一個(gè)供應(yīng)商的商品并不多。于是，我將notexists改成了notin。sql優(yōu)化如下：SELECT
count(*)
FROM
(
select
s2.spu_id
from
spu
s1
inner
join
from
sku
s2
inner
join
mall_sku
s3
on
s3.sku_id=s2.id
where
s2.spu_id=s1.id
ans
s2.status=1
and
s3.id
not
IN
(
select
s4.mall_sku_id
from
supplier_sku
s4
where
s4.mall_sku_id=s3.id
and
s4.supplier_id=...
)
group
by
s2.spu_id
)
a這樣優(yōu)化之后，該sql的執(zhí)行時(shí)間下降到了0.7s。之后，我再用explain關(guān)鍵字查詢該SQL的執(zhí)行計(jì)劃。發(fā)現(xiàn)spu表走了全表掃描，sku表走了eq_ref類型的索引，而mall_sku和supplier_sku表走了ref類型的索引?？梢钥闯?，有時(shí)候sql語句走了4個(gè)索引，性能未必比走了3個(gè)索引好。多張表join的時(shí)候，其中一張表走了全表掃描，說不定整個(gè)SQL語句的性能會更好，我們一定要多測試。1案發(fā)現(xiàn)場前幾天，我收到了一封報(bào)警郵件，提示有一條慢查詢SQL。我打開郵件查看了詳情，那條SQL大概是這樣的：SELECT
count(*)
FROM
spu
s1
WHERE
EXISTS
(
SELECT
*
FROM
sku
s2
INNER
JOIN
mall_sku
s3
ON
s3.sku_id
=
s2.id
WHERE
s2.spu_id
=
s1.id
AND
s2.status
=
1
AND
NOT
EXISTS
(
SELECT
*
FROM
supplier_sku
s4
WHERE
s4.mall_sku_id
=
s3.id
AND
s4.supplier_id
=
123456789
AND
s4.status
=
1
)
)這條SQL的含義是統(tǒng)計(jì)id=123456789的供應(yīng)商，未發(fā)布的spu數(shù)量是多少。這條SQL的耗時(shí)竟然達(dá)標(biāo)了8s，必須要做優(yōu)化了。我首先使用explain關(guān)鍵字查詢該SQL的執(zhí)行計(jì)劃，發(fā)現(xiàn)spu表走了type類型的索引，而sku、mall_sku、supplier_sku表都走了ref類型的索引。也就是說，這4張表都走了索引。不是簡單的增加索引就能解決的事情。那么，接下來該如何優(yōu)化呢？2第一次優(yōu)化這條SQL語句，其中兩個(gè)exists關(guān)鍵字引起了我的注意。一個(gè)exists是為了查詢存在某些滿足條件的商品，另一個(gè)notexists是為了查詢出不存在某些商品。這個(gè)SQL是另外一位已離職的同事寫的。不清楚spu表和sku表為什么不用join，而用了exists。我猜測可能是為了只返回spu表的數(shù)據(jù)，而做的一種處理。如果join了sku表，則可能會查出重復(fù)的數(shù)據(jù)，需要做去重處理。從目前看，這種寫性能有瓶頸。因此，我做出了第一次優(yōu)化。使用join
+
groupby組合，將sql優(yōu)化如下：SELECT
count(*)
FROM
(
select
s2.spu_id
from
spu
s1
inner
join
from
sku
s2
inner
join
mall_sku
s3
on
s3.sku_id=s2.id
where
s2.spu_id=s1.id
ans
s2.status=1
and
not
exists
(
select
*
from
supplier_sku
s4
where
s4.mall_sku_id=s3.id
and
s4.supplier_id=...
)
group
by
s2.spu_id
)
a文章中有些相同的條件省略了，由于spu_id在sku表中是增加了索引的，因此groupby的性能其實(shí)是挺快的。這樣優(yōu)化之后，sql的執(zhí)行時(shí)間變成了2.5s。性能提升了3倍多，但還是不夠快，還需要做進(jìn)一步優(yōu)化。3第二次優(yōu)化還有一個(gè)notexists可以優(yōu)化一下。如果是小表驅(qū)動大表的時(shí)候，使用notexists確實(shí)可以提升性能。但如果是大表驅(qū)動小表的時(shí)候，使用notexists可能有點(diǎn)弄巧成拙。這里exists右邊的sql的含義是查詢某供應(yīng)商的商品數(shù)據(jù)，而目前我們平臺一個(gè)供應(yīng)商的商品并不多。于是，我將notexists改成了notin。sql優(yōu)化如下：SELECT
count(*)
FROM
(
select
s2.spu_id
from
spu
s1
inner
join
from
sku
s2
inner
join
mall_sku
s3
on
s3.sku_id=s2.id
where
s2.spu_id=s1.id
ans
s2.status=1
and
s3.id
not
IN
(
select
s4.mall_sku_id
from
supplier_sku
s4
where
s4.mall_sku_id=s3.id
and
s4.supplier_id=...
)
group
by
s2.spu_id
)
a這樣優(yōu)化之后，該sql的執(zhí)行時(shí)間下降到了0.7s。之后，我再用explain關(guān)鍵字查詢該SQL的執(zhí)行計(jì)劃。發(fā)現(xiàn)spu表走了全表掃描，sku表走了eq_ref類型的索引，而mall_sku和supplier_sku表走了ref類型的索引。可以看出，有時(shí)候sql語句走了4個(gè)索引，性能未必比走了3個(gè)索引好。多張表join的時(shí)候，其中一張表走了全表掃描，說不定整個(gè)SQL語句的性能會更好，我們一定要多測試。1案發(fā)現(xiàn)場前幾天，我收到了一封報(bào)警郵件，提示有一條慢查詢SQL。我打開郵件查看了詳情，那條SQL大概是這樣的：SELECT
count(*)
FROM
spu
s1
WHERE
EXISTS
(
SELECT
*
FROM
sku
s2
INNER
JOIN
mall_sku
s3
ON
s3.sku_id
=
s2.id
WHERE
s2.spu_id
=
s1.id
AND
s2.status
=
1
AND
NOT
EXISTS
(
SELECT
*
FROM
supplier_sku
s4
WHERE
s4.mall_sku_id
=
s3.id
AND
s4.supplier_id
=
123456789
AND
s4.status
=
1
)
)這條SQL的含義是統(tǒng)計(jì)id=123456789的供應(yīng)商，未發(fā)布的spu數(shù)量是多少。這條SQL的耗時(shí)竟然達(dá)標(biāo)了8s，必須要做優(yōu)化了。我首先使用explain關(guān)鍵字查詢該SQL的執(zhí)行計(jì)劃，發(fā)現(xiàn)spu表走了type類型的索引，而sku、mall_sku、supplier_sku表都走了ref類型的索引。也就是說，這4張表都走了索引。不是簡單的增加索引就能解決的事情。那么，接下來該如何優(yōu)化呢？2第一次優(yōu)化這條SQL語句，其中兩個(gè)exists關(guān)鍵字引起了我的注意。一個(gè)exists是為了查詢存在某些滿足條件的商品，另一個(gè)notexists是為了查詢出不存在某些商品。這個(gè)SQL是另外一位已離職的同事寫的。不清楚spu表和sku表為什么不用join，而用了exists。我猜測可能是為了只返回spu表的數(shù)據(jù)，而做的一種處理。如果join了sku表，則可能會查出重復(fù)的數(shù)據(jù)，需要做去重處理。從目前看，這種寫性能有瓶頸。因此，我做出了第一次優(yōu)化。使用join
+
groupby組合，將sql優(yōu)化如下：SELECT
count(*)
FROM
(
select
s2.spu_id
from
spu
s1
inner
join
from
sku
s2
inner
join
mall_sku
s3
on
s3.sku_id=s2.id
where
s2.spu_id=s1.id
ans
s2.status=1
and
not
exists
(
select
*
from
supplier_sku
s4
where
s4.mall_sku_id=s3.id
and
s4.supplier_id=...
)
group
by
s2.spu_id
)
a文章中有些相同的條件省略了，由于spu_id在sku表中是增加了索引的，因此groupby的性能其實(shí)是挺快的。這樣優(yōu)化之后，sql的執(zhí)行時(shí)間變成了2.5s。性能提升了3倍多，但還是不夠快，還需要做進(jìn)一步優(yōu)化。3第二次優(yōu)化還有一個(gè)notexists可以優(yōu)化一下。如果是小表驅(qū)動大表的時(shí)候，使用notexists確實(shí)可以提升性能。但如果是大表驅(qū)動小表的時(shí)候，使用notexists可能有點(diǎn)弄巧成拙。這里exists右邊的sql的含義是查詢某供應(yīng)商的商品數(shù)據(jù)，而目前我們平臺一個(gè)供應(yīng)商的商品并不多。于是，我將notexists改成了notin。sql優(yōu)化如下：SELECT
count(*)
FROM
(
select
s2.spu_id
from
spu
s1
inner
join
from
sku
s2
inner
join
mall_sku
s3
on
s3.sku_id=s2.id
where
s2.spu_id=s1.id
ans
s2.status=1
and
s3.id
not
IN
(
select
s4.mall_sku_id
from
supplier_sku
s4
where
s4.mall_sku_id=s3.id
and
s4.supplier_id=...
)
group
by
s2.spu_id
)
a這樣優(yōu)化之后，該sql的執(zhí)行時(shí)間下降到了0.7s。之后，我再用explain關(guān)鍵字查詢該SQL的執(zhí)行計(jì)劃。發(fā)現(xiàn)spu表走了全表掃描，sku表走了eq_ref類型的索引，而mall_sku和supplier_sku表走了ref類型的索引?？梢钥闯觯袝r(shí)候sql語句走了4個(gè)索引，性能未必比走了3個(gè)索引好。多張表join的時(shí)候，其中一張表走了全表掃描，說不定整個(gè)SQL語句的性能會更好，我們一定要多測試。1案發(fā)現(xiàn)場前幾天，我收到了一封報(bào)警郵件，提示有一條慢查詢SQL。我打開郵件查看了詳情，那條SQL大概是這樣的：SELECT
count(*)
FROM
spu
s1
WHERE
EXISTS
(
SELECT
*
FROM
sku
s2
INNER
JOIN
mall_sku
s3
ON
s3.sku_id
=
s2.id
WHERE
s2.spu_id
=
s1.id
AND
s2.status
=
1
AND
NOT
EXISTS
(
SELECT
*
FROM
supplier_sku
s4
WHERE
s4.mall_sku_id
=
s3.id
AND
s4.supplier_id
=
123456789
AND
s4.status
=
1
)
)這條SQL的含義是統(tǒng)計(jì)id=123456789的供應(yīng)商，未發(fā)布的spu數(shù)量是多少。這條SQL的耗時(shí)竟然達(dá)標(biāo)了8s，必須要做優(yōu)化了。我首先使用explain關(guān)鍵字查詢該SQL的執(zhí)行計(jì)劃，發(fā)現(xiàn)spu表走了type類型的索引，而sku、mall_sku、supplier_sku表都走了ref類型的索引。也就是說，這4張表都走了索引。不是簡單的增加索引就能解決的事情。那么，接下來該如何優(yōu)化呢？2第一次優(yōu)化這條SQL語句，其中兩個(gè)exists關(guān)鍵字引起了我的注意。一個(gè)exists是為了查詢存在某些滿足條件的商品，另一個(gè)notexists是為了查詢出不存在某些商品。這個(gè)SQL是另外一位已離職的同事寫的。不清楚spu表和sku表為什么不用join，而用了exists。我猜測可能是為了只返回spu表的數(shù)據(jù)，而做的一種處理。如果join了sku表，則可能會查出重復(fù)的數(shù)據(jù)，需要做去重處理。從目前看，這種寫性能有瓶頸。因此，我做出了第一次優(yōu)化。使用join
+
groupby組合，將sql優(yōu)化如下：SELECT
count(*)
FROM
(
select
s2.spu_id
from
spu
s1
inner
join
from
sku
s2
inner
join
mall_sku
s3
on
s3.sku_id=s2.id
where
s2.spu_id=s1.id
ans
s2.status=1
and
not
exists
(
select
*
from
supplier_sku
s4
where
s4.mall_sku_id=s3.id
and
s4.supplier_id=...
)
group
by
s2.spu_id
)
a文章中有些相同的條件省略了，由于spu_id在sku表中是增加了索引的，因此groupby的性能其實(shí)是挺快的。這樣優(yōu)化之后，sql的執(zhí)行時(shí)間變成了2.5s。性能提升了3倍多，但還是不夠快，還需要做進(jìn)一步優(yōu)化。3第二次優(yōu)化還有一個(gè)notexists可以優(yōu)化一下。如果是小表驅(qū)動大表的時(shí)候，使用notexists確實(shí)可以提升性能。但如果是大表驅(qū)動小表的時(shí)候，使用notexists可能有點(diǎn)弄巧成拙。這里exists右邊的sql的含義是查詢某供應(yīng)商的商品數(shù)據(jù)，而目前我們平臺一個(gè)供應(yīng)商的商品并不多。于是，我將notexists改成了notin。sql優(yōu)化如下：SELECT
count(*)
FROM
(
select
s2.spu_id
from
spu
s1
inner
join
from
sku
s2
inner
join
mall_sku
s3
on
s3.sku_id=s2.id
where
s2.spu_id=s1.id
ans
s2.status=1
and
s3.id
not
IN
(
select
s4.mall_sku_id
from
supplier_sku
s4
where
s4.mall_sku_id=s3.id
and
s4.supplier_id=...
)
group
by
s2.spu_id
)
a這樣優(yōu)化之后，該sql的執(zhí)行時(shí)間下降到了0.7s。之后，我再用explain關(guān)鍵字查詢該SQL的執(zhí)行計(jì)劃。發(fā)現(xiàn)spu表走了全表掃描，sku表走了eq_ref類型的索引，而mall_sku和supplier_sku表走了ref類型的索引?？梢钥闯?，有時(shí)候sql語句走了4個(gè)索引，性能未必比走了3個(gè)索引好。多張表join的時(shí)候，其中一張表走了全表掃描，說不定整個(gè)SQL語句的性能會更好，我們一定要多測試。1案發(fā)現(xiàn)場前幾天，我收到了一封報(bào)警郵件，提示有一條慢查詢SQL。我打開郵件查看了詳情，那條SQL大概是這樣的：SELECT
count(*)
FROM
spu
s1
WHERE
EXISTS
(
SELECT
*
FROM
sku
s2
INNER
JOIN
mall_sku
s3
ON
s3.sku_id
=
s2.id
WHERE
s2.spu_id
=
s1.id
AND
s2.status
=
1
AND
NOT
EXISTS
(
SELECT
*
FROM
supplier_sku
s4
WHERE
s4.mall_sku_id
=
s3.id
AND
s4.supplier_id
=
123456789
AND
s4.status
=
1
)
)這條SQL的含義是統(tǒng)計(jì)id=123456789的供應(yīng)商，未發(fā)布的spu數(shù)量是多少。這條SQL的耗時(shí)竟然達(dá)標(biāo)了8s，必須要做優(yōu)化了。我首先使用explain關(guān)鍵字查詢該SQL的執(zhí)行計(jì)劃，發(fā)現(xiàn)spu表走了type類型的索引，而sku、mall_sku、supplier_sku表都走了ref類型的索引。也就是說，這4張表都走了索引。不是簡單的增加索引就能解決的事情。那么，接下來該如何優(yōu)化呢？2第一次優(yōu)化這條SQL語句，其中兩個(gè)exists關(guān)鍵字引起了我的注意。一個(gè)exists是為了查詢存在某些滿足條件的商品，另一個(gè)notexists是為了查詢出不存在某些商品。這個(gè)SQL是另外一位已離職的同事寫的。不清楚spu表和sku表為什么不用join，而用了exists。我猜測可能是為了只返回spu表的數(shù)據(jù)，而做的一種處理。如果join了sku表，則可能會查出重復(fù)的數(shù)據(jù)，需要做去重處理。從目前看，這種寫性能有瓶頸。因此，我做出了第一次優(yōu)化。使用join
+
groupby組合，將sql優(yōu)化如下：SELECT
count(*)
FROM
(
select
s2.spu_id
from
spu
s1
inner
join
from
sku
s2
inner
join
mall_sku
s3
on
s3.sku_id=s2.id
where
s2.spu_id=s1.id
ans
s2.status=1
and
not
exists
(
select
*
from
supplier_sku
s4
where
s4.mall_sku_id=s3.id
and
s4.supplier_id=...
)
group
by
s2.spu_id
)
a文章中有些相同的條件省略了，由于spu_id在sku表中是增加了索引的，因此groupby的性能其實(shí)是挺快的。這樣優(yōu)化之后，sql的執(zhí)行時(shí)間變成了2.5s。性能提升了3倍多，但還是不夠快，還需要做進(jìn)一步優(yōu)化。3第二次優(yōu)化還有一個(gè)notexists可以優(yōu)化一下。如果是小表驅(qū)動大表的時(shí)候，使用notexists確實(shí)可以提升性能。但如果是大表驅(qū)動小表的時(shí)候，使用notexists可能有點(diǎn)弄巧成拙。這里exists右邊的sql的含義是查詢某供應(yīng)商的商品數(shù)據(jù)，而目前我們平臺一個(gè)供應(yīng)商的商品并不多。于是，我將notexists改成了notin。sql優(yōu)化如下：SELECT
count(*)
FROM
(
select
s2.spu_id
from
spu
s1
inner
join
from
sku
s2
inner
join
mall_sku
s3
on
s3.sku_id=s2.id
where
s2.spu_id=s1.id
ans
s2.status=1
and
s3.id
not
IN
(
select
s4.mall_sku_id
from
supplier_sku
s4
where
s4.mall_sku_id=s3.id
and
s4.supplier_id=...
)
group
by
s2.spu_id
)
a這樣優(yōu)化之后，該sql的執(zhí)行時(shí)間下降到了0.7s。之后，我再用explain關(guān)鍵字查詢該SQL的執(zhí)行計(jì)劃。發(fā)現(xiàn)spu表走了全表掃描，sku表走了eq_ref類型的索引，而mall_sku和supplier_sku表走了ref類型的索引。可以看出，有時(shí)候sql語句走了4個(gè)索引，性能未必比走了3個(gè)索引好。多張表join的時(shí)候，其中一張表走了全表掃描，說不定整個(gè)SQL語句的性能會更好，我們一定要多測試。1案發(fā)現(xiàn)場前幾天，我收到了一封報(bào)警郵件，提示有一條慢查詢SQL。我打開郵件查看了詳情，那條SQL大概是這樣的：SELECT
count(*)
FROM
spu
s1
WHERE
EXISTS
(
SELECT
*
FROM
sku
s2
INNER
JOIN
mall_sku
s3
ON
s3.sku_id
=
s2.id
WHERE
s2.spu_id
=
s1.id
AND
s2.status
=
1
AND
NOT
EXISTS
(
SELECT
*
FROM
supplier_sku
s4
WHERE
s4.mall_sku_id
=
s3.id
AND
s4.supplier_id
=
123456789
AND
s4.status
=
1
)
)這條SQL的含義是統(tǒng)計(jì)id=123456789的供應(yīng)商，未發(fā)布的spu數(shù)量是多少。這條SQL的耗時(shí)竟然達(dá)標(biāo)了8s，必須要做優(yōu)化了。我首先使用explain關(guān)鍵字查詢該SQL的執(zhí)行計(jì)劃，發(fā)現(xiàn)spu表走了type類型的索引，而sku、mall_sku、supplier_sku表都走了ref類型的索引。也就是說，這4張表都走了索引。不是簡單的增加索引就能解決的事情。那么，接下來該如何優(yōu)化呢？2第一次優(yōu)化這條SQL語句，其中兩個(gè)exists關(guān)鍵字引起了我的注意。一個(gè)exists是為了查詢存在某些滿足條件的商品，另一個(gè)notexists是為了查詢出不存在某些商品。這個(gè)SQL是另外一位已離職的同事寫的。不清楚spu表和sku表為什么不用join，而用了exists。我猜測可能是為了只返回spu表的數(shù)據(jù)，而做的一種處理。如果join了sku表，則可能會查出重復(fù)的數(shù)據(jù)，需要做去重處理。從目前看，這種寫性能有瓶頸。因此，我做出了第一次優(yōu)化。使用join
+
groupby組合，將sql優(yōu)化如下：SELECT
count(*)
FROM
(
select
s2.spu_id
from
spu
s1
inner
join
from
sku
s2
inner
join
mall_sku
s3
on
s3.sku_id=s2.id
where
s2.spu_id=s1.id
ans
s2.status=1
and
not
exists
(
select
*
from
supplier_sku
s4
where
s4.mall_sku_id=s3.id
and
s4.supplier_id=...
)
group
by
s2.spu_id
)
a文章中有些相同的條件省略了，由于spu_id在sku表中是增加了索引的，因此groupby的性能其實(shí)是挺快的。這樣優(yōu)化之后，sql的執(zhí)行時(shí)間變成了2.5s。性能提升了3倍多，但還是不夠快，還需要做進(jìn)一步優(yōu)化。3第二次優(yōu)化還有一個(gè)notexists可以優(yōu)化一下。如果是小表驅(qū)動大表的時(shí)候，使用notexists確實(shí)可以提升性能。但如果是大表驅(qū)動小表的時(shí)候，使用notexists可能有點(diǎn)弄巧成拙。這里exists右邊的sql的含義是查詢某供應(yīng)商的商品數(shù)據(jù)，而目前我們平臺一個(gè)供應(yīng)商的商品并不多。于是，我將notexists改成了notin。sql優(yōu)化如下：SELECT
count(*)
FROM
(
select
s2.spu_id
from
spu
s1
inner
join
from
sku
s2
inner
join
mall_sku
s3
on
s3.sku_id=s2.id
where
s2.spu_id=s1.id
ans
s2.status=1
and
s3.id
not
IN
(
select
s4.mall_sku_id
from
supplier_sku
s4
where
s4.mall_sku_id=s3.id
and
s4.supplier_id=...
)
group
by
s2.spu_id
)
a這樣優(yōu)化之后，該sql的執(zhí)行時(shí)間下降到了0.7s。之后，我再用explain關(guān)鍵字查詢該SQL的執(zhí)行計(jì)劃。發(fā)現(xiàn)spu表走了全表掃描，sku表走了eq_ref類型的索引，而mall_sku和supplier_sku表走了ref類型的索引。可以看出，有時(shí)候sql語句走了4個(gè)索引，性能未必比走了3個(gè)索引好。多張表join的時(shí)候，其中一張表走了全表掃描，說不定整個(gè)SQL語句的性能會更好，我們一定要多測試。1案發(fā)現(xiàn)場前幾天，我收到了一封報(bào)警郵件，提示有一條慢查詢SQL。我打開郵件查看了詳情，那條SQL大概是這樣的：SELECT
count(*)
FROM
spu
s1
WHERE
EXISTS
(
SELECT
*
FROM
sku
s2
INNER
JOIN
mall_sku
s3
ON
s3.sku_id
=
s2.id
WHERE
s2.spu_id
=
s1.id
AND
s2.status
=
1
AND
NOT
EXISTS
(
SELECT
*
FROM
supplier_sku
s4
WHERE
s4.mall_sku_id
=
s3.id
AND
s4.supplier_id
=
123456789
AND
s4.status
=
1
)
)這條SQL的含義是統(tǒng)計(jì)id=123456789的供應(yīng)商，未發(fā)布的spu數(shù)量是多少。這條SQL的耗時(shí)竟然達(dá)標(biāo)了8s，必須要做優(yōu)化了。我首先使用explain關(guān)鍵字查詢該SQL的執(zhí)行計(jì)劃，發(fā)現(xiàn)spu表走了type類型的索引，而sku、mall_sku、supplier_sku表都走了ref類型的索引。也就是說，這4張表都走了索引。不是簡單的增加索引就能解決的事情。那么，接下來該如何優(yōu)化呢？2第一次優(yōu)化這條SQL語句，其中兩個(gè)exists關(guān)鍵字引起了我的注意。一個(gè)exists是為了查詢存在某些滿足條件的商品，另一個(gè)notexists是為了查詢出不存在某些商品。這個(gè)SQL是另外一位已離職的同事寫的。不清楚spu表和sku表為什么不用join，而用了exists。我猜測可能是為了只返回spu表的數(shù)據(jù)，而做的一種處理。如果join了sku表，則可能會查出重復(fù)的數(shù)據(jù)，需要做去重處理。從目前看，這種寫性能有瓶頸。因此，我做出了第一次優(yōu)化。使用join
+
groupby組合，將sql優(yōu)化如下：SELECT
count(*)
FROM
(
select
s2.spu_id
from
spu
s1
inner
join
from
sku
s2
inner
join
mall_sku
s3
on
s3.sku_id=s2.id
where
s2.spu_id=s1.id
ans
s2.status=1
and
not
exists
(
select
*
from
supplier_sku
s4
where
s4.mall_sku_id=s3.id
and
s4.supplier_id=...
)
group
by
s2.spu_id
)
a文章中有些相同的條件省略了，由于spu_id在sku表中是增加了索引的，因此groupby的性能其實(shí)是挺快的。這樣優(yōu)化之后，sql的執(zhí)行時(shí)間變成了2.5s。性能提升了3倍多，但還是不夠快，還需要做進(jìn)一步優(yōu)化。3第二次優(yōu)化還有一個(gè)notexists可以優(yōu)化一下。如果是小表驅(qū)動大表的時(shí)候，使用notexists確實(shí)可以提升性能。但如果是大表驅(qū)動小表的時(shí)候，使用notexists可能有點(diǎn)弄巧成拙。這里exists右邊的sql的含義是查詢某供應(yīng)商的商品數(shù)據(jù)，而目前我們平臺一個(gè)供應(yīng)商的商品并不多。于是，我將notexists改成了notin。sql優(yōu)化如下：SELECT
count(*)
FROM
(
select
s2.spu_id
from
spu
s1
inner
join
from
sku
s2
inner
join
mall_sku
s3
on
s3.sku_id=s2.id
where
s2.spu_id=s1.id
ans
s2.status=1
and
s3.id
not
IN
(
select
s4.mall_sku_id
from
supplier_sku
s4
where
s4.mall_sku_id=s3.id
and
s4.supplier_id=...
)
group
by
s2.spu_id
)
a這樣優(yōu)化之后，該sql的執(zhí)行時(shí)間下降到了0.7s。之后，我再用explain關(guān)鍵字查詢該SQL的執(zhí)行計(jì)劃。發(fā)現(xiàn)spu表走了全表掃描，sku表走了eq_ref類型的索引，而mall_sku和supplier_sku表走了ref類型的索引?？梢钥闯?，有時(shí)候sql語句走了4個(gè)索引，性能未必比走了3個(gè)索引好。多張表join的時(shí)候，其中一張表走了全表掃描，說不定整個(gè)SQL語句的性能會更好，我們一定要多測試。1案發(fā)現(xiàn)場前幾天，我收到了一封報(bào)警郵件，提示有一條慢查詢SQL。我打開郵件查看了詳情，那條SQL大概是這樣的：SELECT
count(*)
FROM
spu
s1
WHERE
EXISTS
(
SELECT
*
FROM
sku
s2
INNER
JOIN
mall_sku
s3
ON
s3.sku_id
=
s2.id
WHERE
s2.spu_id
=
s1.id
AND
s2.status
=
1
AND
NOT
EXISTS
(
SELECT
*
FROM
supplier_sku
s4
WHERE
s4.mall_sku_id
=
s3.id
AND
s4.supplier_id
=
123456789
AND
s4.status
=
1
)
)這條SQL的含義是統(tǒng)計(jì)id=123456789的供應(yīng)商，未發(fā)布的spu數(shù)量是多少。這條SQL的耗時(shí)竟然達(dá)標(biāo)了8s，必須要做優(yōu)化了。我首先使用explain關(guān)鍵字查詢該SQL的執(zhí)行計(jì)劃，發(fā)現(xiàn)spu表走了type類型的索引，而sku、mall_sku、supplier_sku表都走了ref類型的索引。也就是說，這4張表都走了索引。不是簡單的增加索引就能解決的事情。那么，接下來該如何優(yōu)化呢？2第一次優(yōu)化這條SQL語句，其中兩個(gè)exists關(guān)鍵字引起了我的注意。一個(gè)exists是為了查詢存在某些滿足條件的商品，另一個(gè)notexists是為了查詢出不存在某些商品。這個(gè)SQL是另外一位已離職的同事寫的。不清楚spu表和sku表為什么不用join，而用了exists。我猜測可能是為了只返回spu表的數(shù)據(jù)，而做的一種處理。如果join了sku表，則可能會查出重復(fù)的數(shù)據(jù)，需要做去重處理。從目前看，這種寫性能有瓶頸。因此，我做出了第一次優(yōu)化。使用join
+
groupby組合，將sql優(yōu)化如下：SELECT
count(*)
FROM
(
select
s2.spu_id
from
spu
s1
inner
join
from
sku
s2
inner
join
mall_sku
s3
on
s3.sku_id=s2.id
where
s2.spu_id=s1.id
ans
s2.status=1
and
not
exists
(
select
*
from
supplier_sku
s4
where
s4.mall_sku_id=s3.id
and
s4.supplier_id=...
)
group
by
s2.spu_id
)
a文章中有些相同的條件省略了，由于spu_id在sku表中是增加了索引的，因此groupby的性能其實(shí)是挺快的。這樣優(yōu)化之后，sql的執(zhí)行時(shí)間變成了2.5s。性能提升了3倍多，但還是不夠快，還需要做進(jìn)一步優(yōu)化。3第二次優(yōu)化還有一個(gè)notexists可以優(yōu)化一下。如果是小表驅(qū)動大表的時(shí)候，使用notexists確實(shí)可以提升性能。但如果是大表驅(qū)動小表的時(shí)候，使用notexists可能有點(diǎn)弄巧成拙。這里exists右邊的sql的含義是查詢某供應(yīng)商的商品數(shù)據(jù)，而目前我們平臺一個(gè)供應(yīng)商的商品并不多。于是，我將notexists改成了notin。sql優(yōu)化如下：SELECT
count(*)
FROM
(
select
s2.spu_id
from
spu
s1
inner
join
from
sku
s2
inner
join
mall_sku
s3
on
s3.sku_id=s2.id
where
s2.spu_id=s1.id
ans
s2.status=1
and
s3.id
not
IN
(
select
s4.mall_sku_id
from
supplier_sku
s4
where
s4.mall_sku_id=s3.id
and
s4.supplier_id=...
)
group
by
s2.spu_id
)
a這樣優(yōu)化之后，該sql的執(zhí)行時(shí)間下降到了0.7s。之后，我再用explain關(guān)鍵字查詢該SQL的執(zhí)行計(jì)劃。發(fā)現(xiàn)spu表走了全表掃描，sku表走了eq_ref類型的索引，而mall_sku和supplier_sku表走了ref類型的索引?？梢钥闯?，有時(shí)候sql語句走了4個(gè)索引，性能未必比走了3個(gè)索引好。多張表join的時(shí)候，其中一張表走了全表掃描，說不定整個(gè)SQL語句的性能會更好，我們一定要多測試。1案發(fā)現(xiàn)場前幾天，我收到了一封報(bào)警郵件，提示有一條慢查詢SQL。我打開郵件查看了詳情，那條SQL大概是這樣的：SELECT
count(*)
FROM
spu
s1
WHERE
EXISTS
(
SELECT
*
FROM
sku
s2
INNER
JOIN
mall_sku
s3
ON
s3.sku_id
=
s2.id
WHERE
s2.spu_id
=
s1.id
AND
s2.status
=
1
AND
NOT
EXISTS
(
SELECT
*
FROM
supplier_sku
s4
WHERE
s4.mall_sku_id
=
s3.id
AND
s4.supplier_id
=
123456789
AND
s4.status
=
1
)
)這條SQL的含義是統(tǒng)計(jì)id=123456789的供應(yīng)商，未發(fā)布的spu數(shù)量是多少。這條SQL的耗時(shí)竟然達(dá)標(biāo)了8s，必須要做優(yōu)化了。我首先使用explain關(guān)鍵字查詢該SQL的執(zhí)行計(jì)劃，發(fā)現(xiàn)spu表走了type類型的索引，而sku、mall_sku、supplier_sku表都走了ref類型的索引。也就是說，這4張表都走了索引。不是簡單的增加索引就能解決的事情。那么，接下來該如何優(yōu)化呢？2第一次優(yōu)化這條SQL語句，其中兩個(gè)exists關(guān)鍵字引起了我的注意。一個(gè)exists是為了查詢存在某些滿足條件的商品，另一個(gè)notexists是為了查詢出不存在某些商品。這個(gè)SQL是另外一位已離職的同事寫的。不清楚spu表和sku表為什么不用join，而用了exists。我猜測可能是為了只返回spu表的數(shù)據(jù)，而做的一種處理。如果join了sku表，則可能會查出重復(fù)的數(shù)據(jù)，需要做去重處理。從目前看，這種寫性能有瓶頸。因此，我做出了第一次優(yōu)化。使用join
+
groupby組合，將sql優(yōu)化如下：SELECT
count(*)
FROM
(
select
s2.spu_id
from
spu
s1
inner
join
from
sku
s2
inner
join
mall_sku
s3
on
s3.sku_id=s2.id
where
s2.spu_id=s1.id
ans
s2.status=1
and
not
exists
(
select
*
from
supplier_sku
s4
where
s4.mall_sku_id=s3.id
and
s4.supplier_id=...
)
group
by
s2.spu_id
)
a文章中有些相同的條件省略了，由于spu_id在sku表中是增加了索引的，因此groupby的性能其實(shí)是挺快的。這樣優(yōu)化之后，sql的執(zhí)行時(shí)間變成了2.5s。性能提升了3倍多，但還是不夠快，還需要做進(jìn)一步優(yōu)化。3第二次優(yōu)化還有一個(gè)notexists可以優(yōu)化一下。如果是小表驅(qū)動大表的時(shí)候，使用notexists確實(shí)可以提升性能。但如果是大表驅(qū)動小表的時(shí)候，使用notexists可能有點(diǎn)弄巧成拙。這里exists右邊的sql的含義是查詢某供應(yīng)商的商品數(shù)據(jù)，而目前我們平臺一個(gè)供應(yīng)商的商品并不多。于是，我將notexists改成了notin。sql優(yōu)化如下：SELECT
count(*)
FROM
(
select
s2.spu_id
from
spu
s1
inner
join
from
sku
s2
inner
join
mall_sku
s3
on
s3.sku_id=s2.id
where
s2.spu_id=s1.id
ans
s2.status=1
and
s3.id
not
IN
(
select
s4.mall_sku_id
from
supplier_sku
s4
where
s4.mall_sku_id=s3.id
and
s4.supplier_id=...
)
group
by
s2.spu_id
)
a這樣優(yōu)化之后，該sql的執(zhí)行時(shí)間下降到了0.7s。之后，我再用explain關(guān)鍵字查詢該SQL的執(zhí)行計(jì)劃。發(fā)現(xiàn)spu表走了全表掃描，sku表走了eq_ref類型的索引，而mall_sku和supplier_sku表走了ref類型的索引。可以看出，有時(shí)候sql語句走了4個(gè)索引，性能未必比走了3個(gè)索引好。多張表join的時(shí)候，其中一張表走了全表掃描，說不定整個(gè)SQL語句的性能會更好，我們一定要多測試。1案發(fā)現(xiàn)場前幾天，我收到了一封報(bào)警郵件，提示有一條慢查詢SQL。我打開郵件查看了詳情，那條SQL大概是這樣的：SELECT
count(*)
FROM
spu
s1
WHERE
EXISTS
(
SELECT
*
FROM
sku
s2
INNER
JOIN
mall_sku
s3
ON
s3.sku_id
=
s2.id
WHERE
s2.spu_id
=
s1.id
AND
s2.status
=
1
AND
NOT
EXISTS
(
SELECT
*
FROM
supplier_sku
s4
WHERE
s4.mall_sku_id
=
s3.id
AND
s4.supplier_id
=
123456789
AND
s4.status
=
1
)
)這條SQL的含義是統(tǒng)計(jì)id=123456789的供應(yīng)商，未發(fā)布的spu數(shù)量是多少。這條SQL的耗時(shí)竟然達(dá)標(biāo)了8s，必須要做優(yōu)化了。我首先使用explain關(guān)鍵字查詢該SQL的執(zhí)行計(jì)劃，發(fā)現(xiàn)spu表走了type類型的索引，而sku、mall_sku、supplier_sku表都走了ref類型的索引。也就是說，這4張表都走了索引。不是簡單的增加索引就能解決的事情。那么，接下來該如何優(yōu)化呢？2第一次優(yōu)化這條SQL語句，其中兩個(gè)exists關(guān)鍵字引起了我的注意。一個(gè)exists是為了查詢存在某些滿足條件的商品，另一個(gè)notexists是為了查詢出不存在某些商品。這個(gè)SQL是另外一位已離職的同事寫的。不清楚spu表和sku表為什么不用join，而用了exists。我猜測可能是為了只返回spu表的數(shù)據(jù)，而做的一種處理。如果join了sku表，則可能會查出重復(fù)的數(shù)據(jù)，需要做去重處理。從目前看，這種寫性能有瓶頸。因此，我做出了第一次優(yōu)化。使用join
+
groupby組合，將sql優(yōu)化如下：SELECT
count(*)
FROM
(
select
s2.spu_id
from
spu
s1
inner
join
from
sku
s2
inner
join
mall_sku
s3
on
s3.sku_id=s2.id
where
s2.spu_id=s1.id
ans
s2.status=1
and
not
exists
(
select
*
from
supplier_sku
s4
where
s4.mall_sku_id=s3.id
and
s4.supplier_id=...
)
group
by
s2.spu_id
)
a文章中有些相同的條件省略了，由于spu_id在sku表中是增加了索引的，因此groupby的性能其實(shí)是挺快的。這樣優(yōu)化之后，sql的執(zhí)行時(shí)間變成了2.5s。性能提升了3倍多，但還是不夠快，還需要做進(jìn)一步優(yōu)化。3第二次優(yōu)化還有一個(gè)notexists可以優(yōu)化一下。如果是小表驅(qū)動大表的時(shí)候，使用notexists確實(shí)可以提升性能。但如果是大表驅(qū)動小表的時(shí)候，使用notexists可能有點(diǎn)弄巧成拙。這里exists右邊的sql的含義是查詢某供應(yīng)商的商品數(shù)據(jù)，而目前我們平臺一個(gè)供應(yīng)商的商品并不多。于是，我將notexists改成了notin。sql優(yōu)化如下：SELECT
count(*)
FROM
(
select
s2.spu_id
from
spu
s1
inner
join
from
sku
s2
inner
join
mall_sku
s3
on
s3.sku_id=s2.id
where
s2.spu_id=s1.id
ans
s2.status=1
and
s3.id
not
IN
(
select
s4.mall_sku_id
from
supplier_sku
s4
where
s4.mall_sku_id=s3.id
and
s4.supplier_id=...
)
group
by
s2.spu_id
)
a這樣優(yōu)化之后，該sql的執(zhí)行時(shí)間下降到了0.7s。之后，我再用explain關(guān)鍵字查詢該SQL的執(zhí)行計(jì)劃。發(fā)現(xiàn)spu表走了全表掃描，sku表走了eq_ref類型的索引，而mall_sku和supplier_sku表走了ref類型的索引?？梢钥闯?，有時(shí)候sql語句走了4個(gè)索引，性能未必比走了3個(gè)索引好。多張表join的時(shí)候，其中一張表走了全表掃描，說不定整個(gè)SQL語句的性能會更好，我們一定要多測試。1案發(fā)現(xiàn)場前幾天，我收到了一封報(bào)警郵件，提示有一條慢查詢SQL。我打開郵件查看了詳情，那條SQL大概是這樣的：SELECT
count(*)
FROM
spu
s1
WHERE
EXISTS
(
SELECT
*
FROM
sku
s2
INNER
JOIN
mall_sku
s3
ON
s3.sku_id
=
s2.id
WHERE
s2.spu_id
=
s1.id
AND
s2.status
=
1
AND
NOT
EXISTS
(
SELECT
*
FROM
supplier_sku
s4
WHERE
s4.mall_sku_id
=
s3.id
AND
s4.supplier_id
=
123456789
AND
s4.status
=
1
)
)這條SQL的含義是統(tǒng)計(jì)id=123456789的供應(yīng)商，未發(fā)布的spu數(shù)量是多少。這條SQL的耗時(shí)竟然達(dá)標(biāo)了8s，必須要做優(yōu)化了。我首先使用explain關(guān)鍵字查詢該SQL的執(zhí)行計(jì)劃，發(fā)現(xiàn)spu表走了type類型的索引，而sku、mall_sku、supplier_sku表都走了ref類型的索引。也就是說，這4張表都走了索引。不是簡單的增加索引就能解決的事情。那么，接下來該如何優(yōu)化呢？2第一次優(yōu)化這條SQL語句，其中兩個(gè)exists關(guān)鍵字引起了我的注意。一個(gè)exists是為了查詢存在某些滿足條件的商品，另一個(gè)notexists是為了查詢出不存在某些商品。這個(gè)SQL是另外一位已離職的同事寫的。不清楚spu表和sku表為什么不用join，而用了exists。我猜測可能是為了只返回spu表的數(shù)據(jù)，而做的一種處理。如果join了sku表，則可能會查出重復(fù)的數(shù)據(jù)，需要做去重處理。從目前看，這種寫性能有瓶頸。因此，我做出了第一次優(yōu)化。使用join
+
groupby組合，將sql優(yōu)化如下：SELECT
count(*)
FROM
(
select
s2.spu_id
from
spu
s1
inner
join
from
sku
s2
inner
join
mall_sku
s3
on
s3.sku_id=s2.id
where
s2.spu_id=s1.id
ans
s2.status=1
and
not
exists
(
select
*
from
supplier_sku
s4
where
s4.mall_sku_id=s3.id
and
s4.supplier_id=...
)
group
by
s2.spu_id
)
a文章中有些相同的條件省略了，由于spu_id在sku表中是增加了索引的，因此groupby的性能其實(shí)是挺快的。這樣優(yōu)化之后，sql的執(zhí)行時(shí)間變成了2.5s。性能提升了3倍多，但還是不夠快，還需要做進(jìn)一步優(yōu)化。3第二次優(yōu)化還有一個(gè)notexists可以優(yōu)化一下。如果是小表驅(qū)動大表的時(shí)候，使用notexists確實(shí)可以提升性能。但如果是大表驅(qū)動小表的時(shí)候，使用notexists可能有點(diǎn)弄巧成拙。這里exists右邊的sql的含義是查詢某供應(yīng)商的商品數(shù)據(jù)，而目前我們平臺一個(gè)供應(yīng)商的商品并不多。于是，我將notexists改成了notin。sql優(yōu)化如下：SELECT
count(*)
FROM
(
select
s2.spu_id
from
spu
s1
inner
join
from
sku
s2
inner
join
mall_sku
s3
on
s3.sku_id=s2.id
where
s2.spu_id=s1.id
ans
s2.status=1
and
s3.id
not
IN
(
select
s4.mall_sku_id
from
supplier_sku
s4
where
s4.mall_sku_id=s3.id
and
s4.supplier_id=...
)
group
by
s2.spu_id
)
a這樣優(yōu)化之后，該sql的執(zhí)行時(shí)間下降到了0.7s。之后，我再用explain關(guān)鍵字查詢該SQL的執(zhí)行計(jì)劃。發(fā)現(xiàn)spu表走了全表掃描，sku表走了eq_ref類型的索引，而mall_sku和supplier_sku表走了ref類型的索引?？梢钥闯?，有時(shí)候sql語句走了4個(gè)索引，性能未必比走了3個(gè)索引好。多張表join的時(shí)候，其中一張表走了全表掃描，說不定整個(gè)SQL語句的性能會更好，我們一定要多測試。1案發(fā)現(xiàn)場前幾天，我收到了一封報(bào)警郵件，提示有一條慢查詢SQL。我打開郵件查看了詳情，那條SQL大概是這樣的：SELECT
count(*)
FROM
spu
s1
WHERE
EXISTS
(
SELECT
*
FROM
sku
s2
INNER
JOIN
mall_sku
s3
ON
s3.sku_id
=
s2.id
WHERE
s2.spu_id
=
s1.id
AND
s2.status
=
1
AND
NOT
EXISTS
(
SELECT
*
FROM
supplier_sku
s4
WHERE
s4.mall_sku_id
=
s3.id
AND
s4.supplier_id
=
123456789
AND
s4.status
=
1
)
)這條SQL的含義是統(tǒng)計(jì)id=123456789的供應(yīng)商，未發(fā)布的spu數(shù)量是多少。這條SQL的耗時(shí)竟然達(dá)標(biāo)了8s，必須要做優(yōu)化了。我首先使用explain關(guān)鍵字查詢該SQL的執(zhí)行計(jì)劃，發(fā)現(xiàn)spu表走了type類型的索引，而sku、mall_sku、supplier_sku表都走了ref類型的索引。也就是說，這4張表都走了索引。不是簡單的增加索引就能解決的事情。那么，接下來該如何優(yōu)化呢？2第一次優(yōu)化這條SQL語句，其中兩個(gè)exists關(guān)鍵字引起了我的注意。一個(gè)exists是為了查詢存在某些滿足條件的商品，另一個(gè)notexists是為了查詢出不存在某些商品。這個(gè)SQL是另外一位已離職的同事寫的。不清楚spu表和sku表為什么不用join，而用了exists。我猜測可能是為了只返回spu表的數(shù)據(jù)，而做的一種處理。如果join了sku表，則可能會查出重復(fù)的數(shù)據(jù)，需要做去重處理。從目前看，這種寫性能有瓶頸。因此，我做出了第一次優(yōu)化。使用join
+
groupby組合，將sql優(yōu)化如下：SELECT
count(*)
FROM
(
select
s2.spu_id
from
spu
s1
inner
join
from
sku
s2
inner
join
mall_sku
s3
on
s3.sku_id=s2.id
where
s2.spu_id=s1.id
ans
s2.status=1
and
not
exists
(
select
*
from
supplier_sku
s4
where
s4.mall_sku_id=s3.id
and
s4.supplier_id=...
)
group
by
s2.spu_id
)
a文章中有些相同的條件省略了，由于spu_id在sku表中是增加了索引的，因此groupby的性能其實(shí)是挺快的。這樣優(yōu)化之后，sql的執(zhí)行時(shí)間變成了2.5s。性能提升了3倍多，但還是不夠快，還需要做進(jìn)一步優(yōu)化。3第二次優(yōu)化還有一個(gè)notexists可以優(yōu)化一下。如果是小表驅(qū)動大表的時(shí)候，使用notexists確實(shí)可以提升性能。但如果是大表驅(qū)動小表的時(shí)候，使用notexists可能有點(diǎn)弄巧成拙。這里exists右邊的sql的含義是查詢某供應(yīng)商的商品數(shù)據(jù)，而目前我們平臺一個(gè)供應(yīng)商的商品并不多。于是，我將notexists改成了notin。sql優(yōu)化如下：SELECT
count(*)
FROM
(
select
s2.spu_id
from
spu
s1
inner
join
from
sku
s2
inner
join
mall_sku
s3
on
s3.sku_id=s2.id
where
s2.spu_id=s1.id
ans
s2.status=1
and
s3.id
not
IN
(
select
s4.mall_sku_id
from
supplier_sku
s4
where
s4.mall_sku_id=s3.id
and
s4.supplier_id=...
)
group
by
s2.spu_id
)
a這樣優(yōu)化之后，該sql的執(zhí)行時(shí)間下降到了0.7s。之后，我再用explain關(guān)鍵字查詢該SQL的執(zhí)行計(jì)劃。發(fā)現(xiàn)spu表走了全表掃描，sku表走了eq_ref類型的索引，而mall_sku和supplier_sku表走了ref類型的索引?？梢钥闯觯袝r(shí)候sql語句走了4個(gè)索引，性能未必比走了3個(gè)索引好。多張表join的時(shí)候，其中一張表走了全表掃描，說不定整個(gè)SQL語句的性能會更好，我們一定要多測試。1案發(fā)現(xiàn)場前幾天，我收到了一封報(bào)警郵件，提示有一條慢查詢SQL。我打開郵件查看了詳情，那條SQL大概是這樣的：SELECT
count(*)
FROM
spu
s1
WHERE
EXISTS
(
SELECT
*
FROM
sku
s2
INNER
JOIN
mall_sku
s3
ON
s3.sku_id
=
s2.id
WHERE
s2.spu_id
=
s1.id
AND
s2.status
=
1
AND
NOT
EXISTS
(
SELECT
*
FROM
supplier_sku
s4
WHERE
s4.mall_sku_id
=
s3.id
AND
s4.supplier_id
=
123456789
AND
s4.status
=
1
)
)這條SQL的含義是統(tǒng)計(jì)id=123456789的供應(yīng)商，未發(fā)布的spu數(shù)量是多少。這條SQL的耗時(shí)竟然達(dá)標(biāo)了8s，必須要做優(yōu)化了。我首先使用explain關(guān)鍵字查詢該SQL的執(zhí)行計(jì)劃，發(fā)現(xiàn)spu表走了type類型的索引，而sku、mall_sku、supplier_sku表都走了ref類型的索引。也就是說，這4張表都走了索引。不是簡單的增加索引就能解決的事情。那么，接下來該如何優(yōu)化呢？2第一次優(yōu)化這條SQL語句，其中兩個(gè)exists關(guān)鍵字引起了我的注意。一個(gè)exists是為了查詢存在某些滿足條件的商品，另一個(gè)notexists是為了查詢出不存在某些商品。這個(gè)SQL是另外一位已離職的同事寫的。不清楚spu表和sku表為什么不用join，而用了exists。我猜測可能是為了只返回spu表的數(shù)據(jù)，而做的一種處理。如果join了sku表，則可能會查出重復(fù)的數(shù)據(jù)，需要做去重處理。從目前看，這種寫性能有瓶頸。因此，我做出了第一次優(yōu)化。使用join
+
groupby組合，將sql優(yōu)化如下：SELECT
count(*)
FROM
(
select
s2.spu_id
from
spu
s1
inner
join
from
sku
s2
inner
join
mall_sku
s3
on
s3.sku_id=s2.id
where
s2.spu_id=s1.id
ans
s2.status=1
and
not
exists
(
select
*
from
supplier_sku
s4
where
s4.mall_sku_id=s3.id
and
s4.supplier_id=...
)
group
by
s2.spu_id
)
a文章中有些相同的條件省略了，由于spu_id在sku表中是增加了索引的，因此groupby的性能其實(shí)是挺快的。這樣優(yōu)化之后，sql的執(zhí)行時(shí)間變成了2.5s。性能提升了3倍多，但還是不夠快，還需要做進(jìn)一步優(yōu)化。3第二次優(yōu)化還有一個(gè)notexists可以優(yōu)化一下。如果是小表驅(qū)動大表的時(shí)候，使用notexists確實(shí)可以提升性能。但如果是大表驅(qū)動小表的時(shí)候，使用notexists可能有點(diǎn)弄巧成拙。這里exists右邊的sql的含義是查詢某供應(yīng)商的商品數(shù)據(jù)，而目前我們平臺一個(gè)供應(yīng)商的商品并不多。于是，我將notexists改成了notin。sql優(yōu)化如下：SELECT
count(*)
FROM
(
select
s2.spu_id
from
spu
s1
inner
join
from
sku
s2
inner
join
mall_sku
s3
on
s3.sku_id=s2.id
where
s2.spu_id=s1.id
ans
s2.status=1
and
s3.id
not
IN
(
select
s4.mall_sku_id
from
supplier_sku
s4
where
s4.mall_sku_id=s3.id
and
s4.supplier_id=...
)
group
by
s2.spu_id
)
a這樣優(yōu)化之后，該sql的執(zhí)行時(shí)間下降到了0.7s。之后，我再用explain關(guān)鍵字查詢該SQL的執(zhí)行計(jì)劃。發(fā)現(xiàn)spu表走了全表掃描，sku表走了eq_ref類型的索引，而mall_sku和supplier_sku表走了ref類型的索引?？梢钥闯觯袝r(shí)候sql語句走了4個(gè)索引，性能未必比走了3個(gè)索引好。多張表join的時(shí)候，其中一張表走了全表掃描，說不定整個(gè)SQL語句的性能會更好，我們一定要多測試。1案發(fā)現(xiàn)場前幾天，我收到了一封報(bào)警郵件，提示有一條慢查詢SQL。我打開郵件查看了詳情，那條SQL大概是這樣的：SELECT
count(*)
FROM
spu
s1
WHERE
EXISTS
(
SELECT
*
FROM
sku
s2
INNER
JOIN
mall_sku
s3
ON
s3.sku_id
=
s2.id
WHERE
s2.spu_id
=
s1.id
AND
s2.status
=
1
AND
NOT
EXISTS
(
SELECT
*
FROM
supplier_sku
s4
WHERE
s4.mall_sku_id
=
s3.id
AND
s4.supplier_id
=
123456789
AND
s4.status
=
1
)
)這條SQL的含義是統(tǒng)計(jì)id=123456789的供應(yīng)商，未發(fā)布的spu數(shù)量是多少。這條SQL的耗時(shí)竟然達(dá)標(biāo)了8s，必須要做優(yōu)化了。我首先使用explain關(guān)鍵字查詢該SQL的執(zhí)行計(jì)劃，發(fā)現(xiàn)spu表走了type類型的索引，而sku、mall_sku、supplier_sku表都走了ref類型的索引。也就是說，這4張表都走了索引。不是簡單的增加索引就能解決的事情。那么，接下來該如何優(yōu)化呢？2第一次優(yōu)化這條SQL語句，其中兩個(gè)exists關(guān)鍵字引起了我的注意。一個(gè)exists是為了查詢存在某些滿足條件的商品，另一個(gè)notexists是為了查詢出不存在某些商品。這個(gè)SQL是另外一位已離職的同事寫的。不清楚spu表和sku表為什么不用join，而用了exists。我猜測可能是為了只返回spu表的數(shù)據(jù)，而做的一種處理。如果join了sku表，則可能會查出重復(fù)的數(shù)據(jù)，需要做去重處理。從目前看，這種寫性能有瓶頸。因此，我做出了第一次優(yōu)化。使用join
+
groupby組合，將sql優(yōu)化如下：SELECT
count(*)
FROM
(
select
s2.spu_id
from
spu
s1
inner
join
from
sku
s2
inner
join
mall_sku
s3
on
s3.sku_id=s2.id
where
s2.spu_id=s1.id
ans
s2.st
溫馨提示
- 1. 本站所有資源如無特殊說明，都需要本地電腦安裝OFFICE2007和PDF閱讀器。圖紙軟件為CAD,CAXA,PROE,UG,SolidWorks等.壓縮文件請下載最新的WinRAR軟件解壓。
- 2. 本站的文檔不包含任何第三方提供的附件圖紙等，如果需要附件，請聯(lián)系上傳者。文件的所有權(quán)益歸上傳用戶所有。
- 3. 本站RAR壓縮包中若帶圖紙，網(wǎng)頁內(nèi)容里面會有圖紙預(yù)覽，若沒有圖紙預(yù)覽就沒有圖紙。
- 4. 未經(jīng)權(quán)益所有人同意不得將文件中的內(nèi)容挪作商業(yè)或盈利用途。
- 5. 人人文庫網(wǎng)僅提供信息存儲空間，僅對用戶上傳內(nèi)容的表現(xiàn)方式做保護(hù)處理，對用戶上傳分享的文檔內(nèi)容本身不做任何修改或編輯，并不能對任何下載內(nèi)容負(fù)責(zé)。
- 6. 下載文件中如有侵權(quán)或不適當(dāng)內(nèi)容，請與我們聯(lián)系，我們立即糾正。
- 7. 本站不保證下載資源的準(zhǔn)確性、安全性和完整性, 同時(shí)也不承擔(dān)用戶因使用這些下載資源對自己和他人造成任何形式的傷害或損失。
最新文檔
- 運(yùn)動健身的訓(xùn)練安排計(jì)劃
- 家政行業(yè)話務(wù)員工作總結(jié)
- 中班主題有趣的石頭
- 幼兒園大班上學(xué)期科學(xué)教案有關(guān)《磁力組合》課件
- 美容院前臺工作感受
- 生活美學(xué)創(chuàng)意課程設(shè)計(jì)
- 現(xiàn)代理論課程設(shè)計(jì)
- 2024年新型建筑工程原材料采購標(biāo)準(zhǔn)協(xié)議模板版
- 我的紙片人爸爸讀后感
- 捐贈活動領(lǐng)導(dǎo)講話稿
- 智力殘疾送教上門教案
- 2024年上海市中考數(shù)學(xué)試卷真題（含答案）
- 計(jì)算機(jī)網(wǎng)絡(luò)實(shí)驗(yàn)教程資料
- 刑事訴訟法綜合實(shí)訓(xùn)報(bào)告
- 部編版五年級上冊語文第七單元《-即景》作文500字【9篇】
- 2024年廣東能源集團(tuán)天然氣有限公司招聘筆試參考題庫附帶答案詳解
- 垃圾運(yùn)輸清運(yùn)合同
- 基礎(chǔ)工程-趙明華-第二章
- 腎病科主任述職報(bào)告
- 2023-2024全國初中物理競賽試題第11講壓強(qiáng)（解析版）
- 擴(kuò)大高水平對外開放課件
評論
0/150
提交評論