प्राथमिक कुंजी को अनदेखा करते हुए PostgreSQL में डुप्लिकेट पंक्तियों को खोजने के 7 तरीके

PostgreSQL में डुप्लिकेट पंक्तियों को वापस करने के सात तरीके यहां दिए गए हैं जब उन पंक्तियों में प्राथमिक कुंजी या अन्य विशिष्ट पहचानकर्ता कॉलम होता है।

इसका मतलब यह है कि डुप्लीकेट पंक्तियों में उनके प्राथमिक कुंजी/अद्वितीय आईडी कॉलम के अपवाद के साथ सभी कॉलम में बिल्कुल समान मान हैं।

नमूना डेटा

हम अपने उदाहरणों के लिए निम्नलिखित डेटा का उपयोग करेंगे:

SELECT * FROM Dogs;

परिणाम:

 dogid | firstname | lastname 
-------+-----------+----------
     1 | Bark      | Smith
     2 | Bark      | Smith
     3 | Woof      | Jones
     4 | Ruff      | Robinson
     5 | Wag       | Johnson
     6 | Wag       | Johnson
     7 | Wag       | Johnson

पहली दो पंक्तियाँ डुप्लीकेट हैं (DogId . को छोड़कर) कॉलम, जो तालिका की प्राथमिक कुंजी है, और इसमें सभी पंक्तियों में एक अद्वितीय मान होता है)। अंतिम तीन पंक्तियाँ भी डुप्लीकेट हैं (DogId . को छोड़कर) कॉलम)।

प्राथमिक कुंजी कॉलम यह सुनिश्चित करता है कि कोई डुप्लिकेट पंक्तियाँ नहीं हैं, जो कि RDBMS में अच्छा अभ्यास है, क्योंकि प्राथमिक कुंजियाँ डेटा अखंडता को लागू करने में मदद करती हैं। लेकिन चूंकि प्राथमिक कुंजियाँ डुप्लिकेट पंक्तियों को रोकती हैं, इसलिए उनमें डुप्लिकेट खोजने की हमारी क्षमता में हस्तक्षेप करने की क्षमता होती है।

ऊपर हमारी तालिका में, प्राथमिक कुंजी कॉलम एक वृद्धिशील संख्या है, और इसका मान कोई अर्थ नहीं रखता है और यह महत्वपूर्ण नहीं है। इसलिए यदि हम दूसरे कॉलम में डुप्लीकेट ढूंढना चाहते हैं तो हमें उस पंक्ति को अनदेखा करना होगा।

विकल्प 1

हम SQL का उपयोग कर सकते हैं GROUP BY कॉलम को उनके महत्वपूर्ण कॉलम द्वारा समूहित करने के लिए क्लॉज करें, फिर COUNT() . का उपयोग करें समान पंक्तियों की संख्या वापस करने के लिए कार्य:

SELECT 
    FirstName, 
    LastName, 
    COUNT(*) AS Count
FROM Dogs
GROUP BY FirstName, LastName;

परिणाम:

 firstname | lastname | count 
-----------+----------+-------
 Ruff      | Robinson |     1
 Wag       | Johnson  |     3
 Woof      | Jones    |     1
 Bark      | Smith    |     2

यहां हमने प्राथमिक कुंजी कॉलम को अपनी क्वेरी से हटाकर बाहर कर दिया है।

परिणाम हमें बताता है कि वैग जॉनसन वाली तीन पंक्तियाँ और बार्क स्मिथ वाली दो पंक्तियाँ हैं। ये डुप्लीकेट हैं (या वैग जॉनसन के मामले में तीन प्रतियों में)। अन्य दो पंक्तियों में कोई डुप्लीकेट नहीं है।

विकल्प 2

हम आउटपुट से गैर-डुप्लिकेट को HAVING . के साथ बाहर कर सकते हैं खंड:

SELECT 
    FirstName, 
    LastName, 
    COUNT(*) AS Count
FROM Dogs
GROUP BY FirstName, LastName
HAVING COUNT(*) > 1;

परिणाम:

 firstname | lastname | count 
-----------+----------+-------
 Wag       | Johnson  |     3
 Bark      | Smith    |     2

विकल्प 3

समवर्ती स्तंभों पर डुप्लिकेट की जाँच का एक उदाहरण यहां दिया गया है। इस मामले में हम CONCAT() . का उपयोग करते हैं हमारे दो स्तंभों को जोड़ने के लिए कार्य करें, DISTINCT . का उपयोग करें विशिष्ट मान प्राप्त करने के लिए कीवर्ड, फिर COUNT() . का उपयोग करें गिनती वापस करने के लिए कार्य करें:

