MySQL - SELEZIONA il campo IN (sottoquery) - Molto lento perché?

Ho un paio di duplicati in un database che voglio ispezionare, quindi quello che ho fatto per vedere quali sono i duplicati, ho fatto questo:

SELECT relevant_field
FROM some_table
GROUP BY relevant_field
HAVING COUNT(*) > 1

In questo modo, otterrò tutte le righe con il campo rilevante che si verificano più di una volta. Questa query richiede millisecondi per essere eseguita.

Ora, volevo ispezionare ciascuno dei duplicati, quindi ho pensato di poter selezionare ogni riga in some_table con un campo rilevante nella query sopra, quindi ho fatto così:

SELECT *
FROM some_table 
WHERE relevant_field IN
(
    SELECT relevant_field
    FROM some_table
    GROUP BY relevant_field
    HAVING COUNT(*) > 1
)

Questo risulta essere estremamente lento per qualche motivo (richiede minuti). Cosa sta succedendo esattamente qui per renderlo così lento? rilevante_field è indicizzato.

Alla fine ho provato a creare una vista "temp_view" dalla prima query (SELECT relevant_field FROM some_table GROUP BY relevant_field HAVING COUNT(*) > 1)e quindi a fare la mia seconda query in questo modo:

SELECT *
FROM some_table
WHERE relevant_field IN
(
    SELECT relevant_field
    FROM temp_view
)

E funziona benissimo. MySQL lo fa in alcuni millisecondi.

Qualche esperto SQL qui che può spiegare cosa sta succedendo?

Riscrivi la query in questo

SELECT st1.*, st2.relevant_field FROM sometable st1
INNER JOIN sometable st2 ON (st1.relevant_field = st2.relevant_field)
GROUP BY st1.id  /* list a unique sometable field here*/
HAVING COUNT(*) > 1

Penso che st2.relevant_fielddebba essere nella selezione, perché altrimenti la havingclausola darà un errore, ma non sono sicuro al 100%

Non usare mai INcon una subquery; questo è notoriamente lento.
Utilizzare sempre e solo INcon un elenco fisso di valori.

Più suggerimenti

1. Se vuoi fare domande più velocemente, non SELECT *selezionare solo i campi di cui hai veramente bisogno.
2. Assicurati di avere un indice attivo relevant_fieldper velocizzare l'equi-join.
3. Assicurati di group bysulla chiave primaria.
4. Se sei su InnoDB e selezioni solo campi indicizzati (e le cose non sono troppo complesse) di MySQL risolverà la tua query usando solo gli indici, velocizzando le cose.

