कई कॉलम से अंतिम तिथियां प्राप्त करें


18

ऐसा लगता है कि यह एक आसान होना चाहिए। मुझे नवीनतम तिथियां कैसे प्राप्त होंगी जो विभिन्न कॉलमों में हैं

DROP TABLE #indebtedness
CREATE TABLE #indebtedness (call_case CHAR(10), date1 DATETIME, date2 DATETIME, date3 DATETIME)
INSERT #indebtedness VALUES ('Key1', '2019-10-30', '2019-11-30', '2019-10-25')
INSERT #indebtedness VALUES ('Key2', '2019-10-20', '2019-10-30', '2019-10-15')
INSERT #indebtedness VALUES ('Key3', '2019-11-11', '2019-10-29', '2019-10-30')
INSERT #indebtedness VALUES ('Key4',     null    , '2019-10-29', '2019-10-13')

select call_case, ?? AS 'Latest Date' from #indebtedness 

मैं चाहूंगा कि परिणाम:

call_case   Latest Date
Key1        2019-11-30 
Key2        2019-10-30 
Key3        2019-11-11 
Key4        2019-10-29 

जवाबों:


20

एक CASEअभिव्यक्ति का उपयोग करें :

SELECT
    call_case,
    CASE WHEN date1 > date2 AND date1 > date3
         THEN date1
         WHEN date2 > date3
         THEN date2
         ELSE date3 END AS [Latest Date]
FROM #indebtedness;

डेमो

ध्यान दें कि कुछ डेटाबेस, जैसे कि MySQL, SQL सर्वर और SQLite, एक स्केलर सबसे बड़े फ़ंक्शन का समर्थन करते हैं। SQL सर्वर नहीं करता है, इसलिए हम CASEअभिव्यक्ति को वर्कअराउंड के रूप में उपयोग कर सकते हैं ।

संपादित करें:

ऐसा प्रतीत होता है कि आपकी वास्तविक तालिका में, तीन या अधिक स्तंभों में से एक में NULLमान हो सकते हैं । हम उपरोक्त क्वेरी को निम्नानुसार अनुकूलित कर सकते हैं:

SELECT
    call_case,
    CASE WHEN (date1 > date2 OR date2 IS NULL) AND (date1 > date3 OR date3 IS NULL)
         THEN date1
         WHEN date2 > date3 OR date3 IS NULL
         THEN date2
         ELSE date3 END AS [Latest Date]
FROM #indebtedness;

डेमो


यह काम नहीं कर रहा है यह तारीख 3 को केवल 3 कॉलम में अंतिम तारीख नहीं मिल रही है
अहमद अलखतेब

1
@AhmedAlkhteeb मैंने अपना उत्तर संपादित किया वह भी उस मामले को संभालने के लिए जहां एक या अधिक दिनांक स्तंभ हो सकते हैं NULL
टिम बैजलेसेन

3
फिर यहां दिए गए कई उत्तर टूट जाएंगे, और काम नहीं करेंगे। ईमानदारी से, यदि आपको यह तुलना चार स्तंभों में भी करने की आवश्यकता है, तो आप अपने डेटाबेस तालिका डिज़ाइन पर फिर से विचार कर सकते हैं, और इसके बजाय एक अलग पंक्ति में प्रत्येक दिनांक मान प्राप्त करना चाहते हैं । आपकी आवश्यकता तुच्छ होगी यदि आपके पास प्रत्येक पंक्ति एक अलग पंक्ति में थी, क्योंकि तब हम सिर्फ MAXउपयोग कर सकते थे GROUP BY। तो आपके प्रश्न का मेरा उत्तर "ठीक नहीं होगा," क्योंकि मुझे लगता है कि शायद आपके डेटाबेस के डिजाइन को बदलने की आवश्यकता है।
टिम बैजलेसेन

1
टिम यहीं है, @AhmedAlkhteeb यदि आपके पास 10 तारीख के कॉलम हैं, तो आपके पास संभावना है कि वह डेटा असंगत हो। एक पंक्ति में एक जोड़ी ठीक है, इसका मतलब है कि अलग-अलग चीजें (चलो एक शुरुआत और अंत कहें, और जन्म तिथि और एक तारीख जिसे एक व्यक्ति को सिस्टम में जोड़ा गया था), लेकिन कई तारीखें (उनमें से 10) आपको सुझाव देती हैं हर बार कुछ बदलने पर एक कॉलम में एक नई तारीख जोड़ना; एक इतिहास को बनाए रखने के लिए एक नई पंक्ति नहीं डाल रहा है। यदि यह एक डिलीवरी सेवा कंपनी का डेटाबेस था, उदाहरण के लिए, इसमें यात्रा के हर संभव चरण के लिए कोई तारीख स्तंभ नहीं होगा; आप प्रत्येक के लिए एक नई पंक्ति सम्मिलित करेंगे।
लारनू

