MySQL - SELECT WHERE Feld IN (Unterabfrage) - Extrem langsam warum?

Ich habe ein paar Duplikate in einer Datenbank, die ich überprüfen möchte. Was ich also getan habe, um zu sehen, welche Duplikate sind, habe ich folgendermaßen gemacht:

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

Auf diese Weise werden alle Zeilen mit relevantem_Feld mehr als einmal angezeigt. Die Ausführung dieser Abfrage dauert Millisekunden.

Jetzt wollte ich jedes der Duplikate untersuchen, also dachte ich, ich könnte jede Zeile in einer Tabelle mit einem relevanten Feld in der obigen Abfrage AUSWÄHLEN, also gefiel mir Folgendes:

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

Dies stellt sich aus irgendeinem Grund als äußerst langsam heraus (es dauert Minuten). Was genau ist hier los, um es so langsam zu machen? relevant_field ist indiziert.

Schließlich habe ich versucht, aus der ersten Abfrage eine Ansicht "temp_view" zu erstellen (SELECT relevant_field FROM some_table GROUP BY relevant_field HAVING COUNT(*) > 1)und stattdessen meine zweite Abfrage wie folgt durchzuführen :

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

Und das funktioniert gut. MySQL erledigt dies in einigen Millisekunden.

Gibt es hier SQL-Experten, die erklären können, was los ist?

Schreiben Sie die Abfrage in diese um

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

Ich denke, st2.relevant_fieldmuss in der Auswahl sein, weil sonst die havingKlausel einen Fehler gibt, aber ich bin nicht 100% sicher

Niemals INmit einer Unterabfrage verwenden. das ist notorisch langsam.
Nur INmit einer festen Werteliste verwenden.

Mehr Tipps

1. Wenn Sie Abfragen schneller durchführen möchten, SELECT *wählen Sie nicht nur die Felder aus, die Sie wirklich benötigen.
2. Stellen Sie sicher, dass Sie einen Index relevant_fieldaktiviert haben, um den Equi-Join zu beschleunigen.
3. Stellen Sie sicher, dass Sie group byden Primärschlüssel verwenden.
4. Wenn Sie sich in InnoDB befinden und nur indizierte Felder auswählen (und die Dinge nicht zu komplex sind), löst MySQL Ihre Abfrage nur anhand der Indizes auf, was die Dinge erheblich beschleunigt.

Allgemeine Lösung für 90% Ihrer IN (select Anfragen

Verwenden Sie diesen Code

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) 

Die Unterabfrage wird für jede Zeile ausgeführt, da es sich um eine korrelierte Abfrage handelt. Sie können eine korrelierte Abfrage in eine nicht korrelierte Abfrage verwandeln, indem Sie alles aus der Unterabfrage auswählen, wie folgt:

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

Die letzte Abfrage würde folgendermaßen aussehen:

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
)

Unterabfragen vs Joins

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;

Ich habe Ihre Abfrage in einer meiner Datenbanken ausprobiert und auch versucht, sie als Join zu einer Unterabfrage umzuschreiben.

Das hat viel schneller geklappt, probieren Sie es aus!

Versuche dies

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;

Ich habe Ihre langsame SQL-Abfrage mit www.prettysql.net neu formatiert

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

Wenn Sie eine Tabelle sowohl in der Abfrage als auch in der Unterabfrage verwenden, sollten Sie beide immer wie folgt aliasisieren:

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
 );

Hilft das?

Erstens können Sie doppelte Zeilen finden und die Anzahl der Zeilen wird wie oft verwendet und nach dieser Nummer sortiert.

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
) 

Erstellen Sie anschließend eine Tabelle und fügen Sie das Ergebnis ein.

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
) 

Löschen Sie schließlich die Zeilen für die Veröffentlichung. Nein ist Start 0. Mit Ausnahme der ersten Nummer jeder Gruppe löschen Sie alle Zeilen für die Veröffentlichung.

delete from  CopyTable where No!= 0;

Manchmal, wenn die Daten größer werden, kann mysql WHERE IN aufgrund der Abfrageoptimierung ziemlich langsam sein. Versuchen Sie, mit STRAIGHT_JOIN mysql anzuweisen, die Abfrage unverändert auszuführen, z

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

Aber Vorsicht: In den meisten Fällen funktioniert der MySQL-Optimierer ziemlich gut. Ich würde daher empfehlen, ihn nur zu verwenden, wenn Sie solche Probleme haben

Dies ähnelt meinem Fall, in dem ich eine Tabelle mit dem Namen habe tabel_buku_besar. Was ich brauche sind

1. Auf der Suche nach Aufzeichnungen, die account_code='101.100'in tabel_buku_besardenen haben companyarea='20000'und auch IDRals habencurrency

2. Ich muss alle tabel_buku_besarDatensätze abrufen, deren Kontocode mit Schritt 1 identisch ist, aber transaction_numberin Schritt 1 das Ergebnis hat

Während der Verwendung select ... from...where....transaction_number in (select transaction_number from ....)läuft meine Abfrage extrem langsam und führt manchmal zu einem Zeitlimit für Anfragen oder dazu, dass meine Anwendung nicht reagiert ...

Ich versuche diese Kombination und das Ergebnis ... nicht schlecht ...

`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`

Ich finde, dass dies am effizientesten ist, um festzustellen, ob ein Wert vorhanden ist. Die Logik kann leicht invertiert werden, um festzustellen, ob ein Wert nicht vorhanden ist (dh 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

* Ersetzen Sie das relevante_Feld durch den Namen des Werts, den Sie überprüfen möchten und der in Ihrer Tabelle vorhanden ist

* Ersetzen Sie den Primärschlüssel durch den Namen der Primärschlüsselspalte in der Vergleichstabelle.