कई स्तंभों से न्यूनतम मूल्य का चयन करने का सबसे अच्छा तरीका क्या है?

Question 1

SQL सर्वर 2005 में निम्न तालिका दी गई है:

ID   Col1   Col2   Col3
--   ----   ----   ----
1       3     34     76  
2      32    976     24
3       7    235      3
4     245      1    792

निम्नलिखित परिणाम प्राप्त करने वाले क्वेरी को लिखने का सबसे अच्छा तरीका क्या है (यानी कि अंतिम कॉलम की पैदावार - प्रत्येक पंक्ति के लिए Col1, Col2 और Col 3 से बाहर minium मान वाले स्तंभ )?

ID   Col1   Col2   Col3  TheMin
--   ----   ----   ----  ------
1       3     34     76       3
2      32    976     24      24
3       7    235      3       3
4     245      1    792       1

अपडेट करें:

स्पष्टीकरण के लिए (जैसा मैंने कॉमिक्स में कहा है) वास्तविक परिदृश्य में डेटाबेस ठीक से सामान्यीकृत है । ये "सरणी" कॉलम एक वास्तविक तालिका में नहीं हैं, लेकिन एक परिणाम सेट में हैं जो एक रिपोर्ट में आवश्यक है। और नई आवश्यकता यह है कि रिपोर्ट को इस MinValue कॉलम की भी आवश्यकता है। मैं अंतर्निहित परिणाम सेट को नहीं बदल सकता और इसलिए मैं एक आसान "जेल कार्ड से बाहर निकलना" के लिए टी-एसक्यूएल को देख रहा था।

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

वैसे भी, मैंने सोचा कि मैं अपने वर्तमान समाधान को पोस्ट करूंगा, जो मेरी बाधाओं को देखते हुए बहुत अच्छा काम करता है। यह UNPIVOT ऑपरेटर का उपयोग करता है:

with cte (ID, Col1, Col2, Col3)
as
(
    select ID, Col1, Col2, Col3
    from TestTable
)
select cte.ID, Col1, Col2, Col3, TheMin from cte
join
(
    select
        ID, min(Amount) as TheMin
    from 
        cte 
        UNPIVOT (Amount for AmountCol in (Col1, Col2, Col3)) as unpvt
    group by ID
) as minValues
on cte.ID = minValues.ID

मैं कहता हूँ कि मैं यह उम्मीद नहीं करता कि यह सर्वश्रेष्ठ प्रदर्शन की पेशकश करेगा, लेकिन परिस्थितियों को देखते हुए (मैं सभी प्रश्नों को नए MinValue कॉलम की आवश्यकता के लिए पुनः डिज़ाइन नहीं कर सकता), यह एक बहुत ही सुंदर है "जेल से बाहर निकलना कार्ड "।

Question 2

इसे पूरा करने के कई तरीके होने की संभावना है। मेरा सुझाव केस / कब उपयोग करना है। 3 कॉलम के साथ, यह बहुत बुरा नहीं है।

Select Id,
       Case When Col1 < Col2 And Col1 < Col3 Then Col1
            When Col2 < Col1 And Col2 < Col3 Then Col2 
            Else Col3
            End As TheMin
From   YourTableNameHere

Question 3

का उपयोग कर CROSS APPLY:

SELECT ID, Col1, Col2, Col3, MinValue
FROM YourTable
CROSS APPLY (SELECT MIN(d) AS MinValue FROM (VALUES (Col1), (Col2), (Col3)) AS a(d)) A

एसक्यूएल फिडल

Question 4

SELECT ID, Col1, Col2, Col3, 
    (SELECT MIN(Col) FROM (VALUES (Col1), (Col2), (Col3)) AS X(Col)) AS TheMin
FROM Table

Question 5

MySQL पर, इसका उपयोग करें:

select least(col1, col2, col3) FROM yourtable

Question 6

आप एक मोड़ के साथ "जानवर बल" दृष्टिकोण का उपयोग कर सकते हैं:

