Query SQL: eliminare tutti i record dalla tabella tranne l'ultimo N?

È possibile costruire una singola query mysql (senza variabili) per rimuovere tutti i record dalla tabella, eccetto gli ultimi N (ordinati per id desc)?

Qualcosa di simile, solo che non funziona :)

delete from table order by id ASC limit ((select count(*) from table ) - N)

Grazie.

Non è possibile eliminare i record in questo modo, il problema principale è che non è possibile utilizzare una sottoquery per specificare il valore di una clausola LIMIT.

Funziona (testato in MySQL 5.0.67):

DELETE FROM `table`
WHERE id NOT IN (
  SELECT id
  FROM (
    SELECT id
    FROM `table`
    ORDER BY id DESC
    LIMIT 42 -- keep this many records
  ) foo
);

La sottoquery intermedia è obbligatoria. Senza di esso incorreremmo in due errori:

1. Errore SQL (1093): non è possibile specificare la tabella di destinazione "tabella" per l'aggiornamento nella clausola FROM - MySQL non consente di fare riferimento alla tabella che si sta eliminando da una sottoquery diretta.
2. Errore SQL (1235): questa versione di MySQL non supporta ancora "LIMIT & IN / ALL / ANY / SOME sottoquery" : non è possibile utilizzare la clausola LIMIT all'interno di una sottoquery diretta di un operatore NOT IN.

Fortunatamente, l'utilizzo di una sottoquery intermedia ci consente di aggirare entrambe queste limitazioni.

Nicole ha sottolineato che questa query può essere ottimizzata in modo significativo per alcuni casi d'uso (come questo). Consiglio di leggere anche quella risposta per vedere se si adatta alla tua.

So che sto resuscitando una vecchia domanda, ma recentemente mi sono imbattuto in questo problema, ma avevo bisogno di qualcosa che si adattasse bene a grandi numeri . Non c'erano dati sulle prestazioni esistenti e, poiché questa domanda ha ricevuto un po 'di attenzione, ho pensato di pubblicare ciò che ho trovato.

Le soluzioni che hanno effettivamente funzionato erano la doppia NOT INsottoquery / metodo di Alex Barrett (simile a quello di Bill Karwin ) e ilLEFT JOIN metodo di Quassnoi .

Sfortunatamente, entrambi i metodi precedenti creano tabelle temporanee intermedie molto grandi e le prestazioni diminuiscono rapidamente man mano che il numero di record non eliminati aumenta.

Quello che ho scelto utilizza la doppia sottoquery di Alex Barrett (grazie!) Ma usa <=invece di NOT IN:

DELETE FROM `test_sandbox`
  WHERE id <= (
    SELECT id
    FROM (
      SELECT id
      FROM `test_sandbox`
      ORDER BY id DESC
      LIMIT 1 OFFSET 42 -- keep this many records
    ) foo
  )

Viene utilizzato OFFSETper ottenere l'ID dell'N- esimo record ed elimina quel record e tutti i record precedenti.

Poiché l'ordinazione è già un presupposto di questo problema ( ORDER BY id DESC), <=è perfetto.

È molto più veloce, poiché la tabella temporanea generata dalla sottoquery contiene solo un record invece di N record.

Scenario di prova

Ho testato i tre metodi di lavoro e il nuovo metodo sopra in due casi di test.

Entrambi i casi di test utilizzano 10000 righe esistenti, mentre il primo test ne mantiene 9000 (elimina le 1000 meno recenti) e il secondo ne mantiene 50 (elimina le 9950 meno recenti).

+-----------+------------------------+----------------------+
|           | 10000 TOTAL, KEEP 9000 | 10000 TOTAL, KEEP 50 |
+-----------+------------------------+----------------------+
| NOT IN    |         3.2542 seconds |       0.1629 seconds |
| NOT IN v2 |         4.5863 seconds |       0.1650 seconds |
| <=,OFFSET |         0.0204 seconds |       0.1076 seconds |
+-----------+------------------------+----------------------+

La cosa interessante è che il <=metodo vede prestazioni migliori su tutta la linea, ma in realtà migliora più mantieni, anziché peggio.

Sfortunatamente per tutte le risposte fornite da altre persone, non puoi DELETEe SELECTda una data tabella nella stessa query.

DELETE FROM mytable WHERE id NOT IN (SELECT MAX(id) FROM mytable);

ERROR 1093 (HY000): You can't specify target table 'mytable' for update 
in FROM clause

Né MySQL può supportare LIMITin una sottoquery. Queste sono limitazioni di MySQL.

DELETE FROM mytable WHERE id NOT IN 
  (SELECT id FROM mytable ORDER BY id DESC LIMIT 1);

ERROR 1235 (42000): This version of MySQL doesn't yet support 
'LIMIT & IN/ALL/ANY/SOME subquery'

La migliore risposta che posso trovare è farlo in due fasi:

SELECT id FROM mytable ORDER BY id DESC LIMIT n; 

Raccogli gli ID e trasformali in una stringa separata da virgole:

DELETE FROM mytable WHERE id NOT IN ( ...comma-separated string... );

(Normalmente l'interpolazione di un elenco separato da virgole in un'istruzione SQL introduce alcuni rischi di iniezione SQL, ma in questo caso i valori non provengono da una fonte non attendibile, sono noti come valori interi dal database stesso.)

