sql - repetidos - Eliminar duplicados de una tabla

sql omitir repetidos

Question

El tipo de base de datos es PostGres 8.3.

Si escribo:

SELECT field1, field2, field3, count(*)
FROM table1
GROUP BY field1, field2, field3 having count(*) > 1;

Tengo algunas filas que tienen un recuento de más de 1. ¿Cómo puedo sacar el duplicado (todavía quiero 1 fila para cada uno de ellos en lugar de +1 fila ... No quiero borrarlos todos).

Ejemplo:

1-2-3
1-2-3
1-2-3
2-3-4
4-5-6

Debe convertirse :

1-2-3
2-3-4
4-5-6

La única respuesta que encontré está allí, pero me pregunto si podría hacerlo sin la columna hash.

Advertencia : No tengo un PK con un número único, así que no puedo usar la técnica de min (...). El PK es los 3 campos.

Answer 1

Al usar TSQL, no hay idea de si Postgres admite tablas temporales, pero puede seleccionar una tabla temporal, y luego recorrer y eliminar e insertar sus resultados nuevamente en el original

-- **Disclaimer** using TSQL
-- You could select your records into a temp table with a pk
Create Table #dupes
([id] int not null identity(1,1), f1 int, f2 int, f3 int)
Insert Into #dupes (f1,f2,f3) values (1,2,3)
Insert Into #dupes (f1,f2,f3) values (1,2,3)
Insert Into #dupes (f1,f2,f3) values (1,2,3)
Insert Into #dupes (f1,f2,f3) values (2,3,4)
Insert Into #dupes (f1,f2,f3) values (4,5,6)
Insert Into #dupes (f1,f2,f3) values (4,5,6)
Insert Into #dupes (f1,f2,f3) values (4,5,6)
Insert Into #dupes (f1,f2,f3) values (7,8,9)
Select f1,f2,f3 From #dupes
Declare @rowCount int
Declare @counter int
Set @counter = 1
Set @rowCount = (Select Count([id]) from #dupes)
while (@counter < @rowCount + 1)
Begin
Delete From #dupes
Where [Id] <>
(Select [id] From #dupes where [id]=@counter)
and
(
[f1] = (Select [f1] from #dupes where [id]=@counter)
and
[f2] = (Select [f2] from #dupes where [id]=@counter)
and
[f3] = (Select [f3] from #dupes where [id]=@counter)
)
Set @counter = @counter + 1
End
Select f1,f2,f3 From #dupes -- You could take these results and pump them back into --your original table
Drop Table #dupes

Probado esto en MS SQL Server 2000. No estoy familiarizado con las opciones de Postgres, pero tal vez esto te lleve en la dirección correcta.

Answer 2

Bueno, debería malinterpretar algo, pero diré:

SELECCIONE DISTINCT field1, field2, field3 FROM table1

¿Demasiado fácil ser bueno? ^^

Answer 3

Esta es una de las muchas razones por las que todas las tablas deben tener una clave principal (no necesariamente un número de ID o IDENTIDAD, sino una combinación de una o más columnas que identifica de manera única una fila y cuya singularidad se aplica en la base de datos).

Tu mejor apuesta es algo como esto:

SELECT field1, field2, field3, count(*)
INTO temp_table1
FROM table1
GROUP BY field1, field2, field3 having count(*) > 1
DELETE T1
FROM table1 T1
INNER JOIN (SELECT field1, field2, field3
FROM table1
GROUP BY field1, field2, field3 having count(*) > 1) SQ ON
SQ.field1 = T1.field1 AND
SQ.field2 = T1.field2 AND
SQ.field3 = T1.field3
INSERT INTO table1 (field1, field2, field3)
SELECT field1, field2, field3
FROM temp_table1
DROP TABLE temp_table1

Answer 4

Este es el método más simple que he encontrado:

Sintaxis SQL Postgre:

CREATE TABLE tmp AS SELECT distinct * FROM table1
truncate table table1
insert into table1 select * from tmp
drop table tmp

Sintaxis T-SQL:

select distinct * into #tmp from table1
truncate table table1
insert into table1 select * from #tmp
drop table #tmp

Answer 5

Esto usará el ID del objeto OID (si la tabla se creó con él):

DELETE FROM table1
WHERE OID NOT IN (SELECT MIN (OID)
FROM table1
GROUP BY field1, field2, field3)

Answer 6

Una buena respuesta para este problema, pero para SQL Server. Utiliza el ROWCOUNT que SQL Server ofrece, con buenos resultados. Nunca utilicé PostgreSQL y, por lo tanto, no conozco el equivalente de ROWCOUNT en PostgreSQL.

Answer 7

Una posible respuesta es:

CREATE <temporary table> (<correct structure for table being cleaned>);
BEGIN WORK; -- if needed
INSERT INTO <temporary table> SELECT DISTINCT * FROM <source table>;
DELETE FROM <source table>
INSERT INTO <source table> SELECT * FROM <temporary table>;
COMMIT WORK; -- needed
DROP <temporary table>;

No estoy seguro de si el ''trabajo'' es necesario en las declaraciones de transacción, ni si el BEGIN explícito es necesario en PostgreSQL. Pero el concepto se aplica a cualquier DBMS.

Lo único que debe tenerse en cuenta son las restricciones referenciales y, en particular, las operaciones de eliminación activadas. Si existen, esto puede resultar menos satisfactorio.