SELECT CASE
    WHEN Col1 <= Col2 AND Col1 <= Col3 THEN Col1
    WHEN                  Col2 <= Col3 THEN Col2
    ELSE                                    Col3
END AS [Min Value] FROM [Your Table]

जब पहली बार जब स्थिति विफल हो जाती है तो यह गारंटी देता है कि Col1 सबसे छोटा मूल्य नहीं है इसलिए आप इसे बाकी स्थितियों से समाप्त कर सकते हैं। इसी तरह बाद की स्थितियों के लिए। पांच कॉलम के लिए आपकी क्वेरी बन जाती है:

SELECT CASE
    WHEN Col1 <= Col2 AND Col1 <= Col3 AND Col1 <= Col4 AND Col1 <= Col5 THEN Col1
    WHEN                  Col2 <= Col3 AND Col2 <= Col4 AND Col2 <= Col5 THEN Col2
    WHEN                                   Col3 <= Col4 AND Col3 <= Col5 THEN Col3
    WHEN                                                    Col4 <= Col5 THEN Col4
    ELSE                                                                      Col5
END AS [Min Value] FROM [Your Table]

ध्यान दें कि यदि दो या अधिक स्तंभों के बीच एक टाई है, तो <=यह सुनिश्चित करता है कि हम CASEजल्द से जल्द बयान से बाहर निकलें ।

Question 7

यदि कॉलम आपके उदाहरण के अनुसार पूर्णांक थे, तो मैं एक फ़ंक्शन बनाऊंगा:

create function f_min_int(@a as int, @b as int) 
returns int
as
begin
    return case when @a < @b then @a else coalesce(@b,@a) end
end

फिर जब मुझे इसका उपयोग करने की आवश्यकता होगी तो मैं करूंगा:

select col1, col2, col3, dbo.f_min_int(dbo.f_min_int(col1,col2),col3)

यदि आपके पास 5 कॉलम्स हैं तो उपरोक्त बन जाता है

select col1, col2, col3, col4, col5,
dbo.f_min_int(dbo.f_min_int(dbo.f_min_int(dbo.f_min_int(col1,col2),col3),col4),col5)

Question 8

ऐसा करने का सबसे अच्छा तरीका शायद यह करना नहीं है - यह अजीब है कि लोग अपने डेटा को इस तरह से संग्रहीत करने पर जोर देते हैं जिसमें सार्थक जानकारी निकालने के लिए SQL "जिम्नास्टिक" की आवश्यकता होती है, जब वांछित परिणाम प्राप्त करने के लिए बहुत आसान तरीके होते हैं यदि आप बस संरचना अपने स्कीमा थोड़ा बेहतर :-)

ऐसा करने का सही तरीका, मेरी राय में, निम्न तालिका है:

ID    Col    Val
--    ---    ---
 1      1      3
 1      2     34
 1      3     76

 2      1     32
 2      2    976
 2      3     24

 3      1      7
 3      2    235
 3      3      3

 4      1    245
 4      2      1
 4      3    792

साथ ID/Colप्राथमिक कुंजी के रूप (और संभवतः Colएक अतिरिक्त कुंजी के रूप में, अपनी आवश्यकताओं के आधार पर)। तब आपकी क्वेरी सरल हो जाती है select min(val) from tblऔर आप where col = 2अपने अन्य प्रश्नों का उपयोग करके अलग-अलग 'पुराने कॉलम' को अलग-अलग मान सकते हैं। यह भी आसान विस्तार के लिए अनुमति देता है 'पुराने स्तंभों' की संख्या बढ़नी चाहिए।

यह आपके प्रश्नों को इतना आसान बनाता है। मेरे द्वारा उपयोग की जाने वाली सामान्य दिशानिर्देश है, यदि आपके पास कभी ऐसा कुछ है जो डेटाबेस पंक्ति में एक सरणी की तरह दिखता है, तो आप शायद कुछ गलत कर रहे हैं और डेटा के पुनर्गठन के बारे में सोचना चाहिए।

