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

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

नमूना डेटा

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

DROP TABLE IF EXISTS Dogs;
CREATE TABLE Dogs (
    DogId int PRIMARY KEY NOT NULL,
    FirstName varchar(50),
    LastName varchar(50)
    );

INSERT INTO Dogs VALUES
    (1, 'Bark', 'Smith'),
    (2, 'Bark', 'Smith'),
    (3, 'Woof', 'Jones'),
    (4, 'Ruff', 'Robinson'),
    (5, 'Wag', 'Johnson'),
    (6, 'Wag', 'Johnson'),
    (7, 'Wag', 'Johnson');
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

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

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

परिणाम:

+-----------+----------+-------+
| FirstName | LastName | Count |
+-----------+----------+-------+
| Bark      | Smith    |     2 |
| Woof      | Jones    |     1 |
| Ruff      | Robinson |     1 |
| Wag       | Johnson  |     3 |
+-----------+----------+-------+

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

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

विकल्प 2

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

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

परिणाम:

+-----------+----------+-------+
| FirstName | LastName | Count |
+-----------+----------+-------+
| Bark      | Smith    |     2 |
| Wag       | Johnson  |     3 |
+-----------+----------+-------+

विकल्प 3

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

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

परिणाम:

+---------------+-------+
| DogName       | Count |
+---------------+-------+
| Bark Smith    |     2 |
| Woof Jones    |     1 |
| Ruff Robinson |     1 |
| Wag Johnson   |     3 |
+---------------+-------+

विकल्प 4

हम वैकल्पिक रूप से ROW_NUMBER() . का उपयोग कर सकते हैं PARTITION BY . के साथ कार्य करें खंड:

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

परिणाम:

+-------+-----------+----------+----+
| DogId | FirstName | LastName | rn |
+-------+-----------+----------+----+
|     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 |
+-------+-----------+----------+----+

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

यह तकनीक एक संभावित लाभ प्रदान करती है जिसमें हमें परिणामों को समूहबद्ध करने की आवश्यकता नहीं होती है। इसका मतलब है कि हम प्रत्येक डुप्लिकेट पंक्ति को उसके विशिष्ट पहचानकर्ता कॉलम सहित देख सकते हैं।

विकल्प 5

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

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

परिणाम:

+-------+-----------+----------+----+
| DogId | FirstName | LastName | rn |
+-------+-----------+----------+----+
|     2 | Bark      | Smith    |  2 |
|     6 | Wag       | Johnson  |  2 |
|     7 | Wag       | Johnson  |  3 |
+-------+-----------+----------+----+

यह तकनीक आउटपुट से गैर-डुप्लिकेट को बाहर करती है, और यह आउटपुट से प्रत्येक डुप्लिकेट की एक पंक्ति को बाहर करती है।

इस क्वेरी का उपयोग डी-डुपिंग ऑपरेशन के अग्रदूत के रूप में किया जा सकता है। यदि हम डुप्लिकेट को हटाने का निर्णय लेते हैं तो यह हमें दिखा सकता है कि क्या हटाया जा रहा है। तालिका को डी-डुप्लिकेट करने के लिए, हमें केवल अंतिम SELECT * . को बदलना होगा DELETE के साथ ।

विकल्प 6

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

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

परिणाम:

+-------+-----------+----------+
| DogId | FirstName | LastName |
+-------+-----------+----------+
|     2 | Bark      | Smith    |
|     6 | Wag       | Johnson  |
|     7 | Wag       | Johnson  |
+-------+-----------+----------+

इस तकनीक के लिए हमें ROW_NUMBER() . के साथ एक अलग पंक्ति संख्या उत्पन्न करने की आवश्यकता नहीं है पिछले उदाहरण की तरह।

हम SELECT * . को भी बदल सकते हैं DELETE के साथ डुप्लीकेट मिटाने के लिए।

Option 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  |
+-------+-----------+----------+-------+-----------+----------+