SQLite में डुप्लिकेट पंक्तियों को वापस करने के लिए यहां ग्यारह विकल्प दिए गए हैं जब उन पंक्तियों में प्राथमिक कुंजी या कोई अन्य विशिष्ट पहचानकर्ता कॉलम होता है (लेकिन आप प्राथमिक कुंजी को अनदेखा करना चाहते हैं)।
इसका मतलब यह है कि डुप्लीकेट पंक्तियों में उनके प्राथमिक कुंजी/अद्वितीय आईडी कॉलम के अपवाद के साथ सभी स्तंभों में बिल्कुल समान मान हैं।
नमूना डेटा
हम अपने उदाहरणों के लिए निम्नलिखित डेटा का उपयोग करेंगे:
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
ORDER BY Count DESC;परिणाम:
FirstName LastName Count --------- -------- ----- Wag Johnson 3 Bark Smith 2 Ruff Robinson 1 Woof Jones 1
यहां हमने प्राथमिक कुंजी कॉलम को अपनी क्वेरी से हटाकर बाहर कर दिया है। हमने इसे अवरोही क्रम में गिनती के आधार पर भी आदेश दिया, ताकि डुप्लिकेट पहले दिखाई दें।
परिणाम हमें बताता है कि वैग जॉनसन वाली तीन पंक्तियाँ और बार्क स्मिथ वाली दो पंक्तियाँ हैं। ये डुप्लीकेट हैं (या वैग जॉनसन के मामले में तीन प्रतियों में)। अन्य दो पंक्तियों में कोई डुप्लीकेट नहीं है।
विकल्प 2
हम HAVING . का उपयोग कर सकते हैं गैर-डुप्लिकेट को आउटपुट से बाहर करने के लिए क्लॉज:
SELECT
FirstName,
LastName,
COUNT(*) AS Count
FROM Dogs
GROUP BY FirstName, LastName
HAVING COUNT(*) > 1
ORDER BY Count DESC;परिणाम:
FirstName LastName Count --------- -------- ----- Wag Johnson 3 Bark Smith 2
विकल्प 3
समवर्ती स्तंभों पर डुप्लिकेट की जाँच का एक उदाहरण यहां दिया गया है। इस मामले में हम DISTINCT . का उपयोग करते हैं विशिष्ट मान प्राप्त करने के लिए कीवर्ड, फिर COUNT() . का उपयोग करें गिनती वापस करने के लिए कार्य करें:
SELECT
DISTINCT FirstName || ' ' || LastName AS DogName,
COUNT(*) AS Count
FROM Dogs
GROUP BY FirstName || ' ' || LastName
ORDER BY Count DESC;परिणाम:
DogName Count ------------- ----- Wag Johnson 3 Bark Smith 2 Woof Jones 1 Ruff Robinson 1
विकल्प 4
डिफ़ॉल्ट रूप से, SQLite में प्रत्येक पंक्ति में एक विशेष कॉलम होता है, जिसे आमतौर पर rowid कहा जाता है। , जो विशिष्ट रूप से तालिका के भीतर उस पंक्ति की पहचान करता है। जब तक इसे तालिका से स्पष्ट रूप से हटाया नहीं गया है, आप इसे प्रत्येक पंक्ति के लिए एक अद्वितीय पहचानकर्ता के रूप में उपयोग कर सकते हैं।
इसलिए हम rowid . का उपयोग कर सकते हैं हमारी क्वेरी में:
SELECT * FROM Dogs
WHERE EXISTS (
SELECT 1 FROM Dogs d2
WHERE Dogs.FirstName = d2.FirstName
AND Dogs.LastName = d2.LastName
AND Dogs.rowid > d2.rowid
);परिणाम:
DogId FirstName LastName ----- --------- -------- 2 Bark Smith 6 Wag Johnson 7 Wag Johnson
हम SELECT * . को बदल सकते हैं DELETE के साथ टेबल पर डी-डुपिंग ऑपरेशन करने के लिए।
ध्यान दें कि हम DogId . का उपयोग कर सकते थे rowid . के बजाय कॉलम (हमारी प्राथमिक कुंजी) अगर हम चाहते थे। उस ने कहा, rowid यदि आप किसी कारण से प्राथमिक कुंजी कॉलम का उपयोग नहीं कर सकते हैं, या तालिका में प्राथमिक कुंजी नहीं है, तो यह उपयोगी हो सकता है।
विकल्प 5
यहां एक और क्वेरी है जो rowid . का उपयोग करती है :
SELECT * FROM Dogs
WHERE rowid > (
SELECT MIN(rowid) FROM Dogs d2
WHERE Dogs.FirstName = d2.FirstName
AND Dogs.LastName = d2.LastName
);परिणाम:
DogId FirstName LastName ----- --------- -------- 2 Bark Smith 6 Wag Johnson 7 Wag Johnson
पिछले उदाहरण की तरह, हम SELECT * . को बदल सकते हैं DELETE के साथ डुप्लिकेट पंक्तियों को हटाने के लिए।
विकल्प 6
दो rowid यदि आपको अपनी क्वेरी में प्राथमिक कुंजी को पूरी तरह से अनदेखा करना चाहिए (या यदि आपके पास प्राथमिक कुंजी कॉलम बिल्कुल नहीं है) तो उपरोक्त विकल्प बहुत अच्छे हैं। हालांकि जैसा कि बताया गया है, अभी भी rowid . को बदलने का विकल्प है प्राथमिक कुंजी कॉलम के साथ - हमारे मामले में DogId कॉलम:
SELECT * FROM Dogs
WHERE EXISTS (
SELECT 1 FROM Dogs d2
WHERE Dogs.FirstName = d2.FirstName
AND Dogs.LastName = d2.LastName
AND Dogs.DogId > d2.DogId
);परिणाम:
DogId FirstName LastName ----- --------- -------- 2 Bark Smith 6 Wag Johnson 7 Wag Johnson
विकल्प 7
और यहां rowid के साथ अन्य क्वेरी है DogId . द्वारा प्रतिस्थापित किया गया कॉलम:
SELECT * FROM Dogs
WHERE DogId > (
SELECT MIN(DogId) FROM Dogs d2
WHERE Dogs.FirstName = d2.FirstName
AND Dogs.LastName = d2.LastName
);परिणाम:
DogId FirstName LastName ----- --------- -------- 2 Bark Smith 6 Wag Johnson 7 Wag Johnson
विकल्प 8
इसे करने का दूसरा तरीका 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 का उपयोग करना क्लॉज के परिणामस्वरूप एक नया कॉलम जोड़ा जाता है, जिसमें एक पंक्ति संख्या होती है जो हर बार डुप्लिकेट होने पर बढ़ती है, लेकिन एक अद्वितीय पंक्ति होने पर फिर से रीसेट हो जाती है।
इस मामले में हम परिणामों को समूहीकृत नहीं करते हैं, जिसका अर्थ है कि हम प्रत्येक डुप्लिकेट पंक्ति को उसके विशिष्ट पहचानकर्ता कॉलम सहित देख सकते हैं।
विकल्प 9
हम पिछले उदाहरण का उपयोग एक बड़ी क्वेरी में एक सामान्य तालिका अभिव्यक्ति के रूप में भी कर सकते हैं:
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
यह आउटपुट से गैर-डुप्लिकेट को बाहर करता है, और यह आउटपुट से प्रत्येक डुप्लिकेट की एक पंक्ति को बाहर करता है।
विकल्प 10
पिछले उदाहरण के समान आउटपुट प्राप्त करने का एक और तरीका यहां दिया गया है:
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
विकल्प 11
हमारी तालिका से डुप्लीकेट चुनने का एक और विकल्प यहां दिया गया है:
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
