आसानी से उन पंक्तियों को दिखाएं जो दो तालिकाओं या प्रश्नों के बीच भिन्न हैं

Question

कल्पना करें कि आपके पास दो अलग-अलग तालिकाएँ / क्वेरीज़ हैं जो समान डेटा के लिए / वापसी करने वाली हैं। आप इसे सत्यापित करना चाहते हैं। नीचे दिए गए उदाहरण की तरह हर तालिका से किसी भी बेजोड़ पंक्तियों को दिखाने के लिए हर कॉलम की तुलना करने का एक आसान तरीका है? मान लें कि तालिकाओं में 30 कॉलम हैं, जिनमें से कई NULLable हैं।

जब कोई पीके नहीं है या प्रति पीके डुप्लिकेट हो सकता है, तो सिर्फ पीके कॉलम में शामिल होना ही पर्याप्त नहीं है, और यह एक आपदा होगी जिसमें 30 जॉइन की शर्तों के साथ पूर्ण जॉइन करना होगा जो NULLs को ठीक से संभालेंगे, साथ ही एक बुरा स्थिति मिलान की गई पंक्तियों को बाहर करने के लिए।

आम तौर पर ऐसा तब होता है जब मैं अनसेबर्ड या नॉट-फुल-समझे गए डेटा के खिलाफ एक नई क्वेरी लिख रहा हूं कि समस्या सबसे खराब है और पीके के तार्किक रूप से उपलब्ध होने की संभावना बेहद कम है। मैं समस्या को हल करने के लिए दो अलग-अलग तरीके से खाना बनाता हूं और फिर उनके परिणामों की तुलना करता हूं, डेटा में विशेष मामलों को उजागर करने वाले अंतर जिनसे मैं अनजान था।

परिणाम को इस तरह देखना होगा:

Which   Col1   Col2   Col3   ... Col30
------  ------ ------ ------     ------
TableA  Cat    27     86               -- mismatch
TableB  Cat    27     105              -- mismatch
TableB  Cat    27     87               -- mismatch 2
TableA  Cat    128    92               -- no corresponding row
TableB  Lizard 83     NULL             -- no corresponding row

यदि [Col1, Col2]एक कम्पोजिट कुंजी होती है और हम अपने अंतिम परिणाम में उनके द्वारा ऑर्डर करते हैं, तो हम आसानी से देख सकते हैं कि ए और बी में एक पंक्ति अलग है जो समान होनी चाहिए, और प्रत्येक में एक पंक्ति है जो दूसरे में नहीं है।

उपरोक्त उदाहरण में, पहली पंक्ति को दो बार देखना वांछनीय नहीं है।

यहाँ नमूना तालिकाएँ और डेटा सेट करने के लिए DDL और DML है:

CREATE TABLE dbo.TableA (
   Col1 varchar(10),
   Col2 int,
   Col3 int,
   Col4 varchar(10),
   Col5 varchar(10),
   Col6 varchar(10),
   Col7 varchar(10),
   Col8 varchar(10),
   Col9 varchar(10),
   Col10 varchar(10),
   Col11 varchar(10),
   Col12 varchar(10),
   Col13 varchar(10),
   Col14 varchar(10),
   Col15 varchar(10),
   Col16 varchar(10),
   Col17 varchar(10),
   Col18 varchar(10),
   Col19 varchar(10),
   Col20 varchar(10),
   Col21 varchar(10),
   Col22 varchar(10),
   Col23 varchar(10),
   Col24 varchar(10),
   Col25 varchar(10),
   Col26 varchar(10),
   Col27 varchar(10),
   Col28 varchar(10),
   Col29 varchar(10),
   Col30 varchar(10)
);

CREATE TABLE dbo.TableB (
   Col1 varchar(10),
   Col2 int,
   Col3 int,
   Col4 varchar(10),
   Col5 varchar(10),
   Col6 varchar(10),
   Col7 varchar(10),
   Col8 varchar(10),
   Col9 varchar(10),
   Col10 varchar(10),
   Col11 varchar(10),
   Col12 varchar(10),
   Col13 varchar(10),
   Col14 varchar(10),
   Col15 varchar(10),
   Col16 varchar(10),
   Col17 varchar(10),
   Col18 varchar(10),
   Col19 varchar(10),
   Col20 varchar(10),
   Col21 varchar(10),
   Col22 varchar(10),
   Col23 varchar(10),
   Col24 varchar(10),
   Col25 varchar(10),
   Col26 varchar(10),
   Col27 varchar(10),
   Col28 varchar(10),
   Col29 varchar(10),
   Col30 varchar(10)
);

