SQL सर्वर में डुप्लिकेट पंक्तियों की जाँच करने के 4 तरीके

यहां चार तरीके दिए गए हैं जिनका उपयोग आप SQL सर्वर में डुप्लिकेट पंक्तियों को खोजने के लिए कर सकते हैं।

"डुप्लिकेट पंक्तियों" से मेरा मतलब दो या दो से अधिक पंक्तियों से है जो सभी स्तंभों में बिल्कुल समान मान साझा करते हैं।

नमूना डेटा

मान लीजिए हमारे पास निम्न डेटा वाली एक तालिका है:

SELECT * FROM Pets;

परिणाम:

+---------+-----------+-----------+
| PetId   | PetName   | PetType   |
|---------+-----------+-----------|
| 1       | Wag       | Dog       |
| 1       | Wag       | Dog       |
| 2       | Scratch   | Cat       |
| 3       | Tweet     | Bird      |
| 4       | Bark      | Dog       |
| 4       | Bark      | Dog       |
| 4       | Bark      | Dog       |
+---------+-----------+-----------+

हम देख सकते हैं कि पहली दो पंक्तियाँ डुप्लीकेट हैं, जैसा कि अंतिम तीन पंक्तियाँ हैं।

विकल्प 1

डुप्लिकेट पंक्तियों के बारे में जानकारी वापस करने के लिए हम निम्नलिखित क्वेरी का उपयोग कर सकते हैं:

SELECT 
    DISTINCT PetId, 
    COUNT(*) AS "Count"
FROM Pets
GROUP BY PetId
ORDER BY PetId;

परिणाम:

+---------+---------+
| PetId   | Count   |
|---------+---------|
| 1       | 2       |
| 2       | 1       |
| 3       | 1       |
| 4       | 3       |
+---------+---------+

हम SELECT . का विस्तार कर सकते हैं यदि आवश्यक हो तो और कॉलम शामिल करने के लिए सूची:

SELECT 
    PetId,
    PetName,
    PetType,
    COUNT(*) AS "Count"
FROM Pets
GROUP BY 
    PetId,
    PetName,
    PetType
ORDER BY PetId;

परिणाम:

+---------+-----------+-----------+---------+
| PetId   | PetName   | PetType   | Count   |
|---------+-----------+-----------+---------|
| 1       | Wag       | Dog       | 2       |
| 2       | Scratch   | Cat       | 1       |
| 3       | Tweet     | Bird      | 1       |
| 4       | Bark      | Dog       | 3       |
+---------+-----------+-----------+---------+

यदि तालिका में एक विशिष्ट पहचानकर्ता है, तो हम उस कॉलम को क्वेरी से आसानी से हटा सकते हैं। उदाहरण के लिए, यदि हम मान लें कि PetId कॉलम वास्तव में एक प्राथमिक कुंजी कॉलम है जिसमें एक अद्वितीय आईडी होता है, हम प्राथमिक कुंजी कॉलम की गणना नहीं करते हुए डुप्लिकेट वाली सभी पंक्तियों को वापस करने के लिए निम्न क्वेरी चला सकते हैं:

SELECT 
    PetName,
    PetType,
    COUNT(*) AS "Count"
FROM Pets
GROUP BY 
    PetName,
    PetType
ORDER BY PetName;

परिणाम:

+-----------+-----------+---------+
| PetName   | PetType   | Count   |
|-----------+-----------+---------|
| Bark      | Dog       | 3       |
| Scratch   | Cat       | 1       |
| Tweet     | Bird      | 1       |
| Wag       | Dog       | 2       |
+-----------+-----------+---------+

विकल्प 2

यदि हम केवल वास्तविक डुप्लिकेट पंक्तियों को वापस करना चाहते हैं, तो हम HAVING . जोड़ सकते हैं खंड:

SELECT 
    PetId,
    PetName,
    PetType,
    COUNT(*) AS "Count"