SELECT
    DISTINCT CONCAT(FirstName, ' ', LastName) AS DogName,
    COUNT(*) AS Count
FROM Dogs
GROUP BY CONCAT(FirstName, ' ', LastName);

परिणाम:

    dogname    | count 
---------------+-------
 Wag Johnson   |     3
 Ruff Robinson |     1
 Woof Jones    |     1
 Bark Smith    |     2

विकल्प 4

हम वैकल्पिक रूप से ROW_NUMBER() . का उपयोग कर सकते हैं विंडो फ़ंक्शन:

SELECT 
    *,
    ROW_NUMBER() OVER ( 
        PARTITION BY FirstName, LastName 
        ORDER BY FirstName, LastName
        ) AS Row_Number
FROM Dogs;

परिणाम:

 dogid | firstname | lastname | row_number 
-------+-----------+----------+------------
     1 | Bark      | Smith    |          1
     2 | Bark      | Smith    |          2
     4 | Ruff      | Robinson |          1
     5 | Wag       | Johnson  |          1
     6 | Wag       | Johnson  |          2
     7 | Wag       | Johnson  |          3
     3 | Woof      | Jones    |          1

PARTITION का उपयोग करना क्लॉज के परिणामस्वरूप एक नया कॉलम जोड़ा जाता है, जिसमें एक पंक्ति संख्या होती है जो हर बार डुप्लिकेट होने पर बढ़ती है, लेकिन एक अद्वितीय पंक्ति होने पर फिर से रीसेट हो जाती है।

इस मामले में हम परिणामों को समूहीकृत नहीं करते हैं, जिसका अर्थ है कि हम प्रत्येक डुप्लिकेट पंक्ति को उसके विशिष्ट पहचानकर्ता कॉलम सहित देख सकते हैं।

विकल्प 5

हम पिछले उदाहरण का उपयोग एक बड़ी क्वेरी में एक सामान्य तालिका अभिव्यक्ति के रूप में भी कर सकते हैं:

WITH cte AS 
    (
        SELECT 
            *,
            ROW_NUMBER() OVER ( 
                PARTITION BY FirstName, LastName 
                ORDER BY FirstName, LastName
                ) AS Row_Number
        FROM Dogs
    )
SELECT * FROM cte WHERE Row_Number <> 1;

परिणाम:

 dogid | firstname | lastname | row_number 
-------+-----------+----------+------------
     2 | Bark      | Smith    |          2
     6 | Wag       | Johnson  |          2
     7 | Wag       | Johnson  |          3

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

विकल्प 6

पिछले उदाहरण के समान आउटपुट प्राप्त करने का एक और संक्षिप्त तरीका यहां दिया गया है:

SELECT * FROM Dogs 
WHERE DogId IN (
    SELECT DogId FROM Dogs 
    EXCEPT SELECT MIN(DogId) FROM Dogs 
    GROUP BY FirstName, LastName
    );

परिणाम:

 dogid | firstname | lastname 
-------+-----------+----------
     6 | Wag       | Johnson
     2 | Bark      | Smith
     7 | Wag       | Johnson

इस उदाहरण और पिछले उदाहरण के बीच एक अंतर यह है कि इस उदाहरण के लिए अपनी अलग पंक्ति संख्या उत्पन्न करने की आवश्यकता नहीं है।

विकल्प 7

पोस्टग्रेज़ में डुप्लिकेट पंक्तियों को वापस करने का एक और विकल्प यहां दिया गया है:

SELECT * 
FROM Dogs d1, Dogs d2 
WHERE d1.FirstName = d2.FirstName 
AND d1.LastName = d2.LastName
AND d1.DogId <> d2.DogId 
AND d1.DogId = (
    SELECT MAX(DogId) 
    FROM Dogs d3 
    WHERE d3.FirstName = d1.FirstName 
    AND d3.LastName = d1.LastName
);

परिणाम:

 dogid | firstname | lastname | dogid | firstname | lastname 
-------+-----------+----------+-------+-----------+----------
     2 | Bark      | Smith    |     1 | Bark      | Smith
     7 | Wag       | Johnson  |     5 | Wag       | Johnson
     7 | Wag       | Johnson  |     6 | Wag       | Johnson