हालाँकि, अगर किसी कारण से आप उन कॉलमों को नहीं बदल सकते हैं, तो मैं सुझाव देता हूँ कि सम्मिलित करें और ट्रिगर्स को अपडेट करें और एक और कॉलम जोड़ें जो इन ट्रिगर्स को न्यूनतम पर सेट करें Col1/2/3। यह ऑपरेशन की 'लागत' को चयन से अद्यतन / सम्मिलित करने के लिए दूर ले जाएगा जहां यह है - मेरे अनुभव में अधिकांश डेटाबेस तालिकाओं को पढ़ने की तुलना में कहीं अधिक बार पढ़ा जाता है इसलिए समय के साथ अधिक कुशल हो जाता है।

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

ID   Col1   Col2   Col3   MinVal
--   ----   ----   ----   ------
 1      3     34     76        3
 2     32    976     24       24
 3      7    235      3        3
 4    245      1    792        1

किसी भी अन्य विकल्प को selectसमय पर निर्णय लेना पड़ता है, आमतौर पर एक बुरा विचार प्रदर्शन-वार होता है, क्योंकि डेटा केवल इन्सर्ट / अपडेट पर बदलता है - एक अन्य कॉलम का जोड़ डीबी में अधिक स्थान लेता है और आवेषण के लिए थोड़ा धीमा होगा और अद्यतन लेकिन चयनों के लिए बहुत तेज़ हो सकते हैं - पसंदीदा दृष्टिकोण को आपकी प्राथमिकताओं पर निर्भर होना चाहिए लेकिन, जैसा कि कहा गया है, अधिकांश तालिकाओं को उनके लिखे जाने की तुलना में कहीं अधिक बार पढ़ा जाता है।

Question 9

आप इसे यूनियन क्वेरी के साथ भी कर सकते हैं। जैसे-जैसे स्तंभों की संख्या बढ़ती जाएगी, आपको क्वेरी को संशोधित करना होगा, लेकिन कम से कम यह एक सीधा आगे संशोधन होगा।

Select T.Id, T.Col1, T.Col2, T.Col3, A.TheMin
From   YourTable T
       Inner Join (
         Select A.Id, Min(A.Col1) As TheMin
         From   (
                Select Id, Col1
                From   YourTable

                Union All

                Select Id, Col2
                From   YourTable

                Union All

                Select Id, Col3
                From   YourTable
                ) As A
         Group By A.Id
       ) As A
       On T.Id = A.Id

Question 10

यह क्रूर बल है लेकिन काम करता है

 select case when col1 <= col2 and col1 <= col3 then col1
           case when col2 <= col1 and col2 <= col3 then col2
           case when col3 <= col1 and col3 <= col2 then col3
    as 'TheMin'
           end

from Table T

... क्योंकि मिनट () केवल एक स्तंभ पर काम करता है और स्तंभों पर नहीं।

Question 11

यह प्रश्न और यह प्रश्न दोनों इसका उत्तर देने का प्रयास करते हैं।

रिकैप यह है कि ओरेकल में इसके लिए एक फ़ंक्शन है, जिसमें Sql सर्वर के साथ आप या तो उपयोगकर्ता-परिभाषित-फ़ंक्शन को परिभाषित करने या केस स्टेटमेंट का उपयोग करने से अटक जाते हैं।

Question 12

कई कॉलम के लिए एक CASE स्टेटमेंट का उपयोग करना सबसे अच्छा है, हालांकि दो संख्यात्मक कॉलम i और j के लिए आप साधारण गणित का उपयोग कर सकते हैं:

min (i, j) = (i + j) / 2 - abs (ij) / 2

इस फॉर्मूले का उपयोग कई कॉलमों का न्यूनतम मूल्य प्राप्त करने के लिए किया जा सकता है लेकिन इसका वास्तव में गन्दा अतीत 2, मिनट (i, j, k) न्यूनतम होगा (i, min (j, k))

Question 13

यदि आप एक संग्रहीत प्रक्रिया बनाने में सक्षम हैं, तो यह मानों की एक सरणी ले सकता है, और आप बस इसे कॉल कर सकते हैं।

