Oracle में तालिका से डुप्लिकेट पंक्तियों को हटा रहा है

Question

मैं ओरेकल में कुछ परीक्षण कर रहा हूं और कुछ नमूना डेटा के साथ एक तालिका पॉपुलेट की गई है, लेकिन इस प्रक्रिया में मैंने गलती से डुप्लिकेट रिकॉर्ड लोड किए हैं, इसलिए अब मैं कुछ कॉलम का उपयोग करके एक प्राथमिक कुंजी नहीं बना सकता हूं।

मैं सभी डुप्लिकेट पंक्तियों को कैसे हटा सकता हूं और उनमें से केवल एक को छोड़ सकता हूं?

Answer 1

rowidछद्म चॉकलेट का उपयोग करें ।

DELETE FROM your_table
WHERE rowid not in
(SELECT MIN(rowid)
FROM your_table
GROUP BY column1, column2, column3);

जहां column1, column2और column3प्रत्येक रिकॉर्ड के लिए पहचान की कुंजी बनाते हैं। आप अपने सभी कॉलम सूचीबद्ध कर सकते हैं।

Comments

+1 मुझे 12,000+ रिकॉर्ड में दफन दो डुप्लिकेट फोन नंबर खोजने थे। DELETE को SELECT में बदला और इसने उन्हें सेकंड में पाया। मुझे एक टन समय बचा, धन्यवाद।

— टिमटिनी

यह दृष्टिकोण मेरे काम नहीं आया। मुझे पता नहीं क्यों। जब मैंने "DELETE" को "SELECT *" से बदल दिया, तो उसने उन पंक्तियों को वापस कर दिया जिन्हें मैं हटाना चाहता था, लेकिन जब मैंने "DELETE" के साथ निष्पादित किया तो यह अनिश्चित काल तक लटका रहा।

— aro_biz

मेरा भी या तो लटका हुआ है या केवल बहुत लंबे समय से निष्पादित कर रहा है। लगभग 22 घंटे तक चला और अब भी चल रहा है। तालिका में 21M रिकॉर्ड हैं।

— कैमरून कैस्टिलो

मेरा सुझाव है कि अगर आपके पास बहुत बड़ा डेटा सेट है और यदि संभव है तो WHERE स्टेटमेंट में और फ़िल्टरिंग को जोड़ने के लिए, इससे लोगों को लंबे समय तक चलने वाले प्रश्नों में मदद मिल सकती है।

— रिकार्डो सांचेज

यदि चयन काम करता है, लेकिन डिलीट नहीं होता है, तो इसके परिणामस्वरूप सब-वे के आकार के कारण हो सकता है। यह दिलचस्प हो सकता है कि पहले सबक्वेरी रिजल्ट के साथ एक टेबल बनाएं, मिन (राउडी) कॉलम पर एक इंडेक्स बनाएं और फिर डिलीट स्टेटमेंट चलाएं।

— Wouter

Answer 2

टॉम से पूछो

delete from t
 where rowid IN ( select rid
                    from (select rowid rid, 
                                 row_number() over (partition by 
                         companyid, agentid, class , status, terminationdate
                                   order by rowid) rn
                            from t)
                   where rn <> 1);

(लापता कोष्ठक तय)

Comments

बयान में गुमशुदा। मुझे लगता है यह अंत में होना चाहिए?

— कैमरन कैस्टिलो

Answer 3

से DevX.com :

DELETE FROM our_table
WHERE rowid not in
(SELECT MIN(rowid)
FROM our_table
GROUP BY column1, column2, column3...) ;

जहां column1, column2, आदि वह कुंजी है जिसका आप उपयोग करना चाहते हैं।

Answer 4

DELETE FROM tablename a
      WHERE a.ROWID > ANY (SELECT b.ROWID
                             FROM tablename b
                            WHERE a.fieldname = b.fieldname
                              AND a.fieldname2 = b.fieldname2)

Comments

शीर्ष-मतदान जवाब पर मेरी टिप्पणी को फिर से लिखें, यह यह अनुरोध था जिसने वास्तव में मेरी समस्या को हल किया।

— aro_biz

यह बिल के समाधान की तुलना में विशाल तालिकाओं पर बहुत-सा धीमा होगा।

— राउटर

Answer 5

समाधान 1)

delete from emp
where rowid not in
(select max(rowid) from emp group by empno);

समाधान 2)

delete from emp where rowid in
               (
                 select rid from
                  (
                    select rowid rid,
                      row_number() over(partition by empno order by empno) rn
                      from emp
                  )
                where rn > 1
               );

