पूर्ण प्रदर्शन के लिए, SUM तेज़ या COUNT है?


31

यह उन अभिलेखों की संख्या गिनने से संबंधित है जो एक निश्चित स्थिति से मेल खाते हैं, जैसे invoice amount > $100

मुझे पसंद करते हैं

COUNT(CASE WHEN invoice_amount > 100 THEN 1 END)

हालाँकि, यह उतना ही मान्य है

SUM(CASE WHEN invoice_amount > 100 THEN 1 ELSE 0 END)

मैंने सोचा होगा COUNT 2 कारणों से बेहतर है:

  1. इरादे को व्यक्त करता है, जो करने के लिए है COUNT
  2. COUNT शायदi += 1 कहीं एक साधारण ऑपरेशन शामिल है, जबकि SUM एक साधारण पूर्णांक मान होने के लिए अपनी अभिव्यक्ति पर भरोसा नहीं कर सकता है।

क्या किसी के पास विशिष्ट RDBMS के अंतर के बारे में कुछ विशेष तथ्य हैं?

जवाबों:


32

आपने ज्यादातर इस सवाल का जवाब खुद ही दिया। मेरे पास जोड़ने के लिए कुछ निवाला है:

में PostgreSQL (और अन्य RDBMS का समर्थन करने वाले booleanप्रकार) आप उपयोग कर सकते हैं booleanसीधे परीक्षण के परिणाम। यह करने के लिए कास्ट integerऔर SUM():

SUM((amount > 100)::int))

या एक NULLIF()अभिव्यक्ति में इसका उपयोग करें और COUNT():

COUNT(NULLIF(amount > 100, FALSE))

या एक सरल के साथ OR NULL:

COUNT(amount > 100 OR NULL)

या अन्य विभिन्न भाव। प्रदर्शन लगभग समान हैCOUNT()आमतौर पर की तुलना में बहुत थोड़ा तेज है SUM()। इसके विपरीत SUM()और जैसे पॉल ने पहले ही टिप्पणी की थी , COUNT()कभी नहीं लौटा NULL, जो सुविधाजनक हो सकता है। सम्बंधित:

चूंकि Postgres 9.4 में FILTERक्लॉज भी है । विवरण:

यह उपरोक्त सभी 5 - 10% से अधिक तेज़ है:

COUNT(*) FILTER (WHERE amount > 100)

यदि क्वेरी आपके परीक्षण मामले की तरह ही सरल है, तो केवल एक ही गिनती और कुछ नहीं के साथ, आप फिर से लिख सकते हैं:

SELECT count(*) FROM tbl WHERE amount > 100;

जो इंडेक्स के बिना भी प्रदर्शन का सच्चा राजा है।
एक लागू सूचकांक के साथ यह परिमाण के आदेशों से तेज हो सकता है, विशेष रूप से सूचकांक-केवल स्कैन के साथ।

मानक

10 पोस्ट करता है

मैंने एग्रीगेट FILTERक्लॉज और छोटे और बड़े काउंट के लिए एक इंडेक्स की भूमिका का प्रदर्शन करते हुए पोस्टग्रेज 10 के लिए परीक्षणों की एक नई श्रृंखला चलाई ।

सरल सेटअप:

CREATE TABLE tbl (
   tbl_id int
 , amount int NOT NULL
);

INSERT INTO tbl
SELECT g, (random() * 150)::int
FROM   generate_series (1, 1000000) g;

-- only relevant for the last test
CREATE INDEX ON tbl (amount);

वास्तविक समय पृष्ठभूमि के शोर और परीक्षण बिस्तर की बारीकियों के कारण काफी भिन्न होता है। परीक्षणों के एक बड़े सेट से विशिष्ट सर्वोत्तम समय दिखा रहा है । इन दो मामलों को सार पर कब्जा करना चाहिए:

सभी पंक्तियों की 1 गिनती ~ 1% का परीक्षण करें

SELECT COUNT(NULLIF(amount > 148, FALSE))            FROM tbl; -- 140 ms
SELECT SUM((amount > 148)::int)                      FROM tbl; -- 136 ms
SELECT SUM(CASE WHEN amount > 148 THEN 1 ELSE 0 END) FROM tbl; -- 133 ms
SELECT COUNT(CASE WHEN amount > 148 THEN 1 END)      FROM tbl; -- 130 ms
SELECT COUNT((amount > 148) OR NULL)                 FROM tbl; -- 130 ms
SELECT COUNT(*) FILTER (WHERE amount > 148)          FROM tbl; -- 118 ms -- !

SELECT count(*) FROM tbl WHERE amount > 148; -- without index  --  75 ms -- !!
SELECT count(*) FROM tbl WHERE amount > 148; -- with index     --   1.4 ms -- !!!

db <> यहाँ fiddle

परीक्षण 2 गिनती ~ सभी पंक्तियों का 33%

