SQL: come trovare i duplicati in base a due campi?

Question

Ho righe in una tabella di database Oracle che dovrebbe essere univoca per una combinazione di due campi ma il vincolo univoco non è impostato sulla tabella, quindi ho bisogno di trovare tutte le righe che violano il vincolo utilizzando SQL. Sfortunatamente le mie scarse competenze SQL non sono all'altezza del compito.

La mia tabella ha tre colonne rilevanti: entity_id, station_id e obs_year. Per ogni riga, la combinazione di station_id e obs_year dovrebbe essere univoca, e voglio scoprire se ci sono righe che violano questa situazione svuotandole con una query SQL.

Ho provato il seguente SQL (suggerito da this previous question), ma non funziona per me (ho ORA-00918 colonna ambiguo definito):

SELECT 
entity_id, station_id, obs_year 
FROM 
mytable t1 
INNER JOIN (
SELECT entity_id, station_id, obs_year FROM mytable 
GROUP BY entity_id, station_id, obs_year HAVING COUNT(*) > 1) dupes 
ON 
t1.station_id = dupes.station_id AND 
t1.obs_year = dupes.obs_year 

Qualcuno può suggerire quello che sto facendo male e/o come risolvere questo?

Answer 1

SELECT * 
FROM (
     SELECT t.*, ROW_NUMBER() OVER (PARTITION BY station_id, obs_year ORDER BY entity_id) AS rn 
     FROM mytable t 
     ) 
WHERE rn > 1 

Answer 2

Re-scrittura della query

SELECT 
t1.entity_id, t1.station_id, t1.obs_year 
FROM 
mytable t1 
INNER JOIN (
SELECT entity_id, station_id, obs_year FROM mytable 
GROUP BY entity_id, station_id, obs_year HAVING COUNT(*) > 1) dupes 
ON 
t1.station_id = dupes.station_id AND 
t1.obs_year = dupes.obs_year 

penso che l'errore della colonna ambiguo (ORA-00918) è stato perché eri select colonne ing cui nomi apparsi sia la tavola e la subquery, ma non ha fatto specificare se lo si desidera da dupes o da mytable (con alias come t1).

Answer 3

Non è possibile creare una nuova tabella che include il vincolo univoco e quindi copiare i dati riga per riga, ignorando i guasti?

Answer 4

modificare i 3 campi di selezione iniziale per essere

SELECT 
t1.entity_id, t1.station_id, t1.obs_year 

Answer 5

SELECT entity_id, station_id, obs_year 
FROM mytable t1 
WHERE EXISTS (SELECT 1 from mytable t2 Where 
     t1.station_id = t2.station_id 
     AND t1.obs_year = t2.obs_year 
     AND t1.RowId <> t2.RowId) 

Answer 6

È necessario specificare la tabella per le colonne nella select principale. Inoltre, assumendo entity_id è la chiave univoca per mytable ed è irrilevante trovare i duplicati, non dovresti raggruppare su di essa nella subquery dei dupes.

Prova:

SELECT t1.entity_id, t1.station_id, t1.obs_year 
FROM mytable t1 
INNER JOIN (
SELECT station_id, obs_year FROM mytable 
GROUP BY station_id, obs_year HAVING COUNT(*) > 1) dupes 
ON 
t1.station_id = dupes.station_id AND 
t1.obs_year = dupes.obs_year 

Answer 7

SELECT * 
FROM (
     SELECT t.*, ROW_NUMBER() OVER (PARTITION BY station_id, obs_year ORDER BY entity_id) AS rn 
     FROM mytable t 
     ) 
WHERE rn > 1 

dal Quassnoi è il più efficiente per tabelle di grandi dimensioni. ho avuto questa analisi dei costi:

SELECT a.dist_code, a.book_date, a.book_no 
FROM trn_refil_book a 
WHERE EXISTS (SELECT 1 from trn_refil_book b Where 
     a.dist_code = b.dist_code and a.book_date = b.book_date and a.book_no = b.book_no 
     AND a.RowId <> b.RowId) 
     ; 

ha dato un costo di 1322341

SELECT a.dist_code, a.book_date, a.book_no 
FROM trn_refil_book a 
INNER JOIN (
SELECT b.dist_code, b.book_date, b.book_no FROM trn_refil_book b 
GROUP BY b.dist_code, b.book_date, b.book_no HAVING COUNT(*) > 1) c 
ON 
a.dist_code = c.dist_code and a.book_date = c.book_date and a.book_no = c.book_no 
; 

ha un costo di 1271699

mentre

SELECT dist_code, book_date, book_no 
FROM (
     SELECT t.dist_code, t.book_date, t.book_no, ROW_NUMBER() OVER (PARTITION BY t.book_date, t.book_no 
      ORDER BY t.dist_code) AS rn 
     FROM trn_refil_book t 
     ) p 
WHERE p.rn > 1 
; 

ha dato un costo di 1.021.984

La tabella non è stato indicizzato ....

Answer 8

SELECT entity_id, station_id, obs_year 
    FROM mytable 
GROUP BY entity_id, station_id, obs_year 
HAVING COUNT(*) > 1 

specificare i campi per trovare i duplicati sia sul SELECT e GROUP BY.

Funziona utilizzando GROUP BY per trovare le righe che corrispondono ad altre righe in base alle colonne specificate. Il HAVING COUNT(*) > 1 dice che siamo interessati solo a vedere le righe che si verificano più di 1 volta (e sono quindi duplicate)