समाधान 3)

delete from emp e1
         where rowid not in
          (select max(rowid) from emp e2
           where e1.empno = e2.empno ); 

Answer 6

तालिका t2 को t1 से अलग सेलेक्ट * के रूप में बनाएँ;

Comments

एक उत्तर नहीं - distinct *प्रत्येक रिकॉर्ड लेगा जो 1 कॉलम में कम से कम 1 प्रतीक में भिन्न होता है। आपको केवल उन स्तंभों से अलग-अलग मानों का चयन करना है जिन्हें आप प्राथमिक कुंजी बनाना चाहते हैं - बिल का उत्तर इस दृष्टिकोण का महान उदाहरण है।

— नागर

मुझे यही चाहिए था (पूरी तरह समान पंक्तियों को हटा दें)। धन्यवाद !

— इमैनुएल

इस पद्धति का एक और नुकसान यह है कि आपको अपनी तालिका की एक प्रति बनानी होगी। विशाल तालिकाओं के लिए, इसका अर्थ है कि अतिरिक्त तालिकाओं को प्रदान करना, और प्रतिलिपि के बाद तालिकाओं को हटाना या सिकोड़ना। बिल की विधि में अधिक लाभ हैं, और कोई अतिरिक्त नुकसान नहीं है।

— Wouter

Answer 7

आपको लूप के लिए कर्सर का उपयोग करके एक छोटा सा pl / sql ब्लॉक करना चाहिए और उन पंक्तियों को हटा दें जिन्हें आप नहीं रखना चाहते हैं। उदाहरण के लिए:

declare
prev_var my_table.var1%TYPE;

begin

for t in (select var1 from my_table order by var 1) LOOP

-- if previous var equal current var, delete the row, else keep on going.
end loop;

end;

Comments

मेरा मानना ​​है कि डाउनवोट इसलिए है क्योंकि आप पीएल / एसक्यूएल का उपयोग कर रहे हैं जब आप इसे एसक्यूएल में कर सकते हैं, तो आप सोच रहे हैं।

— डब्ल्यूडब्ल्यू।

सिर्फ इसलिए कि आप इसे एसक्यूएल में कर सकते हैं, इसका एकमात्र मतलब यह नहीं है। मैंने इस समाधान को पोस्ट किया, जब मैंने SQL-only समाधान देखा था। मुझे लगा कि वोट गलत जवाब के लिए थे।

— निक

Answer 8

डुप्लिकेट का चयन करने के लिए केवल क्वेरी प्रारूप हो सकता है:

SELECT GroupFunction(column1), GroupFunction(column2),..., 
COUNT(column1), column1, column2...
FROM our_table
GROUP BY column1, column2, column3...
HAVING COUNT(column1) > 1

इसलिए अन्य सुझाव के अनुसार सही प्रश्न है:

DELETE FROM tablename a
      WHERE a.ROWID > ANY (SELECT b.ROWID
                             FROM tablename b
                            WHERE a.fieldname = b.fieldname
                              AND a.fieldname2 = b.fieldname2
                              AND ....so on.. to identify the duplicate rows....)

यह क्वेरी डेटाबेस में चुने गए मानदंडों के लिए सबसे पुराना रिकॉर्ड रखेगा WHERE CLAUSE।

Oracle प्रमाणित एसोसिएट (2008)

Answer 9

सबसे बड़ी तालिकाओं के लिए सबसे तेज़ तरीका

1. नीचे संरचना के साथ अपवाद तालिका बनाएं: अपवाद_रूप

   ROW_ID ROWID
   OWNER VARCHAR2(30)
   TABLE_NAME VARCHAR2(30)
   CONSTRAINT VARCHAR2(30)

2. एक अद्वितीय बाधा या प्राथमिक कुंजी बनाने की कोशिश करें जो डुप्लिकेट द्वारा उल्लंघन की जाएगी। आपको एक त्रुटि संदेश मिलेगा क्योंकि आपके पास डुप्लिकेट हैं। अपवाद तालिका में डुप्लिकेट पंक्तियों के लिए पंक्तिबद्ध होंगे।

   alter table add constraint
   unique --or primary key
   (dupfield1,dupfield2) exceptions into exceptions_table;

3. अपनी तालिका को अपवाद के साथ जोड़कर पंक्तिबद्ध करें और दुपट्टे को हटा दें

   delete original_dups where rowid in (select ROW_ID from exceptions_table);