SELECT COUNT(NULLIF(amount > 100, FALSE))            FROM tbl; -- 140 ms
SELECT SUM((amount > 100)::int)                      FROM tbl; -- 138 ms
SELECT SUM(CASE WHEN amount > 100 THEN 1 ELSE 0 END) FROM tbl; -- 139 ms
SELECT COUNT(CASE WHEN amount > 100 THEN 1 END)      FROM tbl; -- 138 ms
SELECT COUNT(amount > 100 OR NULL)                   FROM tbl; -- 137 ms
SELECT COUNT(*) FILTER (WHERE amount > 100)          FROM tbl; -- 132 ms -- !

SELECT count(*) FROM tbl WHERE amount > 100; -- without index  -- 102 ms -- !!
SELECT count(*) FROM tbl WHERE amount > 100; -- with index     --  55 ms -- !!!

db <> यहाँ fiddle

प्रत्येक सेट में अंतिम परीक्षण में केवल-इंडेक्स स्कैन का उपयोग किया गया था , यही वजह है कि इसने सभी पंक्तियों में से एक तिहाई को गिनने में मदद की। लगभग 5% या अधिक सभी पंक्तियों को शामिल करने पर प्लेन इंडेक्स या बिटमैप इंडेक्स स्कैन एक अनुक्रमिक स्कैन के साथ प्रतिस्पर्धा नहीं कर सकते हैं।

Postgres 9.1 के लिए पुराना परीक्षण

सत्यापित करने के लिए मैंने EXPLAIN ANALYZEPostgreSQL 9.1.6 में एक वास्तविक जीवन तालिका के साथ एक त्वरित परीक्षण चलाया ।

184568 पंक्तियों की 74208 शर्त के साथ योग्य kat_id > 50। सभी प्रश्न समान परिणाम देते हैं। मैंने कैशिंग प्रभावों को बाहर करने के लिए प्रत्येक बार 10 बार दौड़ लगाई और नोट के रूप में सबसे अच्छा परिणाम प्राप्त किया:

SELECT SUM((kat_id > 50)::int)                      FROM log_kat; -- 438 ms
SELECT COUNT(NULLIF(kat_id > 50, FALSE))            FROM log_kat; -- 437 ms
SELECT COUNT(CASE WHEN kat_id > 50 THEN 1 END)      FROM log_kat; -- 437 ms
SELECT COUNT((kat_id > 50) OR NULL)                 FROM log_kat; -- 436 ms
SELECT SUM(CASE WHEN kat_id > 50 THEN 1 ELSE 0 END) FROM log_kat; -- 432 ms

प्रदर्शन में शायद ही कोई वास्तविक अंतर हो।


1
क्या फिल्टर समाधान "धीमी" समूह से किसी भी विविधता को हरा देता है?
एंड्री एम

@AndriyM: मैं FILTERउपरोक्त अभिव्यक्तियों की तुलना में एग्रीगेट के लिए थोड़ा तेज समय देखता हूं (परीक्षण 9.5 के साथ)। क्या आपको वही मिलता है? ( WHEREअभी भी प्रदर्शन के राजा हैं - जहां संभव हो)।
एरविन ब्रान्डेसटेटर

कोई पीजी काम नहीं मिला, इसलिए नहीं बता सकता। वैसे भी, मैं केवल उम्मीद कर रहा था कि आप अंतिम समाधान के लिए समय के आंकड़ों के साथ अपने उत्तर को अपडेट करेंगे, बस पूर्णता के लिए :)
एंड्री एम

@AndriyM: अंत में मुझे नए बेंचमार्क जोड़ने के लिए मिला। FILTERसमाधान है आम तौर पर तेजी से मेरी परीक्षणों में।
इरविन ब्रान्डेसटेटर

11

यह SQL Server 2012 RTM पर मेरा परीक्षण है।

if object_id('tempdb..#temp1') is not null drop table #temp1;
if object_id('tempdb..#timer') is not null drop table #timer;
if object_id('tempdb..#bigtimer') is not null drop table #bigtimer;
GO

select a.*
into #temp1
from master..spt_values a
join master..spt_values b on b.type='p' and b.number < 1000;

alter table #temp1 add id int identity(10,20) primary key clustered;

create table #timer (
    id int identity primary key,
    which bit not null,
    started datetime2 not null,
    completed datetime2 not null,
);
create table #bigtimer (
    id int identity primary key,
    which bit not null,
    started datetime2 not null,
    completed datetime2 not null,
);
GO

--set ansi_warnings on;
set nocount on;
dbcc dropcleanbuffers with NO_INFOMSGS;
dbcc freeproccache with NO_INFOMSGS;
declare @bigstart datetime2;
declare @start datetime2, @dump bigint, @counter int;

set @bigstart = sysdatetime();
set @counter = 1;
while @counter <= 100
begin
    set @start = sysdatetime();
    select @dump = count(case when number < 100 then 1 end) from #temp1;
    insert #timer values (0, @start, sysdatetime());
    set @counter += 1;
