版權(quán)說明：本文檔由用戶提供并上傳，收益歸屬內(nèi)容提供方，若內(nèi)容存在侵權(quán)，請進(jìn)行舉報或認(rèn)領(lǐng)
文檔簡介
1案發(fā)現(xiàn)場前幾天，我收到了一封報警郵件，提示有一條慢查詢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的耗時竟然達(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語句，其中兩個exists關(guān)鍵字引起了我的注意。一個exists是為了查詢存在某些滿足條件的商品，另一個notexists是為了查詢出不存在某些商品。這個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í)行時間變成了2.5s。性能提升了3倍多，但還是不夠快，還需要做進(jìn)一步優(yōu)化。3第二次優(yōu)化還有一個notexists可以優(yōu)化一下。如果是小表驅(qū)動大表的時候，使用notexists確實(shí)可以提升性能。但如果是大表驅(qū)動小表的時候，使用notexists可能有點(diǎn)弄巧成拙。這里exists右邊的sql的含義是查詢某供應(yīng)商的商品數(shù)據(jù)，而目前我們平臺一個供應(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í)行時間下降到了0.7s。之后，我再用explain關(guān)鍵字查詢該SQL的執(zhí)行計(jì)劃。發(fā)現(xiàn)spu表走了全表掃描，sku表走了eq_ref類型的索引，而mall_sku和supplier_sku表走了ref類型的索引?？梢钥闯觯袝r候sql語句走了4個索引，性能未必比走了3個索引好。多張表join的時候，其中一張表走了全表掃描，說不定整個SQL語句的性能會更好，我們一定要多測試。1案發(fā)現(xiàn)場前幾天，我收到了一封報警郵件，提示有一條慢查詢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的耗時竟然達(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語句，其中兩個exists關(guān)鍵字引起了我的注意。一個exists是為了查詢存在某些滿足條件的商品，另一個notexists是為了查詢出不存在某些商品。這個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í)行時間變成了2.5s。性能提升了3倍多，但還是不夠快，還需要做進(jìn)一步優(yōu)化。3第二次優(yōu)化還有一個notexists可以優(yōu)化一下。如果是小表驅(qū)動大表的時候，使用notexists確實(shí)可以提升性能。但如果是大表驅(qū)動小表的時候，使用notexists可能有點(diǎn)弄巧成拙。這里exists右邊的sql的含義是查詢某供應(yīng)商的商品數(shù)據(jù)，而目前我們平臺一個供應(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í)行時間下降到了0.7s。之后，我再用explain關(guān)鍵字查詢該SQL的執(zhí)行計(jì)劃。發(fā)現(xiàn)spu表走了全表掃描，sku表走了eq_ref類型的索引，而mall_sku和supplier_sku表走了ref類型的索引?？梢钥闯觯袝r候sql語句走了4個索引，性能未必比走了3個索引好。多張表join的時候，其中一張表走了全表掃描，說不定整個SQL語句的性能會更好，我們一定要多測試。1案發(fā)現(xiàn)場前幾天，我收到了一封報警郵件，提示有一條慢查詢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的耗時竟然達(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語句，其中兩個exists關(guān)鍵字引起了我的注意。一個exists是為了查詢存在某些滿足條件的商品，另一個notexists是為了查詢出不存在某些商品。這個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í)行時間變成了2.5s。性能提升了3倍多，但還是不夠快，還需要做進(jìn)一步優(yōu)化。3第二次優(yōu)化還有一個notexists可以優(yōu)化一下。如果是小表驅(qū)動大表的時候，使用notexists確實(shí)可以提升性能。但如果是大表驅(qū)動小表的時候，使用notexists可能有點(diǎn)弄巧成拙。這里exists右邊的sql的含義是查詢某供應(yīng)商的商品數(shù)據(jù)，而目前我們平臺一個供應(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í)行時間下降到了0.7s。之后，我再用explain關(guān)鍵字查詢該SQL的執(zhí)行計(jì)劃。發(fā)現(xiàn)spu表走了全表掃描，sku表走了eq_ref類型的索引，而mall_sku和supplier_sku表走了ref類型的索引?？梢钥闯?，有時候sql語句走了4個索引，性能未必比走了3個索引好。多張表join的時候，其中一張表走了全表掃描，說不定整個SQL語句的性能會更好，我們一定要多測試。1案發(fā)現(xiàn)場前幾天，我收到了一封報警郵件，提示有一條慢查詢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的耗時竟然達(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語句，其中兩個exists關(guān)鍵字引起了我的注意。一個exists是為了查詢存在某些滿足條件的商品，另一個notexists是為了查詢出不存在某些商品。這個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í)行時間變成了2.5s。性能提升了3倍多，但還是不夠快，還需要做進(jìn)一步優(yōu)化。3第二次優(yōu)化還有一個notexists可以優(yōu)化一下。如果是小表驅(qū)動大表的時候，使用notexists確實(shí)可以提升性能。但如果是大表驅(qū)動小表的時候，使用notexists可能有點(diǎn)弄巧成拙。這里exists右邊的sql的含義是查詢某供應(yīng)商的商品數(shù)據(jù)，而目前我們平臺一個供應(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í)行時間下降到了0.7s。之后，我再用explain關(guān)鍵字查詢該SQL的執(zhí)行計(jì)劃。發(fā)現(xiàn)spu表走了全表掃描，sku表走了eq_ref類型的索引，而mall_sku和supplier_sku表走了ref類型的索引?？梢钥闯觯袝r候sql語句走了4個索引，性能未必比走了3個索引好。多張表join的時候，其中一張表走了全表掃描，說不定整個SQL語句的性能會更好，我們一定要多測試。1案發(fā)現(xiàn)場前幾天，我收到了一封報警郵件，提示有一條慢查詢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的耗時竟然達(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語句，其中兩個exists關(guān)鍵字引起了我的注意。一個exists是為了查詢存在某些滿足條件的商品，另一個notexists是為了查詢出不存在某些商品。這個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í)行時間變成了2.5s。性能提升了3倍多，但還是不夠快，還需要做進(jìn)一步優(yōu)化。3第二次優(yōu)化還有一個notexists可以優(yōu)化一下。如果是小表驅(qū)動大表的時候，使用notexists確實(shí)可以提升性能。但如果是大表驅(qū)動小表的時候，使用notexists可能有點(diǎn)弄巧成拙。這里exists右邊的sql的含義是查詢某供應(yīng)商的商品數(shù)據(jù)，而目前我們平臺一個供應(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í)行時間下降到了0.7s。之后，我再用explain關(guān)鍵字查詢該SQL的執(zhí)行計(jì)劃。發(fā)現(xiàn)spu表走了全表掃描，sku表走了eq_ref類型的索引，而mall_sku和supplier_sku表走了ref類型的索引?？梢钥闯觯袝r候sql語句走了4個索引，性能未必比走了3個索引好。多張表join的時候，其中一張表走了全表掃描，說不定整個SQL語句的性能會更好，我們一定要多測試。1案發(fā)現(xiàn)場前幾天，我收到了一封報警郵件，提示有一條慢查詢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的耗時竟然達(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語句，其中兩個exists關(guān)鍵字引起了我的注意。一個exists是為了查詢存在某些滿足條件的商品，另一個notexists是為了查詢出不存在某些商品。這個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í)行時間變成了2.5s。性能提升了3倍多，但還是不夠快，還需要做進(jìn)一步優(yōu)化。3第二次優(yōu)化還有一個notexists可以優(yōu)化一下。如果是小表驅(qū)動大表的時候，使用notexists確實(shí)可以提升性能。但如果是大表驅(qū)動小表的時候，使用notexists可能有點(diǎn)弄巧成拙。這里exists右邊的sql的含義是查詢某供應(yīng)商的商品數(shù)據(jù)，而目前我們平臺一個供應(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í)行時間下降到了0.7s。之后，我再用explain關(guān)鍵字查詢該SQL的執(zhí)行計(jì)劃。發(fā)現(xiàn)spu表走了全表掃描，sku表走了eq_ref類型的索引，而mall_sku和supplier_sku表走了ref類型的索引。可以看出，有時候sql語句走了4個索引，性能未必比走了3個索引好。多張表join的時候，其中一張表走了全表掃描，說不定整個SQL語句的性能會更好，我們一定要多測試。1案發(fā)現(xiàn)場前幾天，我收到了一封報警郵件，提示有一條慢查詢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的耗時竟然達(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語句，其中兩個exists關(guān)鍵字引起了我的注意。一個exists是為了查詢存在某些滿足條件的商品，另一個notexists是為了查詢出不存在某些商品。這個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í)行時間變成了2.5s。性能提升了3倍多，但還是不夠快，還需要做進(jìn)一步優(yōu)化。3第二次優(yōu)化還有一個notexists可以優(yōu)化一下。如果是小表驅(qū)動大表的時候，使用notexists確實(shí)可以提升性能。但如果是大表驅(qū)動小表的時候，使用notexists可能有點(diǎn)弄巧成拙。這里exists右邊的sql的含義是查詢某供應(yīng)商的商品數(shù)據(jù)，而目前我們平臺一個供應(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í)行時間下降到了0.7s。之后，我再用explain關(guān)鍵字查詢該SQL的執(zhí)行計(jì)劃。發(fā)現(xiàn)spu表走了全表掃描，sku表走了eq_ref類型的索引，而mall_sku和supplier_sku表走了ref類型的索引。可以看出，有時候sql語句走了4個索引，性能未必比走了3個索引好。多張表join的時候，其中一張表走了全表掃描，說不定整個SQL語句的性能會更好，我們一定要多測試。1案發(fā)現(xiàn)場前幾天，我收到了一封報警郵件，提示有一條慢查詢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的耗時竟然達(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語句，其中兩個exists關(guān)鍵字引起了我的注意。一個exists是為了查詢存在某些滿足條件的商品，另一個notexists是為了查詢出不存在某些商品。這個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í)行時間變成了2.5s。性能提升了3倍多，但還是不夠快，還需要做進(jìn)一步優(yōu)化。3第二次優(yōu)化還有一個notexists可以優(yōu)化一下。如果是小表驅(qū)動大表的時候，使用notexists確實(shí)可以提升性能。但如果是大表驅(qū)動小表的時候，使用notexists可能有點(diǎn)弄巧成拙。這里exists右邊的sql的含義是查詢某供應(yīng)商的商品數(shù)據(jù)，而目前我們平臺一個供應(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í)行時間下降到了0.7s。之后，我再用explain關(guān)鍵字查詢該SQL的執(zhí)行計(jì)劃。發(fā)現(xiàn)spu表走了全表掃描，sku表走了eq_ref類型的索引，而mall_sku和supplier_sku表走了ref類型的索引?？梢钥闯觯袝r候sql語句走了4個索引，性能未必比走了3個索引好。多張表join的時候，其中一張表走了全表掃描，說不定整個SQL語句的性能會更好，我們一定要多測試。1案發(fā)現(xiàn)場前幾天，我收到了一封報警郵件，提示有一條慢查詢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的耗時竟然達(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語句，其中兩個exists關(guān)鍵字引起了我的注意。一個exists是為了查詢存在某些滿足條件的商品，另一個notexists是為了查詢出不存在某些商品。這個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í)行時間變成了2.5s。性能提升了3倍多，但還是不夠快，還需要做進(jìn)一步優(yōu)化。3第二次優(yōu)化還有一個notexists可以優(yōu)化一下。如果是小表驅(qū)動大表的時候，使用notexists確實(shí)可以提升性能。但如果是大表驅(qū)動小表的時候，使用notexists可能有點(diǎn)弄巧成拙。這里exists右邊的sql的含義是查詢某供應(yīng)商的商品數(shù)據(jù)，而目前我們平臺一個供應(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í)行時間下降到了0.7s。之后，我再用explain關(guān)鍵字查詢該SQL的執(zhí)行計(jì)劃。發(fā)現(xiàn)spu表走了全表掃描，sku表走了eq_ref類型的索引，而mall_sku和supplier_sku表走了ref類型的索引?？梢钥闯觯袝r候sql語句走了4個索引，性能未必比走了3個索引好。多張表join的時候，其中一張表走了全表掃描，說不定整個SQL語句的性能會更好，我們一定要多測試。1案發(fā)現(xiàn)場前幾天，我收到了一封報警郵件，提示有一條慢查詢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的耗時竟然達(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語句，其中兩個exists關(guān)鍵字引起了我的注意。一個exists是為了查詢存在某些滿足條件的商品，另一個notexists是為了查詢出不存在某些商品。這個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í)行時間變成了2.5s。性能提升了3倍多，但還是不夠快，還需要做進(jìn)一步優(yōu)化。3第二次優(yōu)化還有一個notexists可以優(yōu)化一下。如果是小表驅(qū)動大表的時候，使用notexists確實(shí)可以提升性能。但如果是大表驅(qū)動小表的時候，使用notexists可能有點(diǎn)弄巧成拙。這里exists右邊的sql的含義是查詢某供應(yīng)商的商品數(shù)據(jù)，而目前我們平臺一個供應(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í)行時間下降到了0.7s。之后，我再用explain關(guān)鍵字查詢該SQL的執(zhí)行計(jì)劃。發(fā)現(xiàn)spu表走了全表掃描，sku表走了eq_ref類型的索引，而mall_sku和supplier_sku表走了ref類型的索引?？梢钥闯?，有時候sql語句走了4個索引，性能未必比走了3個索引好。多張表join的時候，其中一張表走了全表掃描，說不定整個SQL語句的性能會更好，我們一定要多測試。1案發(fā)現(xiàn)場前幾天，我收到了一封報警郵件，提示有一條慢查詢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的耗時竟然達(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語句，其中兩個exists關(guān)鍵字引起了我的注意。一個exists是為了查詢存在某些滿足條件的商品，另一個notexists是為了查詢出不存在某些商品。這個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í)行時間變成了2.5s。性能提升了3倍多，但還是不夠快，還需要做進(jìn)一步優(yōu)化。3第二次優(yōu)化還有一個notexists可以優(yōu)化一下。如果是小表驅(qū)動大表的時候，使用notexists確實(shí)可以提升性能。但如果是大表驅(qū)動小表的時候，使用notexists可能有點(diǎn)弄巧成拙。這里exists右邊的sql的含義是查詢某供應(yīng)商的商品數(shù)據(jù)，而目前我們平臺一個供應(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í)行時間下降到了0.7s。之后，我再用explain關(guān)鍵字查詢該SQL的執(zhí)行計(jì)劃。發(fā)現(xiàn)spu表走了全表掃描，sku表走了eq_ref類型的索引，而mall_sku和supplier_sku表走了ref類型的索引?？梢钥闯?，有時候sql語句走了4個索引，性能未必比走了3個索引好。多張表join的時候，其中一張表走了全表掃描，說不定整個SQL語句的性能會更好，我們一定要多測試。1案發(fā)現(xiàn)場前幾天，我收到了一封報警郵件，提示有一條慢查詢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的耗時竟然達(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語句，其中兩個exists關(guān)鍵字引起了我的注意。一個exists是為了查詢存在某些滿足條件的商品，另一個notexists是為了查詢出不存在某些商品。這個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í)行時間變成了2.5s。性能提升了3倍多，但還是不夠快，還需要做進(jìn)一步優(yōu)化。3第二次優(yōu)化還有一個notexists可以優(yōu)化一下。如果是小表驅(qū)動大表的時候，使用notexists確實(shí)可以提升性能。但如果是大表驅(qū)動小表的時候，使用notexists可能有點(diǎn)弄巧成拙。這里exists右邊的sql的含義是查詢某供應(yīng)商的商品數(shù)據(jù)，而目前我們平臺一個供應(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í)行時間下降到了0.7s。之后，我再用explain關(guān)鍵字查詢該SQL的執(zhí)行計(jì)劃。發(fā)現(xiàn)spu表走了全表掃描，sku表走了eq_ref類型的索引，而mall_sku和supplier_sku表走了ref類型的索引?？梢钥闯?，有時候sql語句走了4個索引，性能未必比走了3個索引好。多張表join的時候，其中一張表走了全表掃描，說不定整個SQL語句的性能會更好，我們一定要多測試。1案發(fā)現(xiàn)場前幾天，我收到了一封報警郵件，提示有一條慢查詢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的耗時竟然達(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語句，其中兩個exists關(guān)鍵字引起了我的注意。一個exists是為了查詢存在某些滿足條件的商品，另一個notexists是為了查詢出不存在某些商品。這個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í)行時間變成了2.5s。性能提升了3倍多，但還是不夠快，還需要做進(jìn)一步優(yōu)化。3第二次優(yōu)化還有一個notexists可以優(yōu)化一下。如果是小表驅(qū)動大表的時候，使用notexists確實(shí)可以提升性能。但如果是大表驅(qū)動小表的時候，使用notexists可能有點(diǎn)弄巧成拙。這里exists右邊的sql的含義是查詢某供應(yīng)商的商品數(shù)據(jù)，而目前我們平臺一個供應(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í)行時間下降到了0.7s。之后，我再用explain關(guān)鍵字查詢該SQL的執(zhí)行計(jì)劃。發(fā)現(xiàn)spu表走了全表掃描，sku表走了eq_ref類型的索引，而mall_sku和supplier_sku表走了ref類型的索引?？梢钥闯?，有時候sql語句走了4個索引，性能未必比走了3個索引好。多張表join的時候，其中一張表走了全表掃描，說不定整個SQL語句的性能會更好，我們一定要多測試。1案發(fā)現(xiàn)場前幾天，我收到了一封報警郵件，提示有一條慢查詢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的耗時竟然達(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語句，其中兩個exists關(guān)鍵字引起了我的注意。一個exists是為了查詢存在某些滿足條件的商品，另一個notexists是為了查詢出不存在某些商品。這個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)確性、安全性和完整性, 同時也不承擔(dān)用戶因使用這些下載資源對自己和他人造成任何形式的傷害或損失。
最新文檔
- 城市管廊建設(shè)監(jiān)理合同（2篇）
- 農(nóng)業(yè)銀行貸款合同范本示范文本
- 珠寶首飾顧問聘用合同
- 城市次干道周邊道路標(biāo)線改造合同
- 陶瓷制品生產(chǎn)經(jīng)理合同
- 商場攤位租賃合同：攝影器材專賣
- 建筑維修承攬合同范本
- 大型超市冷鏈系統(tǒng)電路安裝合同
- 武漢舞蹈教室租賃合同
- 品牌推廣專員聘用合同模板
- GB/T 16857.1-2002產(chǎn)品幾何量技術(shù)規(guī)范(GPS)坐標(biāo)測量機(jī)的驗(yàn)收檢測和復(fù)檢檢測第1部分：詞匯
- GB 4053.2-2009固定式鋼梯及平臺安全要求第2部分：鋼斜梯
- GB 28261-2012安全氣囊氣體發(fā)生器用點(diǎn)火具生產(chǎn)安全技術(shù)條件
- 通力電梯培訓(xùn)教材：《LCE控制系統(tǒng)課程》
- RT qPCR(實(shí)時熒光定量PCR)課件
- 品管圈PDCA持續(xù)質(zhì)量改進(jìn)提高靜脈血栓栓塞癥規(guī)范預(yù)防率
- 醫(yī)院發(fā)熱門診工作考核表
- 陜西省榆林市各縣區(qū)鄉(xiāng)鎮(zhèn)行政村村莊村名居民村民委員會明細(xì)
- 螺桿空壓機(jī)作業(yè)指導(dǎo)書
- 中國智能物聯(lián)網(wǎng)（AIoT）研究報告
- 江蘇新海石化有限公司廢氣治理項(xiàng)目環(huán)境影響報告書
評論
0/150
提交評論