Question 14

select *,
case when column1 < columnl2 And column1 < column3 then column1
when columnl2 < column1 And columnl2 < column3 then columnl2
else column3
end As minValue
from   tbl_example

Question 15

यूनियन क्वेरी पर थोड़ा ट्विस्ट:

DECLARE @Foo TABLE (ID INT, Col1 INT, Col2 INT, Col3 INT)

INSERT @Foo (ID, Col1, Col2, Col3)
VALUES
(1, 3, 34, 76),
(2, 32, 976, 24),
(3, 7, 235, 3),
(4, 245, 1, 792)

SELECT
    ID,
    Col1,
    Col2,
    Col3,
    (
        SELECT MIN(T.Col)
        FROM
        (
            SELECT Foo.Col1 AS Col UNION ALL
            SELECT Foo.Col2 AS Col UNION ALL
            SELECT Foo.Col3 AS Col 
        ) AS T
    ) AS TheMin
FROM
    @Foo AS Foo

Question 16

यदि आप SQL 2005 का उपयोग करते हैं तो आप इस तरह से कुछ साफ कर सकते हैं:

;WITH    res
          AS ( SELECT   t.YourID ,
                        CAST(( SELECT   Col1 AS c01 ,
                                        Col2 AS c02 ,
                                        Col3 AS c03 ,
                                        Col4 AS c04 ,
                                        Col5 AS c05
                               FROM     YourTable AS cols
                               WHERE    YourID = t.YourID
                             FOR
                               XML AUTO ,
                                   ELEMENTS
                             ) AS XML) AS colslist
               FROM     YourTable AS t
             )
    SELECT  YourID ,
            colslist.query('for $c in //cols return min(data($c/*))').value('.',
                                            'real') AS YourMin ,
            colslist.query('for $c in //cols return avg(data($c/*))').value('.',
                                            'real') AS YourAvg ,
            colslist.query('for $c in //cols return max(data($c/*))').value('.',
                                            'real') AS YourMax
    FROM    res

इस तरह आप इतने सारे ऑपरेटरों में खो नहीं है :)

हालांकि, यह दूसरी पसंद से धीमी हो सकती है।

यह तुम्हारी पसंद है...

Question 17

नीचे मैं कई तिथियों को प्राप्त करने के लिए एक अस्थायी तालिका का उपयोग करता हूं। पहले अस्थायी टेबल क्वेरीज़ में कई तारीखें (साथ ही क्वेरी के लिए अन्य मान) प्राप्त करने के लिए तालिकाओं को मिलाया गया था, दूसरा अस्थायी तालिका तब विभिन्न स्तंभों और न्यूनतम तिथि का उपयोग करती है, जिनमें कई तारीखें होती हैं।

यह अनिवार्य रूप से यूनियन क्वेरी की तरह है, समान संख्या में पास की आवश्यकता होती है, लेकिन अधिक कुशल हो सकता है (अनुभव के आधार पर, लेकिन परीक्षण की आवश्यकता होगी)। इस मामले में दक्षता एक मुद्दा नहीं था (8,000 रिकॉर्ड)। एक सूचकांक आदि सकता है।

--==================== this gets minimums and global min
if object_id('tempdb..#temp1') is not null
    drop table #temp1
if object_id('tempdb..#temp2') is not null
    drop table #temp2

select r.recordid ,  r.ReferenceNumber, i.InventionTitle, RecordDate, i.ReceivedDate
, min(fi.uploaddate) [Min File Upload], min(fi.CorrespondenceDate) [Min File Correspondence]
into #temp1
from record r 
join Invention i on i.inventionid = r.recordid
left join LnkRecordFile lrf on lrf.recordid = r.recordid
left join fileinformation fi on fi.fileid = lrf.fileid
where r.recorddate > '2015-05-26'
 group by  r.recordid, recorddate, i.ReceivedDate,
 r.ReferenceNumber, i.InventionTitle



select recordid, recorddate [min date]
into #temp2
from #temp1