FROM Pets
GROUP BY 
    PetId,
    PetName,
    PetType
HAVING COUNT(*) > 1
ORDER BY PetId;

परिणाम:

+---------+-----------+-----------+---------+
| PetId   | PetName   | PetType   | Count   |
|---------+-----------+-----------+---------|
| 1       | Wag       | Dog       | 2       |
| 4       | Bark      | Dog       | 3       |
+---------+-----------+-----------+---------+

विकल्प 3

इसे करने का दूसरा तरीका ROW_NUMBER() . का उपयोग करना है PARTITION BY . के साथ कार्य करें परिणाम सेट के आउटपुट को क्रमांकित करने के लिए क्लॉज।

SELECT 
    *, 
    ROW_NUMBER() OVER ( 
        PARTITION BY PetId, PetName, PetType 
        ORDER BY PetId, PetName, PetType
        ) AS Row_Number
FROM Pets;

परिणाम:

+---------+-----------+-----------+--------------+
| PetId   | PetName   | PetType   | Row_Number   |
|---------+-----------+-----------+--------------|
| 1       | Wag       | Dog       | 1            |
| 1       | Wag       | Dog       | 2            |
| 2       | Scratch   | Cat       | 1            |
| 3       | Tweet     | Bird      | 1            |
| 4       | Bark      | Dog       | 1            |
| 4       | Bark      | Dog       | 2            |
| 4       | Bark      | Dog       | 3            |
+---------+-----------+-----------+--------------+

PARTITION BY क्लॉज FROM . द्वारा निर्मित परिणाम सेट को विभाजित करता है विभाजन में खंड जिस पर फ़ंक्शन लागू होता है। जब हम परिणाम सेट के लिए विभाजन निर्दिष्ट करते हैं, तो प्रत्येक विभाजन नंबरिंग को फिर से शुरू करने का कारण बनता है (यानी प्रत्येक विभाजन में पहली पंक्ति के लिए नंबरिंग 1 से शुरू होगी)।

विकल्प 4

यदि हम चाहते हैं कि मिलान करने वाले डुप्लीकेट से केवल अधिशेष पंक्तियां लौटाई जाएं, तो हम उपरोक्त क्वेरी को एक सामान्य तालिका अभिव्यक्ति के रूप में उपयोग कर सकते हैं, जैसे:

WITH CTE AS 
    (
        SELECT 
            *, 
            ROW_NUMBER() OVER ( 
                PARTITION BY PetId, PetName, PetType 
                ORDER BY PetId, PetName, PetType
                ) AS Row_Number
        FROM Pets
    )
SELECT * FROM CTE WHERE Row_Number <> 1;

परिणाम:

+---------+-----------+-----------+--------------+
| PetId   | PetName   | PetType   | Row_Number   |
|---------+-----------+-----------+--------------|
| 1       | Wag       | Dog       | 2            |
| 4       | Bark      | Dog       | 2            |
| 4       | Bark      | Dog       | 3            |
+---------+-----------+-----------+--------------+

ऐसा करने का एक लाभ यह है कि हम केवल SELECT * . स्विच करके डुप्लिकेट पंक्तियों को हटा सकते हैं करने के लिए DELETE (अंतिम पंक्ति पर)।

इसलिए हम उपरोक्त कोड का उपयोग यह देखने के लिए कर सकते हैं कि कौन सी पंक्तियां हटा दी जाएंगी, और फिर जब हम संतुष्ट हों कि हम सही पंक्तियों को हटाने जा रहे हैं, तो हम इसे DELETE पर स्विच कर सकते हैं वास्तव में उन्हें हटाने के लिए कथन।

इस तरह:

WITH CTE AS 
    (
        SELECT 
            *, 
            ROW_NUMBER() OVER ( 
                PARTITION BY PetId, PetName, PetType 
                ORDER BY PetId, PetName, PetType
                ) AS Row_Number
        FROM Pets
    )
DELETE FROM CTE WHERE Row_Number <> 1;