Soluzione generale per il 90% delle tue IN (select domande

Usa questo codice

SELECT * FROM sometable a WHERE EXISTS (
  SELECT 1 FROM sometable b
  WHERE a.relevant_field = b.relevant_field
  GROUP BY b.relevant_field
  HAVING count(*) > 1) 

La sottoquery viene eseguita per ogni riga perché è una query correlata. È possibile trasformare una query correlata in una query non correlata selezionando tutto dalla sottoquery, in questo modo:

SELECT * FROM
(
    SELECT relevant_field
    FROM some_table
    GROUP BY relevant_field
    HAVING COUNT(*) > 1
) AS subquery

La query finale sarebbe simile a questa:

SELECT *
FROM some_table
WHERE relevant_field IN
(
    SELECT * FROM
    (
        SELECT relevant_field
        FROM some_table
        GROUP BY relevant_field
        HAVING COUNT(*) > 1
    ) AS subquery
)

Sottoquery vs join

http://www.scribd.com/doc/2546837/New-Subquery-Optimizations-In-MySQL-6

SELECT st1.*
FROM some_table st1
inner join 
(
    SELECT relevant_field
    FROM some_table
    GROUP BY relevant_field
    HAVING COUNT(*) > 1
)st2 on st2.relevant_field = st1.relevant_field;

Ho provato la tua query su uno dei miei database e ho anche provato a riscriverla come join a una query secondaria.

Ha funzionato molto più velocemente, provalo!

Prova questo

SELECT t1.*
FROM 
 some_table t1,
  (SELECT relevant_field
  FROM some_table
  GROUP BY relevant_field
  HAVING COUNT (*) > 1) t2
WHERE
 t1.relevant_field = t2.relevant_field;

Ho riformattato la tua query sql lenta con www.prettysql.net

SELECT *
FROM some_table
WHERE
 relevant_field in
 (
  SELECT relevant_field
  FROM some_table
  GROUP BY relevant_field
  HAVING COUNT ( * ) > 1
 );

Quando si utilizza una tabella sia nella query che nella sottoquery, è necessario sempre alias entrambi, in questo modo:

SELECT *
FROM some_table as t1
WHERE
 t1.relevant_field in
 (
  SELECT t2.relevant_field
  FROM some_table as t2
  GROUP BY t2.relevant_field
  HAVING COUNT ( t2.relevant_field ) > 1
 );

Questo aiuta?

In primo luogo puoi trovare righe duplicate e trovare il conteggio delle righe utilizzato quante volte e ordinarlo per numero come questo;

SELECT q.id,q.name,q.password,q.NID,(select count(*) from UserInfo k where k.NID= q.NID) as Count,
(
		CASE q.NID
		WHEN @curCode THEN
			@curRow := @curRow + 1
		ELSE
			@curRow := 1
		AND @curCode := q.NID
		END
	) AS No
FROM UserInfo q,
(
		SELECT
			@curRow := 1,
			@curCode := ''
	) rt
WHERE q.NID IN
(
    SELECT NID
    FROM UserInfo
    GROUP BY NID
    HAVING COUNT(*) > 1
) 

successivamente crea una tabella e inserisci il risultato.

create table CopyTable 
SELECT q.id,q.name,q.password,q.NID,(select count(*) from UserInfo k where k.NID= q.NID) as Count,
(
		CASE q.NID
		WHEN @curCode THEN
			@curRow := @curRow + 1
		ELSE
			@curRow := 1
		AND @curCode := q.NID
		END
	) AS No
FROM UserInfo q,
(
		SELECT
			@curRow := 1,
			@curCode := ''
	) rt
WHERE q.NID IN
(
    SELECT NID
    FROM UserInfo
    GROUP BY NID
    HAVING COUNT(*) > 1
) 

Infine, elimina le righe pubbliche. Non viene avviato 0. Tranne il numero di pugno di ciascun gruppo, elimina tutte le righe pubbliche.

delete from  CopyTable where No!= 0;

a volte quando i dati diventano più grandi mysql DOVE IN potrebbe essere piuttosto lento a causa dell'ottimizzazione delle query. Prova a utilizzare STRAIGHT_JOIN per dire a mysql di eseguire la query così com'è, ad es

SELECT STRAIGHT_JOIN table.field FROM table WHERE table.id IN (...)

ma attenzione: nella maggior parte dei casi mysql optimizer funziona abbastanza bene, quindi consiglierei di usarlo solo quando hai questo tipo di problema

Questo è simile al mio caso, in cui ho una tabella denominata tabel_buku_besar. Quello di cui ho bisogno sono

1. Alla ricerca di record che hanno account_code='101.100'in tabel_buku_besarcui hanno companyarea='20000'e anche IDRcomecurrency

2. Devo ottenere tutti i record dai tabel_buku_besarquali account_code è uguale al passaggio 1 ma con il transaction_numberrisultato del passaggio 1

durante l'utilizzo select ... from...where....transaction_number in (select transaction_number from ....) , la mia query è estremamente lenta e talvolta causa il timeout della richiesta o impedisce alla mia applicazione di rispondere ...

Provo questa combinazione e il risultato ... non male ...

`select DATE_FORMAT(L.TANGGAL_INPUT,'%d-%m-%y') AS TANGGAL,
      L.TRANSACTION_NUMBER AS VOUCHER,
      L.ACCOUNT_CODE,
      C.DESCRIPTION,
      L.DEBET,
      L.KREDIT 
 from (select * from tabel_buku_besar A
                where A.COMPANYAREA='$COMPANYAREA'
                      AND A.CURRENCY='$Currency'
                      AND A.ACCOUNT_CODE!='$ACCOUNT'
                      AND (A.TANGGAL_INPUT BETWEEN STR_TO_DATE('$StartDate','%d/%m/%Y') AND STR_TO_DATE('$EndDate','%d/%m/%Y'))) L 
INNER JOIN (select * from tabel_buku_besar A
                     where A.COMPANYAREA='$COMPANYAREA'
                           AND A.CURRENCY='$Currency'
                           AND A.ACCOUNT_CODE='$ACCOUNT'
                           AND (A.TANGGAL_INPUT BETWEEN STR_TO_DATE('$StartDate','%d/%m/%Y') AND STR_TO_DATE('$EndDate','%d/%m/%Y'))) R ON R.TRANSACTION_NUMBER=L.TRANSACTION_NUMBER AND R.COMPANYAREA=L.COMPANYAREA 
LEFT OUTER JOIN master_account C ON C.ACCOUNT_CODE=L.ACCOUNT_CODE AND C.COMPANYAREA=L.COMPANYAREA 
ORDER BY L.TANGGAL_INPUT,L.TRANSACTION_NUMBER`

Trovo che questo sia il più efficiente per scoprire se esiste un valore, la logica può essere facilmente invertita per scoprire se un valore non esiste (cioè IS NULL);

SELECT * FROM primary_table st1
LEFT JOIN comparision_table st2 ON (st1.relevant_field = st2.relevant_field)
WHERE st2.primaryKey IS NOT NULL

* Sostituisci il campo rilevante con il nome del valore che desideri verificare nella tabella

* Sostituire primaryKey con il nome della colonna chiave primaria nella tabella di confronto.