SQL alle bis auf einen von aufeinanderfolgenden Einträge mit gleichem Wert löschen

SQL alle bis auf einen von aufeinanderfolgenden Einträge mit gleichem Wert löschen (22 Beiträge, 469 Mal gelesen)

Du bist nicht angemeldet. [ Login/Registrieren ]

EDIT:
Problem gelöst: Einfach keine schlechten Daten in die Datenbank lassen.
Let's build a wall and let them pay for it!

Ich habe den folgenden Table, sortiert nach Zeit:

Hieraus soll nun eine der Zeilen mit fk 17 und zwei Zeilen mit fk 15 gelöscht werden, es sollen also unten und oben ein Eintrag mit 15 übrig bleiben.
Welche sind eigentlich egal, aber wenn ich es mir aussuchen kann die mit der höheren Zeit.

Der Table soll danach so aussehen:

Dialekt ist MySQL.

Hat einer von euch eine Idee?
Macht man so etwas mit einem Cursor? Habe ich noch nie verwendet, Zeit wirds.

Falls das nicht geht mach ich es im Code.

17.01.2017, 13:11 Uhr - Editiert von Diabolo2000, alte Version: hier

DELETE FROM table WHERE fk = 15 ORDER BY zeit LIMIT 2;
DELETE FROM table WHERE fk = 17 ORDER BY zeit LIMIT 1;

Den Titel habe ich zu spät gelesen

.
Function mit Cursor oder im Code...

05.01.2017, 19:16 Uhr - Editiert von mko, alte Version: hier
Dieser Beitrag bezieht sich auf eine ältere Version des beantworteten Postings!

Datenbankadministratoren tun mir leid, das ist ja scheußlicher als Python.

DELIMITER //

CREATE FUNCTION deleteOlderDuplicateSongPlays()
RETURNS VARCHAR(255)

BEGIN
	
	DECLARE idToBeDeleted BIGINT DEFAULT -1;
	DECLARE lastSongId BIGINT DEFAULT -1;
	DECLARE songId BIGINT DEFAULT -1;
	DECLARE c1Finished INTEGER DEFAULT 0;
	DECLARE result VARCHAR(255) DEFAULT '';
		
	DECLARE c1 CURSOR FOR
		select
			sp.id,
			sp.song_id
		from worstStation.songplay sp
		order by sp.time desc
	;
	
	DECLARE CONTINUE HANDLER FOR NOT FOUND SET c1Finished = 1;

	OPEN c1; loop1: LOOP
		FETCH c1 INTO idToBeDeleted, songId;
			
		IF c1Finished = 1 THEN 
			LEAVE loop1;
		END IF;
		
		IF lastSongId = songId THEN
			SET result = CONCAT(result,',');
			SET result = CONCAT(result,idToBeDeleted);
			
			SET @idToBeDeletedForQuery:= idToBeDeleted;
			
			 delete
			 	from worstStation.songplay
		 	 	where id = @idToBeDeletedForQuery;
		END IF;
		
		SET lastSongId = songId;
	END LOOP loop1; CLOSE c1;
	
	RETURN result;
END; //

DELIMITER ;

Datenbankadministratoren tun mir leid, das ist ja scheußlicher als Python.

Die Datenbankadministratoren die ich kenne schreiben auch keine Functions

hast einen index in der tabelle?

sonst etwas risiko: delete from table wehre zeit not in (select max(zeit) from table group by fk)
da sollte zeit aber eindeutig sein!
mit index natürlich sicherer, könntest dir aber view mit autocount erstellen und dafür nutzen... das prinzip sollte klar sein

Dieser Beitrag bezieht sich auf eine ältere Version des beantworteten Postings!

Ich denke deine Idee würde bei meinem Beispiel 3 Einträge mit fk 15 löschen, oder?
Einträge mit gleichem fk liegen zeitlich nicht unbedingt direkt aneinander und dürfen übrig bleiben.

Das hier ist ok:

Wie kommen die Werte in die DB, lässt sich ev. ein "doppelter Eintrag" nicht schon hier verhindern?

Dieser Beitrag bezieht sich auf eine ältere Version des beantworteten Postings!

Polling einer undokumentierten API die Daten aus der kurzen Vergangenheit und Zukunft anzeigt.
Datums und Id Werte eines Tupels aus der Zukunft können sich bis zum Eintreten des tatsächlichen Zeitpunktes ändern. Soweit ich verstanden habe ändert sich die Id genau dann wenn sich das Datum ändert. Ein Tupel beinhaltet jedoch auch noch zwei weitere Werte die zusammen die sich nicht ändern, die Kombination dieser zwei Werte kann niemals aufeinander folgen, dadurch erkenne ich die Duplikate.

