SQLite
 sql >> डेटाबेस >  >> RDS >> SQLite

SQLite में डुप्लिकेट पंक्तियों का चयन करने के 6 तरीके

SQLite में डुप्लिकेट पंक्तियों को वापस करने के लिए निम्न प्रश्नों का उपयोग किया जा सकता है।

यहां, डुप्लिकेट पंक्तियों में आईडी कॉलम सहित सभी कॉलम में डुप्लिकेट मान होते हैं।

नमूना डेटा

मान लीजिए हमारे पास निम्न डेटा वाली एक तालिका है:

SELECT * FROM Pets;

परिणाम:

PetId  PetName  PetType
-----  -------  -------
1      Wag      Dog    
1      Wag      Dog    
2      Scratch  Cat    
3      Tweet    Bird   
4      Bark     Dog    
4      Bark     Dog    
4      Bark     Dog    

पहली दो पंक्तियाँ डुप्लिकेट हैं, जैसा कि अंतिम तीन पंक्तियाँ हैं। ऐसा इसलिए है क्योंकि सभी तीन स्तंभों में प्रत्येक डुप्लिकेट पंक्ति में समान मान होते हैं।

विकल्प 1

हम निम्नलिखित क्वेरी का उपयोग यह देखने के लिए कर सकते हैं कि कितनी पंक्तियाँ डुप्लिकेट हैं:

SELECT 
    PetId,
    PetName,
    PetType,
    COUNT(*) AS "Count"
FROM Pets
GROUP BY 
    PetId,
    PetName,
    PetType
ORDER BY PetId;

परिणाम:

PetId  PetName  PetType  Count
-----  -------  -------  -----
1      Wag      Dog      2    
2      Scratch  Cat      1    
3      Tweet    Bird     1    
4      Bark     Dog      3    

यहां, हमने पंक्तियों को सभी स्तंभों के आधार पर समूहीकृत किया, और प्रत्येक समूह की पंक्ति गणना लौटा दी। यह हमें बताता है कि कोई पंक्ति अद्वितीय है (1 की गिनती के साथ) या डुप्लीकेट (1 से अधिक की गिनती के साथ)।

हम इसे अवरोही क्रम में गिनती के आधार पर ऑर्डर कर सकते हैं, ताकि सबसे अधिक डुप्लिकेट वाली पंक्तियाँ पहले दिखाई दें:

SELECT 
    PetId,
    PetName,
    PetType,
    COUNT(*) AS "Count"
FROM Pets
GROUP BY 
    PetId,
    PetName,
    PetType
ORDER BY Count(*) DESC;

परिणाम:

PetId  PetName  PetType  Count
-----  -------  -------  -----
4      Bark     Dog      3    
1      Wag      Dog      2    
2      Scratch  Cat      1    
3      Tweet    Bird     1    

विकल्प 2

यदि हम केवल डुप्लिकेट पंक्तियों को सूचीबद्ध करना चाहते हैं, तो हम HAVING . का उपयोग कर सकते हैं क्लॉज केवल 1 से अधिक की गिनती वाली पंक्तियों को वापस करने के लिए:

SELECT 
    PetId,
    PetName,
    PetType,
    COUNT(*) AS "Count"
FROM Pets
GROUP BY 
    PetId,
    PetName,
    PetType
HAVING COUNT(*) > 1
ORDER BY PetId;

परिणाम:

PetId  PetName  PetType  Count
-----  -------  -------  -----
1      Wag      Dog      2    
4      Bark     Dog      3    

विकल्प 3

एक अन्य विकल्प ROW_NUMBER() . का उपयोग करना है विंडो फ़ंक्शन:

SELECT 
    *, 
    ROW_NUMBER() OVER ( 
        PARTITION BY PetId, PetName, PetType 
        ORDER BY PetId, PetName, PetType
        ) AS Row_Number
FROM Pets;

परिणाम:

PetId  PetName  PetType  Row_Number
-----  -------  -------  ----------
1      Wag      Dog      1         
1      Wag      Dog      2         
2      Scratch  Cat      1         
3      Tweet    Bird     1         
4      Bark     Dog      1         
4      Bark     Dog      2         
4      Bark     Dog      3         

PARTITION BY क्लॉज FROM . द्वारा निर्मित परिणाम सेट को विभाजित करता है विभाजन में खंड जिस पर फ़ंक्शन लागू होता है। जब हम परिणाम सेट के लिए विभाजन निर्दिष्ट करते हैं, तो प्रत्येक विभाजन नंबरिंग को फिर से शुरू करने का कारण बनता है (यानी प्रत्येक विभाजन में पहली पंक्ति के लिए नंबरिंग 1 से शुरू होगी)।

विकल्प 4

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

WITH cte AS 
    (
        SELECT 
            *, 
            ROW_NUMBER() OVER ( 
                PARTITION BY PetId, PetName, PetType 
                ORDER BY PetId, PetName, PetType
                ) AS Row_Number
        FROM Pets
    )
SELECT * FROM cte WHERE Row_Number <> 1;

परिणाम:

PetId  PetName  PetType  Row_Number
-----  -------  -------  ----------
1      Wag      Dog      2         
4      Bark     Dog      2         
4      Bark     Dog      3         

यह मिलान करने वाले डुप्लीकेट से केवल अतिरिक्त पंक्तियां देता है। तो यदि दो समान पंक्तियां हैं, तो यह उनमें से एक लौटाती है। यदि तीन समान पंक्तियाँ हैं, तो यह दो देता है, और इसी तरह।

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

सौभाग्य से, अगले दो विकल्पों को हटाने के लिए संशोधित किया जा सकता है।

विकल्प 5

हम SQLite के rowid . का लाभ उठा सकते हैं :

SELECT * FROM Pets
WHERE EXISTS (
  SELECT 1 FROM Pets p2 
  WHERE Pets.PetName = p2.PetName
  AND Pets.PetType = p2.PetType
  AND Pets.rowid > p2.rowid
);

परिणाम:

PetId  PetName  PetType
-----  -------  -------
1      Wag      Dog    
4      Bark     Dog    
4      Bark     Dog    

यह कैसे काम करता है? डिफ़ॉल्ट रूप से, SQLite में प्रत्येक पंक्ति में एक विशेष कॉलम होता है, जिसे आमतौर पर rowid . कहा जाता है , जो विशिष्ट रूप से तालिका के भीतर उस पंक्ति की पहचान करता है। यदि आवश्यक हो तो इसे हटाया जा सकता है, लेकिन जब तक इसे स्पष्ट रूप से हटाया नहीं जाता है, तब तक आप अपने प्रश्नों में इसका लाभ उठा सकेंगे।

विकल्प 6

और अंत में, यहाँ एक और विकल्प है जो SQLite के rowid . का उपयोग करता है :

SELECT * FROM Pets
WHERE rowid > (
  SELECT MIN(rowid) FROM Pets p2  
  WHERE Pets.PetName = p2.PetName
  AND Pets.PetType = p2.PetType
);

परिणाम:

PetId  PetName  PetType
-----  -------  -------
1      Wag      Dog    
4      Bark     Dog    
4      Bark     Dog    

  1. Database
  2.   
  3. Mysql
  4.   
  5. Oracle
  6.   
  7. Sqlserver
  8.   
  9. PostgreSQL
  10.   
  11. Access
  12.   
  13. SQLite
  14.   
  15. MariaDB
  1. एंड्रॉइड SQLite में छवियों का उपयोग कैसे करें जो कर्सरविंडो की सीमाओं से बड़े हैं?

  2. SQLite में 4 सारणीबद्ध आउटपुट मोड

  3. बेस एडेप्टर और लिस्टव्यू का उपयोग करके डेटाबेस से डेटा प्रदर्शित करें

  4. SQLiteException:तालिका पहले से मौजूद है

  5. SQLite ने PRINTF () का नाम बदलकर FORMAT () कर दिया है