update #temp2
set [min date] = ReceivedDate 
from #temp1 t1 join #temp2 t2 on t1.recordid = t2.recordid
where t1.ReceivedDate < [min date] and  t1.ReceivedDate > '2001-01-01'

update #temp2 
set [min date] = t1.[Min File Upload]
from #temp1 t1 join #temp2 t2 on t1.recordid = t2.recordid
where t1.[Min File Upload] < [min date] and  t1.[Min File Upload] > '2001-01-01'

update #temp2
set [min date] = t1.[Min File Correspondence]
from #temp1 t1 join #temp2 t2 on t1.recordid = t2.recordid
where t1.[Min File Correspondence] < [min date] and t1.[Min File Correspondence] > '2001-01-01'


select t1.*, t2.[min date] [LOWEST DATE]
from #temp1 t1 join #temp2 t2 on t1.recordid = t2.recordid
order by t1.recordid

Question 18

SELECT [ID],
            (
                SELECT MIN([value].[MinValue])
                FROM
                (
                    VALUES
                        ([Col1]),
                        ([Col1]),
                        ([Col2]),
                        ([Col3])
                ) AS [value] ([MinValue])
           ) AS [MinValue]
FROM Table;

Question 19

यदि आप जानते हैं कि आप किन मूल्यों की तलाश कर रहे हैं, तो आमतौर पर एक स्थिति कोड, निम्नलिखित सहायक हो सकता है:

select case when 0 in (PAGE1STATUS ,PAGE2STATUS ,PAGE3STATUS,
PAGE4STATUS,PAGE5STATUS ,PAGE6STATUS) then 0 else 1 end
FROM CUSTOMERS_FORMS

Question 20

मुझे पता है कि प्रश्न पुराना है, लेकिन मैं अभी भी उत्तर की आवश्यकता में था और अन्य उत्तरों से खुश नहीं था इसलिए मुझे अपना स्वयं का वशीकरण करना पड़ा जो कि @ paxdiablo´s उत्तर पर एक ट्विस्ट है ।

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

एनबी एक-आकार-फिट-सभी समाधान आगे नहीं!

CREATE TABLE #tempTable (ID int, columnName varchar(20), dataValue int)

INSERT INTO #tempTable 
  SELECT ID, 'Col1', Col1
    FROM sourceTable
   WHERE Col1 IS NOT NULL
INSERT INTO #tempTable 
  SELECT ID, 'Col2', Col2
    FROM sourceTable
   WHERE Col2 IS NOT NULL
INSERT INTO #tempTable 
  SELECT ID, 'Col3', Col3
    FROM sourceTable
   WHERE Col3 IS NOT NULL

SELECT ID
     , min(dataValue) AS 'Min'
     , max(dataValue) AS 'Max'
     , max(dataValue) - min(dataValue) AS 'Diff' 
  FROM #tempTable 
  GROUP BY ID

यह 630000 पंक्तियों के स्रोत सेट पर कुछ 30 सेकंड लेता है और केवल सूचकांक-डेटा का उपयोग करता है, इसलिए समय-महत्वपूर्ण प्रक्रिया में चलने वाली चीज़ नहीं है, लेकिन एक बार के डेटा निरीक्षण या दिन के अंत में रिपोर्ट जैसी चीजें आपके लिए हो सकती हैं ठीक है (लेकिन अपने साथियों या वरिष्ठों के साथ इसे सत्यापित करें, कृपया!)। मेरे लिए इस शैली का मुख्य बोनस यह था कि मैं आसानी से अधिक / कम स्तंभों का उपयोग कर सकता हूं और समूहन, फ़िल्टरिंग आदि को बदल सकता हूं, विशेषकर एक बार डेटा की नकल की गई थी।

अतिरिक्त डेटा ( columnName, maxतों, ...) मेरी खोज में मेरी सहायता करने के लिए थे, इसलिए आपको उनकी आवश्यकता नहीं हो सकती है; मैं उन्हें यहाँ छोड़ दिया शायद कुछ विचारों को चिंगारी :-)।