1
@ अहम् अख्तियतेब उस मामले में लारनु सही है - आपके पास एक कार्रवाई ( call_case) और टाइमस्टैम्प के साथ एक तालिका होनी चाहिए । 50 कॉलम के साथ एक भी मेज नहीं
Dannnno

13

वर्तमान में स्वीकार जवाब सबसे अच्छा जवाब है, लेकिन मैं इसे क्यों समझाने का एक अच्छा पर्याप्त काम करता है नहीं लगता। अन्य उत्तर निश्चित रूप से एक नज़र में बहुत साफ दिखते हैं (जो उस बदसूरत मामले का बयान लिखना चाहते हैं), लेकिन जब आप बड़े पैमाने पर काम करना शुरू करते हैं तो बहुत अधिक खराब होने की संभावना होती है।

SELECT @@VERSION

Microsoft SQL Server 2016 (SP2) (KB4052908) - 13.0.5026.0 (X64) 
Mar 18 2018 09:11:49 
Copyright (c) Microsoft Corporation
Developer Edition (64-bit) on Windows 10 Enterprise 10.0 <X64> (Build 17763: )

यहाँ है कि मैं सब कुछ कैसे सेट करता हूं

DECLARE @Offset bigint = 0;
DECLARE @Max bigint = 10000000;

DROP TABLE IF EXISTS #Indebtedness;
CREATE TABLE #Indebtedness
(
  call_case char(10) COLLATE DATABASE_DEFAULT NOT NULL,
  date1     datetime NULL,
  date2     datetime NULL,
  date3     datetime NULL
);

WHILE @Offset < @Max
BEGIN

  INSERT INTO #Indebtedness
  ( call_case, date1, date2, date3 )
    SELECT @Offset + ROW_NUMBER() OVER ( ORDER BY ( SELECT NULL )),
           DATEADD( DAY,
                    CASE WHEN RAND() > 0 THEN 1
                         ELSE -1 END * ROUND( RAND(), 0 ),
                    CURRENT_TIMESTAMP ),
           DATEADD( DAY,
                    CASE WHEN RAND() > 0 THEN 1
                         ELSE -1 END * ROUND( RAND(), 0 ),
                    CURRENT_TIMESTAMP ),
           DATEADD( DAY,
                    CASE WHEN RAND() > 0 THEN 1
                         ELSE -1 END * ROUND( RAND(), 0 ),
                    CURRENT_TIMESTAMP )
      FROM master.dbo.spt_values a
        CROSS APPLY master.dbo.spt_values b;


  SET @Offset = @Offset + ROWCOUNT_BIG();
END;

मेरे सिस्टम पर यह मुझे तालिका में 12,872,738 पंक्तियों में मिलती है। यदि मैं उपरोक्त प्रत्येक प्रश्न को ट्राई करता हूं ( SELECT INTOइसलिए मुझे इसकी आवश्यकता नहीं है तो एसएसएमएस में परिणाम प्रिंट करने के लिए इंतजार करने की आवश्यकता है), मुझे निम्नलिखित परिणाम मिलते हैं:

Method                                | CPU time (ms) | Elapsed time (ms) | Relative Cost
-----------------------------------------------------------------------------------------
Tim Biegeleisen (CASE)                | 13485         | 2167              | 2%
Red Devil (Subquery over MAX columns) | 55187         | 9891              | 14%
Vignesh Kumar (Subquery over columns) | 33750         | 5139              | 5%
Serkan Arslan (UNPIVOT)               | 86205         | 15023             | 12%
Metal (STRING_SPLIT)                  | 459668        | 186742            | 68%

यदि आप क्वेरी योजनाओं को देखते हैं, तो यह बहुत स्पष्ट हो जाता है कि क्यों - किसी भी प्रकार की अनप्राइवेट या एग्रीगेट (या स्वर्ग की मनाही STRING_SPLIT) को जोड़ने से आप उन सभी अतिरिक्त ऑपरेटरों के साथ समाप्त हो जाएंगे जिनकी आपको आवश्यकता नहीं है (और यह योजना को मजबूर करता है समानांतर जाना, संसाधनों को दूर रखना अन्य प्रश्न हो सकता है)। अनुबंध के CASEआधार पर, आधारित समाधान समानांतर नहीं जाता है, बहुत जल्दी चलता है, और अविश्वसनीय रूप से सरल है।

इस मामले में, जब तक आपके पास असीमित संसाधन (आप नहीं हैं), आपको सबसे सरल और सबसे तेज़ दृष्टिकोण चुनना चाहिए।


