मारियाडीबी में प्राथमिक कुंजी वाली डुप्लिकेट पंक्तियों को वापस करने के 7 तरीके

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

इसलिए, डुप्लीकेट पंक्तियों में उनके विशिष्ट पहचानकर्ता कॉलम को छोड़कर सभी कॉलमों में बिल्कुल समान मान होते हैं।

नमूना डेटा

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

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 |
| Ruff      | Robinson |     1 |
| Wag       | Johnson  |     3 |
| Woof      | Jones    |     1 |
+-----------+----------+-------+

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

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

विकल्प 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 |
| Ruff Robinson |     1 |
| Wag Johnson   |     3 |
| Woof Jones    |     1 |
+---------------+-------+

विकल्प 4

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

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 |
|     6 | Wag       | Johnson  |          1 |
|     5 | 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 Row_Number
        FROM Dogs
    )
SELECT * FROM cte WHERE Row_Number <> 1;

परिणाम:

+-------+-----------+----------+------------+
| DogId | FirstName | LastName | Row_Number |
+-------+-----------+----------+------------+
|     2 | Bark      | Smith    |          2 |
|     5 | Wag       | Johnson  |          2 |
|     7 | Wag       | Johnson  |          3 |
+-------+-----------+----------+------------+

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

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

विकल्प 6

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

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

परिणाम:

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

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

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

विकल्प 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  |
+-------+-----------+----------+-------+-----------+----------+