4. यदि हटाने के लिए पंक्तियों की मात्रा बड़ी है, तो एक नई तालिका बनाएं (सभी अनुदानों और अनुक्रमितों के साथ) विरोधी के साथ जुड़ने के साथ-साथ पंक्तिबद्ध करें और मूल तालिका को मूल_dups तालिका में नाम बदलें और नए_table_with_no_dups को मूल तालिका में नाम बदलें।

   create table new_table_with_no_dups AS (
       select field1, field2 ........ 
       from original_dups t1
       where not exists ( select null from exceptions_table T2 where t1.rowid = t2.row_id )
   )

Answer 10

उपद्रवी का उपयोग करना-

delete from emp
 where rowid not in
 (select max(rowid) from emp group by empno);

सेल्फ ज्वाइन का उपयोग करना-

delete from emp e1
 where rowid not in
 (select max(rowid) from emp e2
 where e1.empno = e2.empno );

Comments

हाय टांडले, कृपया पठनीयता बढ़ाते हुए जवाब प्रस्तुत करते समय कोड स्वरूपण उपकरण का उपयोग करें।

— NSNoob डेस

Answer 11

समाधान 4)

 delete from emp where rowid in
            (
             select rid from
                (
                  select rowid rid,
                  dense_rank() over(partition by empno order by rowid
                ) rn
             from emp
            )
 where rn > 1
);

Comments

क्या आप थोड़ा समझा सकते हैं?

— डाइटर मीमकेन

विभाजन के साथ सघन रैंक से डुप्लिकेट पंक्तियों के लिए रैंक समान संख्या के साथ मिलती है उदाहरण के लिए तीन पंक्तियाँ जिसमें रैंक 1, 1, 1 है और हर पंक्ति में हर पंक्ति यूनिक होती है और हम उन पंक्ति को हटाने की कोशिश कर रहे हैं जो मेल नहीं खा रहे हैं।

— DoOrDie

हम रैंक और dense_rank फ़ंक्शन दोनों का उपयोग कर सकते हैं, लेकिन मुझे लगता है कि रैंक इस परिदृश्य में पूरी तरह से काम करता है।

— DoOrDie

Answer 12

1. समाधान

delete from emp
    where rowid not in
    (select max(rowid) from emp group by empno);

2. थपकी

delete from emp where rowid in
               (
                 select rid from
                  (
                    select rowid rid,
                      row_number() over(partition by empno order by empno) rn
                      from emp
                  )
                where rn > 1
               );

3.solution

delete from emp e1
         where rowid not in
          (select max(rowid) from emp e2
           where e1.empno = e2.empno ); 

4. समाधान

 delete from emp where rowid in
            (
             select rid from
                (
                  select rowid rid,
                  dense_rank() over(partition by empno order by rowid
                ) rn
             from emp
            )
 where rn > 1
);

Answer 13

5. समाधान

delete from emp where rowid in 
    (
      select  rid from
       (
         select rowid rid,rank() over (partition by emp_id order by rowid)rn from emp     
       )
     where rn > 1
    );

Answer 14

DELETE from table_name where rowid not in (select min(rowid) FROM table_name group by column_name);

और आप दूसरे तरीके से डुप्लिकेट रिकॉर्ड भी हटा सकते हैं

DELETE from table_name a where rowid > (select min(rowid) FROM table_name b where a.column=b.column);

Answer 15

create table abcd(id number(10),name varchar2(20))

insert into abcd values(1,'abc')

insert into abcd values(2,'pqr')


insert into abcd values(3,'xyz')

insert into abcd values(1,'abc')

insert into abcd values(2,'pqr')

insert into abcd values(3,'xyz')


select * from abcd
id  Name
1   abc
2   pqr
3   xyz
1   abc
2   pqr
3   xyz

Delete Duplicate record but keep Distinct Record in table 

DELETE 
FROM abcd a
WHERE ROWID > (SELECT MIN(ROWID) FROM abcd b
WHERE b.id=a.id
);

run the above query 3 rows delete 

select * from abcd

id  Name 
1   abc
2   pqr
3   xyz

Answer 16

DELETE FROM tableName  WHERE ROWID NOT IN (SELECT   MIN (ROWID) FROM table GROUP BY columnname);

Comments

बिल द छिपकली के अधिक विस्तृत जवाब के रूप में एक ही जवाब।

— Wouter

Answer 17

delete from dept
where rowid in (
     select rowid
     from dept
     minus
     select max(rowid)
     from dept
     group by DEPTNO, DNAME, LOC
);

Comments

क्या आप अपने तरीके के बारे में अधिक जानकारी जोड़ सकते हैं? धन्यवाद।

— रिपोर्टर

Answer 18

