SQL सर्वर में डुप्लिकेट पंक्तियों को खोजने के लिए यहां सात विकल्प दिए गए हैं, जब उन पंक्तियों में प्राथमिक कुंजी या अन्य विशिष्ट पहचानकर्ता कॉलम होता है।
दूसरे शब्दों में, तालिका में दो या दो से अधिक पंक्तियाँ होती हैं जो अपने विशिष्ट पहचानकर्ता कॉलम को छोड़कर सभी स्तंभों में बिल्कुल समान मान साझा करती हैं।
नमूना डेटा
मान लीजिए हमारे पास निम्न डेटा वाली एक तालिका है:
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 का उपयोग करती है खंड:
SELECT
FirstName,
LastName,
COUNT(*) AS Count
FROM Dogs
GROUP BY FirstName, LastName;परिणाम:
+-------------+------------+---------+ | FirstName | LastName | Count | |-------------+------------+---------| | Wag | Johnson | 3 | | Woof | Jones | 1 | | Ruff | Robinson | 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() . का उपयोग कर सकते हैं हमारे दो स्तंभों को जोड़ने का कार्य:
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 | | 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 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 | +---------+-------------+------------+--------------+
यह विकल्प आउटपुट से गैर-डुप्लिकेट को बाहर करता है।
यह आउटपुट से प्रत्येक डुप्लिकेट की ठीक एक पंक्ति को भी बाहर करता है। यह हमारे लिए अंतिम 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 | +-------+-----------+----------+
इस उदाहरण के लिए हमारी अपनी अलग पंक्ति संख्या उत्पन्न करने की आवश्यकता नहीं है।
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 | +---------+-------------+------------+---------+-------------+------------+
यहां तक कि परिणाम अधिक जटिल दिखता है, लेकिन हे, यह अभी भी हमें डुप्लिकेट दिखाता है!