end;
insert #bigtimer values (0, @bigstart, sysdatetime());
set nocount off;
GO

set nocount on;
dbcc dropcleanbuffers with NO_INFOMSGS;
dbcc freeproccache with NO_INFOMSGS;
declare @bigstart datetime2;
declare @start datetime2, @dump bigint, @counter int;

set @bigstart = sysdatetime();
set @counter = 1;
while @counter <= 100
begin
    set @start = sysdatetime();
    select @dump = SUM(case when number < 100 then 1 else 0 end) from #temp1;
    insert #timer values (1, @start, sysdatetime());
    set @counter += 1;
end;
insert #bigtimer values (1, @bigstart, sysdatetime());
set nocount off;
GO

अलग-अलग रन और बैचों को अलग से देखना

select which, min(datediff(mcs, started, completed)), max(datediff(mcs, started, completed)),
            avg(datediff(mcs, started, completed))
from #timer group by which
select which, min(datediff(mcs, started, completed)), max(datediff(mcs, started, completed)),
            avg(datediff(mcs, started, completed))
from #bigtimer group by which

5 बार (और दोहराने) के बाद परिणाम काफी अनिर्णायक हैं।

which                                       ** Individual
----- ----------- ----------- -----------
0     93600       187201      103927
1     93600       187201      103864

which                                       ** Batch
----- ----------- ----------- -----------
0     10108817    10545619    10398978
1     10327219    10498818    10386498

यह दिखाता है कि एसक्यूएल टाइमर की ग्रेन्युलैरिटी के साथ मापा जाता है, जब कार्यान्वयन के बीच अंतर होता है, तो चलने की स्थिति में कहीं अधिक परिवर्तनशीलता होती है। या तो संस्करण शीर्ष पर आ सकता है, और मेरे द्वारा प्राप्त अधिकतम संस्करण 2.5% है।

हालांकि, एक अलग दृष्टिकोण ले:

set showplan_text on;
GO
select SUM(case when number < 100 then 1 else 0 end) from #temp1;
select count(case when number < 100 then 1 end) from #temp1;

StmtText (SUM)

  |--Compute Scalar(DEFINE:([Expr1003]=CASE WHEN [Expr1011]=(0) THEN NULL ELSE [Expr1012] END))
       |--Stream Aggregate(DEFINE:([Expr1011]=Count(*), [Expr1012]=SUM([Expr1004])))
            |--Compute Scalar(DEFINE:([Expr1004]=CASE WHEN [tempdb].[dbo].[#temp1].[number]<(100) THEN (1) ELSE (0) END))
                 |--Clustered Index Scan(OBJECT:([tempdb].[dbo].[#temp1]))

StmtText (COUNT)

  |--Compute Scalar(DEFINE:([Expr1003]=CONVERT_IMPLICIT(int,[Expr1008],0)))
       |--Stream Aggregate(DEFINE:([Expr1008]=COUNT([Expr1004])))
            |--Compute Scalar(DEFINE:([Expr1004]=CASE WHEN [tempdb].[dbo].[#temp1].[number]<(100) THEN (1) ELSE NULL END))
                 |--Clustered Index Scan(OBJECT:([tempdb].[dbo].[#temp1]))

मेरे पढ़ने से, यह प्रतीत होता है कि SUM संस्करण थोड़ा अधिक करता है। यह एक SUM के अलावा COUNT प्रदर्शन कर रहा है । कहा जा रहा है कि, COUNT(*)अलग है और इससे अधिक तेज होना चाहिए COUNT([Expr1004])(NULLs को छोड़ें, अधिक तर्क)। एक उचित अनुकूलक एहसास होगा कि [Expr1004]में SUM([Expr1004])में योग संस्करण एक "पूर्णांक" प्रकार है और इसलिए एक पूर्णांक रजिस्टर का उपयोग करें।

किसी भी मामले में, जबकि मुझे विश्वास है कि COUNTसंस्करण अभी भी सबसे RDBMS में तेज़ होगा, परीक्षण से मेरा निष्कर्ष यह है कि मैं SUM(.. 1.. 0..)भविष्य में साथ जा रहा हूं , कम से कम SQL सर्वर के लिए कोई अन्य कारण से ANSI चेतावनी की तुलना में जब उपयोग किया जा रहा है COUNT


1

मेरे अनुभव में एक ट्रेसिंग बनाना, दोनों विधियों के लिए लगभग 10,000,000 की एक क्वेरी में मैंने नोट किया कि काउंट (*) लगभग दो बार सीपीयू का उपयोग करता है और थोड़ा तेज चलता है। लेकिन मेरी क्वेरी फ़िल्टर के बिना हैं।

गणना (*)

CPU...........: 1828   
Execution time:  470 ms  

बीमा राशि (1)

CPU...........: 3859  
Execution time:  681 ms  

यो को निर्दिष्ट करना चाहिए कि आपने इस परीक्षण को बनाने के लिए किस RDBMS का उपयोग किया है।
ईएमेज़
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.