INSERT dbo.TableA (Col1, Col2, Col3, Col4, Col5, Col6, Col7, Col8, Col9, Col10, Col11, Col12, Col13, Col14, Col15, Col16, Col17, Col18, Col19, Col20, Col21, Col22, Col23, Col24, Col25, Col26, Col27, Col28, Col29, Col30)
VALUES
   ('Cat', 27, 86, 'a', 'b', 'c', 'd', 'e', 'f', 'g',' h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '0'),
   ('Cat', 128, 92, 'a', 'b', 'c', 'd', 'e', 'f', 'g',' h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '0'),
   ('Porcupine', NULL, 42, 'a', 'b', 'c', 'd', 'e', 'f', 'g',' h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '0'),
   ('Tapir', NULL, NULL, 'a', 'b', 'c', 'd', 'e', 'f', 'g',' h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '0')
;

INSERT dbo.TableB (Col1, Col2, Col3, Col4, Col5, Col6, Col7, Col8, Col9, Col10, Col11, Col12, Col13, Col14, Col15, Col16, Col17, Col18, Col19, Col20, Col21, Col22, Col23, Col24, Col25, Col26, Col27, Col28, Col29, Col30)
VALUES
   ('Cat', 27, 105, 'a', 'b', 'c', 'd', 'e', 'f', 'g',' h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '0'),
   ('Cat', 27, 87, 'a', 'b', 'c', 'd', 'e', 'f', 'g',' h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '0'),
   ('Lizard', 83, NULL, 'a', 'b', 'c', 'd', 'e', 'f', 'g',' h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '0'),
   ('Porcupine', NULL, 42, 'a', 'b', 'c', 'd', 'e', 'f', 'g',' h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '0'),
   ('Tapir', NULL, NULL, 'a', 'b', 'c', 'd', 'e', 'f', 'g',' h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '0');

Answer 1

यहां आपको 30 जॉइन की शर्तों की जरूरत नहीं FULL OUTER JOINहै।

आप पीके पर केवल पूर्ण आउटर में शामिल हो सकते हैं, पंक्तियों को कम से कम एक अंतर के साथ संरक्षित कर सकते हैं WHERE EXISTS (SELECT A.* EXCEPT SELECT B.*)और एड रो के CROSS APPLY (SELECT A.* UNION ALL SELECT B.*)दोनों किनारों JOINको अलग-अलग पंक्तियों में बाहर निकालने के लिए उपयोग कर सकते हैं।

WITH TableA(Col1, Col2, Col3) 
     AS (SELECT 'Dog',1,1     UNION ALL 
         SELECT 'Cat',27,86   UNION ALL 
         SELECT 'Cat',128,92), 
     TableB(Col1, Col2, Col3) 
     AS (SELECT 'Dog',1,1     UNION ALL 
         SELECT 'Cat',27,105  UNION ALL 
         SELECT 'Lizard',83,NULL) 
SELECT CA.*
FROM   TableA A 
       FULL OUTER JOIN TableB B 
         ON A.Col1 = B.Col1 
            AND A.Col2 = B.Col2 
/*Unpivot the joined rows*/
CROSS APPLY (SELECT 'TableA' AS what, A.* UNION ALL
             SELECT 'TableB' AS what, B.*) AS CA     
/*Exclude identical rows*/
WHERE  EXISTS (SELECT A.* 
               EXCEPT 
               SELECT B.*) 
/*Discard NULL extended row*/
AND CA.Col1 IS NOT NULL      
ORDER BY CA.Col1, CA.Col2

देता है

what   Col1   Col2        Col3
------ ------ ----------- -----------
TableA Cat    27          86
TableB Cat    27          105
TableA Cat    128         92
TableB Lizard 83          NULL

या स्थानांतरित गोलपोस्ट से निपटने वाला संस्करण।

SELECT DISTINCT CA.*
FROM   TableA A 
       FULL OUTER JOIN TableB B 
         ON EXISTS (SELECT A.*  INTERSECT  SELECT B.*) 
CROSS APPLY (SELECT 'TableA' AS what, A.* UNION ALL
             SELECT 'TableB' AS what, B.*) AS CA     
WHERE NOT EXISTS (SELECT A.*  INTERSECT  SELECT B.*) 
AND CA.Col1 IS NOT NULL
ORDER BY CA.Col1, CA.Col2  

---

कई स्तंभों वाली तालिकाओं के लिए अभी भी विशिष्ट स्तंभों को पहचानना मुश्किल हो सकता है। उसके लिए आप संभावित रूप से नीचे का उपयोग कर सकते हैं।

(हालांकि सिर्फ अपेक्षाकृत छोटे तालिकाओं पर अन्यथा इस विधि की पर्याप्त प्रदर्शन नहीं होगा)

SELECT t1.primary_key,
       y1.c,
       y1.v,
       y2.v
FROM   t1
       JOIN t2
         ON t1.primary_key = t2.primary_key
       CROSS APPLY (SELECT t1.*
                    FOR xml path('row'), elements xsinil, type) x1(x)
       CROSS APPLY (SELECT t2.*
                    FOR xml path('row'), elements xsinil, type) x2(x)
       CROSS APPLY (SELECT n.n.value('local-name(.)', 'sysname'),
                           n.n.value('.', 'nvarchar(max)')
                    FROM   x1.x.nodes('row/*') AS n(n)) y1(c, v)
       CROSS APPLY (SELECT n.n.value('local-name(.)', 'sysname'),
                           n.n.value('.', 'nvarchar(max)')
                    FROM   x2.x.nodes('row/*') AS n(n)) y2(c, v)
WHERE  y1.c = y2.c
       AND EXISTS(SELECT y1.v
                  EXCEPT
                  SELECT y2.v) 

Answer 2

यह EXCEPT और / या INTERSECT का उपयोग करके संभाला जा सकता है। http://msdn.microsoft.com/en-us/library/ms188055.aspx

पहले उन सभी रिकॉर्डों को खोजें जो तालिका 1 में हैं जो तालिका 2 में नहीं हैं, फिर उन सभी रिकॉर्डों को खोजें जो तालिका 2 में हैं जो तालिका 1 में नहीं हैं।

SELECT * FROM table1
EXCEPT
SELECT * FROM table2

UNION

SELECT * FROM table2
EXCEPT
SELECT * FROM table1

ऐसा करने के लिए निस्संदेह एक अधिक कुशल तरीका है, लेकिन यह मेरे सिर के ऊपर से पहला "त्वरित और गंदा" समाधान है। इसके अलावा, मैं एक * वाइल्डकार्ड का उपयोग करने की अनुशंसा नहीं करता, लेकिन यह संक्षिप्तता के लिए यहां सूट करता है।

वैकल्पिक रूप से, आप एक अंतर ऑपरेटर का उपयोग कर सकते हैं और इससे सभी परिणामों को बाहर कर सकते हैं।

Comments

SELECT ... EXCEPT ... SELECTदूसरे SELECTकथन के साथ लपेटें और तालिका नाम जोड़ें, अर्थात SELECT "table1", T1.* FROM (SELECT ... EXCEPT ... SELECT) T1फिर UNIONक्वेरी के दूसरे आधे भाग के साथ।

— साइमन रीग्रेट्स

Answer 3

थर्ड पार्टी टूल जैसे डेटा तुलना, या सिर्फ क्लाइंट पर करना आसान है। इकाई परीक्षण संग्रहीत प्रक्रियाओं के संदर्भ में, हमने बस कुछ C # कोड लिखे।

यहां C # कोड का उपयोग किया जा रहा है, जिसे एक पुराने लेख से उद्धृत किया गया है: उन Loopholes को बंद करें - परीक्षण की गई प्रक्रियाएं

   internal static class DataSetComparer
   {
      internal static bool Compare(DataSet one, DataSet two)
      {
         if(one.Tables.Count != two.Tables.Count)
            return false;

         for(int i = 0; i < one.Tables.Count; i++)
            if(!CompareTables(one.Tables[i], two.Tables[i]))
               return false;

         return true;
        }

      private static bool CompareTables(DataTable one, DataTable two)
      {
         if(one.Rows.Count != two.Rows.Count)
            return false;

         for(int i = 0; i < one.Rows.Count; i++)
            if(!CompareRows(one.Rows[i], two.Rows[i]))
               return false;

         return true;
      }

      private static bool CompareRows(DataRow one, DataRow two)
      {
         if(one.ItemArray.Length != two.ItemArray.Length)
            return false;

         for(int i = 0; i < one.ItemArray.Length; i++)
            if(!CompareItems(one.ItemArray[i], two.ItemArray[i]))
               return false;

         return true;
      }

      private static bool CompareItems(object value1, object value2)
      {
         if(value1.GetType() != value2.GetType())
            return false;

         if(value1 is DBNull)
            return true;

         if(value1 is DateTime)
            return ((DateTime) value1).CompareTo((DateTime) value2)
                                                              == 0;

         if(value1 is byte[])
         {
            if(((byte[]) value1).Length != ((byte[]) value2).Length)
               return false;

            for(int i = 0; i < ((byte[]) value1).Length; i++)
               if(((byte[]) value1)[i] != ((byte[]) value2)[i])
                  return false;

            return true;
         }

         return value1.ToString().Equals(value2.ToString());
      }
   }

Answer 4

यहाँ एक तरीका है जो दिखाने के लिए कहा गया था:

SELECT
   Which = 'TableA',
   *
FROM (
   SELECT * FROM dbo.TableA
   EXCEPT
   SELECT * FROM dbo.TableB
) X
UNION ALL
SELECT
   'TableB',
   *
FROM (
   SELECT * FROM dbo.TableB
   EXCEPT
   SELECT * FROM dbo.TableA
) X
ORDER BY
   Col1, Col2, Col3, Col4, Col5, Col6, Col7, Col8, Col9, Col10, Col11, Col12, Col13, Col14, Col15, Col16, Col17, Col18, Col19, Col20, Col21, Col22, Col23, Col24, Col25, Col26, Col27, Col28, Col29, Col30
;