सर्वोत्तम प्रदर्शन के लिए, यहाँ मैंने जो लिखा है:
(निष्पादन योजना देखें)

DELETE FROM your_table
WHERE rowid IN 
  (select t1.rowid from your_table  t1
      LEFT OUTER JOIN (
      SELECT MIN(rowid) as rowid, column1,column2, column3
      FROM your_table 
      GROUP BY column1, column2, column3
  )  co1 ON (t1.rowid = co1.rowid)
  WHERE co1.rowid IS NULL
);

Answer 19

स्क्रिप्ट नीचे देखें -

1।

Create table test(id int,sal int); 

2।

    insert into test values(1,100);    
    insert into test values(1,100);    
    insert into test values(2,200);    
    insert into test values(2,200);    
    insert into test values(3,300);    
    insert into test values(3,300);    
    commit;

3।

 select * from test;    

आप यहाँ 6-रिकॉर्ड देखेंगे।
4. क्वेरी से नीचे -

delete from 
   test
where rowid in
 (select rowid from 
   (select 
     rowid,
     row_number()
    over 
     (partition by id order by sal) dup
    from test)
  where dup > 1)

5. select * from test;

आप देखेंगे कि डुप्लिकेट रिकॉर्ड हटा दिए गए हैं।
आशा है कि यह आपकी क्वेरी को हल करता है। धन्यवाद :)

Answer 20

मुझे ऐसा कोई उत्तर नहीं मिला जो सामान्य तालिका अभिव्यक्तियों और विंडो फ़ंक्शंस का उपयोग करता हो। यह वही है जिसके साथ मुझे काम करना सबसे आसान लगता है।

DELETE FROM
 YourTable
WHERE
 ROWID IN
    (WITH Duplicates
          AS (SELECT
               ROWID RID, 
               ROW_NUMBER() 
               OVER(
               PARTITION BY First_Name, Last_Name, Birth_Date)
                  AS RN
               SUM(1)
               OVER(
               PARTITION BY First_Name, Last_Name, Birth_Date
               ORDER BY ROWID ROWS BETWEEN UNBOUNDED PRECEDING 
                                       AND UNBOUNDED FOLLOWING)
                   AS CNT
              FROM
               YourTable
              WHERE
               Load_Date IS NULL)
     SELECT
      RID
     FROM
      duplicates
     WHERE
      RN > 1);

ध्यान देने योग्य बातें:

1) हम केवल विभाजन खंड में क्षेत्रों पर दोहराव के लिए जाँच कर रहे हैं।

2) यदि आपके पास दूसरों पर एक डुप्लिकेट लेने का कोई कारण है, तो आप उस क्रम से क्लॉज द्वारा एक ऑर्डर का उपयोग कर सकते हैं, जिसमें पंक्ति row_number () = 1 होगी

3) आप फाइनल में बदलकर संरक्षित नंबर डुप्लिकेट को बदल सकते हैं जहां N> = 1 के साथ "व्हेयर आरएन> एन" का क्लॉज है (मैं सोच रहा था कि एन = 0 डुप्लिकेट वाली सभी पंक्तियों को हटा देगा, लेकिन यह सिर्फ सभी पंक्तियों को हटा देगा) ।

4) सुमी विभाजन क्षेत्र को CTE क्वेरी जोड़ा गया जो समूह में संख्या पंक्तियों के साथ प्रत्येक पंक्ति को टैग करेगा। इसलिए डुप्लिकेट वाली पंक्तियों का चयन करने के लिए, जिसमें पहला आइटम "WHERE cnt> 1" शामिल है।

Answer 21

create or replace procedure delete_duplicate_enq as
    cursor c1 is
    select *
    from enquiry;
begin
    for z in c1 loop
        delete enquiry
        where enquiry.enquiryno = z.enquiryno
        and rowid > any
        (select rowid
        from enquiry
        where enquiry.enquiryno = z.enquiryno);
    end loop;
 end delete_duplicate_enq;

Comments

इस पद्धति का एक बड़ा नुकसान आंतरिक जुड़ाव है। बड़ी तालिकाओं के लिए यह बिल की विधि की तुलना में काफी धीमा होगा। इसके अलावा, यह करने के लिए PL / SQL का उपयोग ओवरकिल है, आप बस sql का उपयोग करके भी इसका उपयोग कर सकते हैं।

— Wouter

Answer 22

उपाय :

delete from emp where rowid in
(
    select rid from
    (
        select rowid rid,
        row_number() over(partition by empno order by empno) rn
        from emp
    )
    where rn > 1
);