nota: sebbene questo non porti a termine il lavoro in una singola query, a volte una soluzione più semplice e completa è la più efficace.

DELETE  i1.*
FROM    items i1
LEFT JOIN
        (
        SELECT  id
        FROM    items ii
        ORDER BY
                id DESC
        LIMIT 20
        ) i2
ON      i1.id = i2.id
WHERE   i2.id IS NULL

Se il tuo ID è incrementale, usa qualcosa come

delete from table where id < (select max(id) from table)-N

Per cancellare tutti i record tranne l'ultimo N puoi usare la query riportata di seguito.

È una singola query ma con molte affermazioni, quindi in realtà non è una singola query nel modo in cui era intesa nella domanda originale.

Inoltre è necessaria una variabile e un'istruzione preparata incorporata (nella query) a causa di un bug in MySQL.

Spero che possa essere utile comunque ...

nnn sono le righe da mantenere e theTable è la tabella si sta lavorando.

Presumo che tu abbia un record con incremento automatico denominato id

SELECT @ROWS_TO_DELETE := COUNT(*) - nnn FROM `theTable`;
SELECT @ROWS_TO_DELETE := IF(@ROWS_TO_DELETE<0,0,@ROWS_TO_DELETE);
PREPARE STMT FROM "DELETE FROM `theTable` ORDER BY `id` ASC LIMIT ?";
EXECUTE STMT USING @ROWS_TO_DELETE;

La cosa buona di questo approccio sono le prestazioni : ho testato la query su un DB locale con circa 13.000 record, mantenendo gli ultimi 1.000. Funziona in 0,08 secondi.

Il copione dalla risposta accettata ...

DELETE FROM `table`
WHERE id NOT IN (
  SELECT id
  FROM (
    SELECT id
    FROM `table`
    ORDER BY id DESC
    LIMIT 42 -- keep this many records
  ) foo
);

Richiede 0,55 secondi. Circa 7 volte di più.

Ambiente di test: mySQL 5.5.25 su un MacBookPro i7 di fine 2011 con SSD

DELETE FROM table WHERE ID NOT IN
(SELECT MAX(ID) ID FROM table)

prova sotto la query:

DELETE FROM tablename WHERE id < (SELECT * FROM (SELECT (MAX(id)-10) FROM tablename ) AS a)

la sottoquery interna restituirà il valore dei primi 10 e la query esterna eliminerà tutti i record tranne i primi 10.

Che dire :

SELECT * FROM table del 
         LEFT JOIN table keep
         ON del.id < keep.id
         GROUP BY del.* HAVING count(*) > N;

Restituisce righe con più di N righe prima. Potrebbe essere utile?

L'utilizzo di id per questa attività non è un'opzione in molti casi. Ad esempio: tabella con stati di Twitter. Ecco una variante con il campo timestamp specificato.

delete from table 
where access_time >= 
(
    select access_time from  
    (
        select access_time from table 
            order by access_time limit 150000,1
    ) foo    
)

Volevo solo metterlo nel mix per chiunque utilizzi Microsoft SQL Server invece di MySQL. La parola chiave "Limite" non è supportata da MSSQL, quindi dovrai utilizzare un'alternativa. Questo codice ha funzionato in SQL 2008 e si basa su questo post SO. https://stackoverflow.com/a/1104447/993856

-- Keep the last 10 most recent passwords for this user.
DECLARE @UserID int; SET @UserID = 1004
DECLARE @ThresholdID int -- Position of 10th password.
SELECT  @ThresholdID = UserPasswordHistoryID FROM
        (
            SELECT ROW_NUMBER()
            OVER (ORDER BY UserPasswordHistoryID DESC) AS RowNum, UserPasswordHistoryID
            FROM UserPasswordHistory
            WHERE UserID = @UserID
        ) sub
WHERE   (RowNum = 10) -- Keep this many records.

DELETE  UserPasswordHistory
WHERE   (UserID = @UserID)
        AND (UserPasswordHistoryID < @ThresholdID)

Certo, questo non è elegante. Se sei in grado di ottimizzarlo per Microsoft SQL, condividi la tua soluzione. Grazie!

Se è necessario eliminare i record anche in base a qualche altra colonna, ecco una soluzione:

DELETE
FROM articles
WHERE id IN
    (SELECT id
     FROM
       (SELECT id
        FROM articles
        WHERE user_id = :userId
        ORDER BY created_at DESC LIMIT 500, 10000000) abc)
  AND user_id = :userId

Questo dovrebbe funzionare anche:

DELETE FROM [table] 
INNER JOIN (
    SELECT [id] 
    FROM (
        SELECT [id] 
        FROM [table] 
        ORDER BY [id] DESC
        LIMIT N
    ) AS Temp
) AS Temp2 ON [table].[id] = [Temp2].[id]

DELETE FROM table WHERE id NOT IN (
    SELECT id FROM table ORDER BY id, desc LIMIT 0, 10
)

Perchè no

DELETE FROM table ORDER BY id DESC LIMIT 1, 123456789

Elimina tutto tranne la prima riga (l'ordine è DESC!), Utilizzando un numero molto grande come secondo argomento LIMIT. Vedere qui

Rispondendo dopo molto tempo ... Mi sono imbattuto nella stessa situazione e invece di usare le risposte menzionate, sono venuto con di seguito -

DELETE FROM table_name order by ID limit 10

Ciò eliminerà i primi 10 record e manterrà gli ultimi record.