यदि आपको नए कॉलम जोड़ने और केस स्टेटमेंट का विस्तार करने की आवश्यकता है तो क्या करना है, इस पर सवाल था। हाँ, यह कमज़ोर हो जाता है, लेकिन ऐसा हर दूसरे उपाय से होता है। यदि यह वास्तव में एक प्रशंसनीय वर्कफ़्लो है, तो आपको अपनी तालिका को फिर से डिज़ाइन करना चाहिए। आप जो चाहते हैं वह कुछ इस तरह दिखता है:

CREATE TABLE #Indebtedness2
(
  call_case     char(10) COLLATE DATABASE_DEFAULT NOT NULL,
  activity_type bigint   NOT NULL,  -- This indicates which date# column it was, if you care
  timestamp     datetime NOT NULL
);

SELECT Indebtedness.call_case,
       Indebtedness.activity_type,
       Indebtedness.timestamp
  FROM ( SELECT call_case,
                activity_type,
                timestamp,
                ROW_NUMBER() OVER ( PARTITION BY call_case
                                    ORDER BY timestamp DESC ) RowNumber
           FROM #Indebtedness2 ) Indebtedness
  WHERE Indebtedness.RowNumber = 1;

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


यदि कोई उत्तर हटा दिया जाता है, तो यहां वे संस्करण हैं जिनकी मैं तुलना कर रहा था (क्रम में)

SELECT
    call_case,
    CASE WHEN date1 > date2 AND date1 > date3
         THEN date1
         WHEN date2 > date3
         THEN date2
         ELSE date3 END AS [Latest Date]
FROM #indebtedness;

SELECT call_case,
  (SELECT Max(v) 
   FROM (VALUES (date1), (date2), (date3),...) AS value(v)) as [MostRecentDate]
FROM #indebtedness

SELECT call_case,
  (SELECT
     MAX(call_case) 
   FROM ( VALUES 
            (MAX(date1)), 
            (MAX(date2))
            ,(max(date3)) 
        ) MyAlias(call_case)
  ) 
FROM #indebtedness
group by call_case

select call_case, MAX(date)  [Latest Date] from #indebtedness 
UNPIVOT(date FOR col IN ([date1], [date2], [date3])) UNPVT
GROUP BY call_case

select call_case , max(cast(x.Item as date)) as 'Latest Date' from #indebtedness  t
cross apply dbo.SplitString(concat(date1, ',', date2, ',', date3), ',') x
group by call_case

यह महान जासूसी का काम है +1, और मुझे आश्चर्य है कि इसने किसी भी उभार को आकर्षित करने से बचा है।
बजे टिम बेज़ेलिसेन

यह बहुत ही उपयोगी उत्तर है +1
अहमद अलखतेब

11

इसे इस्तेमाल करे:

SELECT call_case,
  (SELECT
     MAX(call_case) 
   FROM ( VALUES 
            (MAX(date1)), 
            (MAX(date2))
            ,(max(date3)) 
        ) MyAlias(call_case)
  ) 
FROM #indebtedness
group by call_case

@ अहमद अलखतेब । । यह सबसे अच्छा जवाब है। यह NULLएस को संभालता है , अच्छा प्रदर्शन होना चाहिए, और आसानी से अधिक कॉलम के लिए सामान्यीकृत होता है।
गॉर्डन लिनोफ 12

VALUES में MAX () और ग्रुप BY आवश्यक नहीं हैं और क्वेरी को धीमा बनाता है; बेहतर सिर्फ सही i.call_case, (SELECT MAX (d.date) FROM (VALUES ((i.date1))), ((i.date2)), ((i.date3)) AS d (दिनांक) AS के रूप में उपयोग करें #Indebtedness के रूप में मैं से MAX_DATE
थॉमस फ्रांज

8

SQL FIDDLE

उपयोग MAX()

SELECT call_case,
  (SELECT Max(v) 
   FROM (VALUES (date1), (date2), (date3),...) AS value(v)) as [MostRecentDate]
FROM #indebtedness

उपयोग CASE

 SELECT
        CASE
            WHEN Date1 >= Date2 AND Date1 >= Date3 THEN Date1
            WHEN Date2 >= Date1 AND Date2 >= Date3 THEN Date2
            WHEN Date3 >= Date1 AND Date3 >= Date2 THEN Date3
            ELSE                                        Date1
        END AS MostRecentDate
 FROM  #indebtedness

2
डाउन वोटों पर कोई सुराग नहीं, मेरी राय में MAX का उपयोग करके आपका उदाहरण स्वीकृत समाधान की तुलना में कहीं अधिक सुरुचिपूर्ण है (जो कि बहुत बड़ा बोझिल हो जाएगा यदि बड़ी संख्या में स्तंभ थे)।
बार्नीएल

1
मैं सहमत हूं, अधिक मूल्यों के साथ विधि का उपयोग VALUESकरना एक बड़ी CASEअभिव्यक्ति की तुलना में अधिक स्केलेबल है । मैं यह भी सीखना चाहूंगा कि इसे क्यों उतारा गया, क्योंकि मतदाता को लगता है कि एसक्यूएल के साथ कोई समस्या है, और इसलिए यदि वे हमें वह समस्या बताते हैं तो हम इससे सीख सकते हैं।
लारनु

1

मेरे विचार में, Pivot इस क्वेरी के लिए सबसे अच्छा और कुशल विकल्प है। MS SQL SERVER में कॉपी और पेस्ट करें। कृपया नीचे लिखे कोड की जाँच करें:

CREATE TABLE #indebtedness (call_case CHAR(10), date1 DATETIME, date2 DATETIME, date3 DATETIME)
INSERT #indebtedness VALUES ('Key1', '2019-10-30', '2019-11-30', '2019-10-31')
INSERT #indebtedness VALUES ('Key2', '2019-10-20', '2019-10-30', '2019-11-21')
INSERT #indebtedness VALUES ('Key3', '2019-11-11', '2019-10-29', '2019-10-30')
INSERT #indebtedness VALUES ('Key4', Null, '2019-10-29', '2019-10-13')

--Solution-1:
SELECT        
    call_case,
    MAX(RecnetDate) as MaxDateColumn         
FROM #indebtedness
UNPIVOT
(RecnetDate FOR COL IN ([date1], [date2], [date3])) as TRANSPOSE
GROUP BY call_case 

--Solution-2:
select 
    call_case, case 
    when date1>date2 and date1 > date3 then date1
    when date2>date3                   then date2
    when date3>date1                   then date1 
   else date3 end as date
from #indebtedness as a 


Drop table #indebtedness

0

यह वास्तव में डिज़ाइन स्तर पर फिर से मूल्यांकन किया जाना चाहिए जैसा कि अन्य ने संकेत दिया है। नीचे दो तालिकाओं का उपयोग करके बेहतर डिज़ाइन का एक उदाहरण दिया गया है जो आपके परिणामों की तलाश में है। यह विकास को और अधिक अनुकूल बना देगा।

यहाँ एक उदाहरण है (प्रयुक्त विभिन्न तालिका नाम):

-- Drop pre-existing tables
DROP TABLE #call_log
DROP TABLE #case_type

-- Create table for Case Types
CREATE TABLE #case_type (id INT PRIMARY KEY CLUSTERED NOT NULL, 
    descript VARCHAR(50) NOT NULL)
INSERT #case_type VALUES (1,'No Answer')
INSERT #case_type VALUES (2,'Answer')
INSERT #case_type VALUES (3,'Not Exist')
INSERT #case_type VALUES (4,'whatsapp')
INSERT #case_type VALUES (5,'autodial')
INSERT #case_type VALUES (6,'SMS')

-- Create a Call Log table with a primary identity key and also an index on the call types
CREATE TABLE #call_log (call_num BIGINT PRIMARY KEY CLUSTERED IDENTITY NOT NULL,
    call_type INT NOT NULL REFERENCES #case_type(id), call_date DATETIME)
CREATE NONCLUSTERED INDEX ix_call_log_entry_type ON #call_log(call_type)
INSERT #call_log(call_type, call_date) VALUES (1,'2019-11-30')
INSERT #call_log(call_type, call_date) VALUES (2,'2019-10-15')
INSERT #call_log(call_type, call_date) VALUES (3,null)
INSERT #call_log(call_type, call_date) VALUES (3,'2019-10-29')
INSERT #call_log(call_type, call_date) VALUES (1,'2019-10-25')
INSERT #call_log(call_type, call_date) VALUES (2,'2019-10-30')
INSERT #call_log(call_type, call_date) VALUES (3,'2019-10-13')
INSERT #call_log(call_type, call_date) VALUES (2,'2019-10-20')
INSERT #call_log(call_type, call_date) VALUES (1,'2019-10-30')

-- use an aggregate to show only the latest date for each case type
SELECT DISTINCT ct.descript, MAX(cl.call_date) AS "Date" 
    FROM #call_log cl JOIN #case_type ct ON cl.call_type = ct.id GROUP BY ct.descript

यह अधिक केस प्रकारों को जोड़ने की अनुमति देता है, कई और लॉग प्रविष्टियों को जोड़ा जाता है और एक बेहतर डिजाइन प्रदान करता है।

यह सीखने के उद्देश्यों के लिए सिर्फ एक उदाहरण है।


उपयोगकर्ता की स्थिति के आधार पर डेटाबेस को फिर से डिज़ाइन करना एक विकल्प नहीं हो सकता है। ऐसे अन्य विकल्प उपलब्ध हैं जिन्हें डेटा के पुनर्गठन की आवश्यकता नहीं है।
DWRoelands

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