In etwa: Id, Zeit, Songname, Künstlername.
Id scheint einfach eine GUID zu sein, die sich bei Änderung der Zeit ändert.
Es ist nicht davon auszugehen, dass derselbe Song zweimal hintereinander kommt.

Jetzt wo ich das schreibe bin ich auf die Lösung gekommen: Einfach nur die fixierten Daten der Vergangenheit einlesen. 🙄

Danke, dass du mir die Idee verschafft hast. Da hab ich viel zu umständlich gedacht.

mysql> CREATE TABLE `test` (
    ->     `id` int(11) NOT NULL AUTO_INCREMENT,
    ->     `fk` int(11) NOT NULL,
    ->     `zeit` time NOT NULL,
    ->     PRIMARY KEY (`id`)
    -> ) ENGINE=InnoDB;
Query OK, 0 rows affected (0.03 sec)

mysql> INSERT INTO `test`
    ->     (`fk`, `zeit`)
    -> VALUES
    ->     (12, '12:07'),
    ->     (15, '12:06'),
    ->     (15, '12:05'),
    ->     (15, '12:04'),
    ->     (69, '12:03'),
    ->     (17, '12:02'),
    ->     (17, '12:01'),
    ->     (15, '12:00');
Query OK, 8 rows affected (0.00 sec)
Records: 8  Duplicates: 0  Warnings: 0

mysql> SELECT `fk`, `zeit` FROM `test`;
+----+----------+
| fk | zeit     |
+----+----------+
| 12 | 12:07:00 |
| 15 | 12:06:00 |
| 15 | 12:05:00 |
| 15 | 12:04:00 |
| 69 | 12:03:00 |
| 17 | 12:02:00 |
| 17 | 12:01:00 |
| 15 | 12:00:00 |
+----+----------+
8 rows in set (0.00 sec)

mysql> DELETE t1.* FROM `test` t1
    -> INNER JOIN `test` t2 ON (
    ->     t2.`fk` = t1.`fk` AND t2.`zeit` = t1.`zeit` + INTERVAL 1 MINUTE
    -> );
Query OK, 3 rows affected (0.00 sec)

mysql> SELECT `fk`, `zeit` FROM `test`;
+----+----------+
| fk | zeit     |
+----+----------+
| 12 | 12:07:00 |
| 15 | 12:06:00 |
| 69 | 12:03:00 |
| 17 | 12:02:00 |
| 15 | 12:00:00 |
+----+----------+
5 rows in set (0.00 sec)

Dieser Beitrag bezieht sich auf eine ältere Version des beantworteten Postings!

Hallo, danke für deinen Ansatz, aber es können beliebige Zeiträume zwischen den Zeiten liegen.
Ich hab das ganze inzwischen so gelöst, dass keine falschen Daten mehr in die Datenbank kommen (;

Constraint auf FK setzen, rebuild des Objekts und alle Constraint Verletzungen auf einen Fehlerbestand schreiben lassen.

pong

"Ein Gewitter reinigt die Luft", sagte ein Mann, nachdem ein Blitz seine Frau erschlug

Dieser Beitrag bezieht sich auf eine ältere Version des beantworteten Postings!

FK darf mehrmals zeitlich durch andere FK getrennt vorkommen!
Ich habe das Problem schon anders gelöst, ich lasse keine falschen Daten mehr in die Datenbank.

08.01.2017, 21:34 Uhr - Editiert von Diabolo2000, alte Version: hier

probier mal (in dem fall bleiben die mit der niedrigsten zeit über). wenn zwei fk mit der gleichen niedrigsten zeit drinnen sind bleiben beide.

delete from tabelle t1 where (0= (select count(*) from (select fk, min (zeit) as minzeit from tabelle group by fk) as t2 where t1.fk=t2.fk and t1.zeit=t2.minzeit))

16.01.2017, 14:10 Uhr - Editiert von *patrick star*, alte Version: hier
Dieser Beitrag bezieht sich auf eine ältere Version des beantworteten Postings!

Dieses Forum ist eine frei zugängliche Diskussionsplattform.
Der Betreiber übernimmt keine Verantwortung für den Inhalt der Beiträge und behält sich das Recht vor, Beiträge mit rechtswidrigem oder anstößigem Inhalt zu löschen.
Datenschutzerklärung