it-swarm.com.de

SQL wählt nur Zeilen mit maximalem Wert für eine Spalte aus

Ich habe diese Tabelle für Dokumente (hier vereinfachte Version):

+------+-------+--------------------------------------+
| id   | rev   | content                              |
+------+-------+--------------------------------------+
| 1    | 1     | ...                                  |
| 2    | 1     | ...                                  |
| 1    | 2     | ...                                  |
| 1    | 3     | ...                                  |
+------+-------+--------------------------------------+

Wie wähle ich eine Zeile pro ID und nur die größte Umdrehung aus?
Mit den obigen Daten sollte das Ergebnis zwei Zeilen enthalten: [1, 3, ...] und [2, 1, ..]. Ich verwende MySQL.

Derzeit verwende ich Prüfungen in der while-Schleife, um alte Umdrehungen aus dem Resultset zu erkennen und zu überschreiben. Aber ist dies die einzige Methode, um das Ergebnis zu erzielen? Gibt es nicht eine SQL - Lösung?

Update
Wie die Antworten vermuten lassen, gibt es is eine SQL-Lösung und hier eine sqlfiddle-Demo

Update 2
Nach dem Hinzufügen des obigen sqlfiddle fiel mir auf, dass die Rate, mit der die Frage bestätigt wurde, die Upvote-Rate der Antworten übertroffen hat. Das war nicht die Absicht! Die Geige basiert auf den Antworten, insbesondere der akzeptierten Antwort.

994

Auf den ersten Blick...

Sie benötigen lediglich eine GROUP BY-Klausel mit der Aggregatfunktion MAX:

SELECT id, MAX(rev)
FROM YourTable
GROUP BY id

So einfach ist das nie, oder?

Ich habe gerade bemerkt, dass Sie auch die Spalte content benötigen.

Dies ist eine sehr häufige Frage in SQL: Ermitteln Sie die gesamten Daten für die Zeile mit maximalem Wert in einer Spalte pro Gruppenkennung. Das habe ich während meiner Karriere viel gehört. Eigentlich war dies eine der Fragen, die ich im technischen Interview meines aktuellen Jobs beantwortete. 

Tatsächlich ist es so üblich, dass die StackOverflow-Community ein einzelnes Tag erstellt hat, um sich mit solchen Fragen zu befassen: best-n-per-group .

Grundsätzlich gibt es zwei Ansätze, um dieses Problem zu lösen:

Verbinden mit einfacher group-identifier, max-value-in-group-Unterabfrage

Bei diesem Ansatz finden Sie zuerst den group-identifier, max-value-in-group (bereits oben gelöst) in einer Unterabfrage. Dann verknüpfen Sie Ihre Tabelle mit der Unterabfrage mit Gleichheit für group-identifier und max-value-in-group:

SELECT a.id, a.rev, a.contents
FROM YourTable a
INNER JOIN (
    SELECT id, MAX(rev) rev
    FROM YourTable
    GROUP BY id
) b ON a.id = b.id AND a.rev = b.rev

Left Joining mit selbst, optimierten Join-Bedingungen und Filtern

Bei diesem Ansatz haben Sie die Tabelle mit sich selbst verbunden. Gleichheit geht natürlich in den group-identifier. Dann 2 Smart Moves: 

  1. Die zweite Verknüpfungsbedingung besteht darin, dass der linke Wert kleiner als der rechte Wert ist
  2. Wenn Sie Schritt 1 ausführen, wird die Zeile (n), die tatsächlich den Maximalwert enthält, auf der rechten Seite NULL angezeigt (es ist ein LEFT JOIN, erinnern Sie sich?). Dann filtern wir das verbundene Ergebnis und zeigen nur die Zeilen, in denen die rechte Seite NULL ist.

So landest du mit:

SELECT a.*
FROM YourTable a
LEFT OUTER JOIN YourTable b
    ON a.id = b.id AND a.rev < b.rev
WHERE b.id IS NULL;

Fazit

Beide Ansätze bringen genau das gleiche Ergebnis. 

Wenn Sie zwei Zeilen mit max-value-in-group für group-identifier haben, sind beide Zeilen in beiden Ansätzen im Ergebnis.

Beide Ansätze sind SQL-ANSI-kompatibel und funktionieren daher mit Ihrem bevorzugten RDBMS, unabhängig von ihrer "Flavour".

Beide Ansätze sind auch leistungsorientiert, Ihre Laufleistung kann jedoch variieren (RDBMS, DB-Struktur, Indizes usw.). Wenn Sie also einen Ansatz über den anderen wählen, benchmark. Und stellen Sie sicher, dass Sie diejenige auswählen, die für Sie am sinnvollsten ist.

1579
Adrian Carneiro

Meine Präferenz ist es, so wenig Code wie möglich zu verwenden ...

Sie können dies mit IN.__ tun. Versuchen Sie folgendes:

SELECT * 
FROM t1 WHERE (id,rev) IN 
( SELECT id, MAX(rev)
  FROM t1
  GROUP BY id
)

meiner Meinung nach ist es weniger kompliziert ... einfacher zu lesen und zu warten.

204
Kevin Burton

Eine andere Lösung ist die Verwendung einer korrelierten Unterabfrage:

select yt.id, yt.rev, yt.contents
    from YourTable yt
    where rev = 
        (select max(rev) from YourTable st where yt.id=st.id)

Mit einem Index für (id, rev) wird die Unterabfrage fast als einfache Suche dargestellt.

Es folgen Vergleiche zu den Lösungen in @ AdrianCarneiros Antwort (Unterabfrage, Linksjoin), basierend auf MySQL-Messungen mit InnoDB-Tabelle mit ~ 1 Million Datensätzen, Gruppengröße: 1-3.

Während für vollständige Tabellenscans Unterabfragen/Linksverknüpfungen/korrelierte Timings als 6/8/9 aufeinander bezogen sind, ist die Unterabfrage bei direkten Suchvorgängen oder Batch (id in (1,2,3)) viel langsamer als die anderen (aufgrund des erneuten Ausführen der Unterabfrage). Ich konnte jedoch nicht zwischen linker Verbindung und korrelierten Geschwindigkeitslösungen unterscheiden.

Eine letzte Anmerkung, da leftjoin n * (n + 1)/2 Joins in Gruppen erstellt, kann die Leistung der Gruppen stark von der Größe der Gruppen beeinflusst werden.

66
Vajk Hermecz

Ich bin verblüfft, dass keine Antwort eine SQL-Fensterfunktionslösung anbot:

SELECT a.id, a.rev, a.contents
  FROM (SELECT id, rev, contents,
               ROW_NUMBER() OVER (PARTITION BY id ORDER BY rev DESC) rank
          FROM YourTable) a
 WHERE a.rank = 1 

Im SQL-Standard ANSI/ISO-Standard SQL: 2003 hinzugefügt und später mit ANSI/ISO-Standard SQL: 2008 erweitert, sind jetzt Fenster- (oder Fenster-) Funktionen für alle großen Hersteller verfügbar. Es gibt mehrere Arten von Rangfunktionen, die sich mit einem Gleichheitsproblem befassen: RANK, DENSE_RANK, PERSENT_RANK.

54
topchef

Ich kann nicht für die Leistung bürgen, aber hier ist ein Trick, der von den Einschränkungen von Microsoft Excel inspiriert ist. Es hat einige gute Eigenschaften

GUTES ZEUG

  • Es sollte die Rückgabe nur eines "maximalen Datensatzes" erzwingen, auch wenn ein Unentschieden vorliegt (manchmal nützlich).
  • Es ist kein Join erforderlich

ANSATZ

Es ist etwas hässlich und erfordert, dass Sie etwas über den Bereich der gültigen Werte der Spalterevwissen. Nehmen wir an, dass wir wissen, dass die Spaltereveine Zahl zwischen 0,00 und 999 ist, einschließlich Dezimalzahlen, dass jedoch immer nur zwei Ziffern rechts vom Dezimalzeichen stehen (z. B. 34.17 wäre ein gültiger Wert ).

Der Kern der Sache ist, dass Sie eine einzelne synthetische Spalte erstellen, indem Sie das primäre Vergleichsfeld zusammen mit den gewünschten Daten durch eine Zeichenfolge verketten/packen. Auf diese Weise können Sie die MAX () - Aggregatfunktion von SQL zwingen, alle Daten zurückzugeben (da sie in eine einzige Spalte gepackt wurde). Dann müssen Sie die Daten auspacken.

So sieht es mit dem obigen Beispiel aus, geschrieben in SQL

SELECT id, 
       CAST(SUBSTRING(max(packed_col) FROM 2 FOR 6) AS float) as max_rev,
       SUBSTRING(max(packed_col) FROM 11) AS content_for_max_rev 
FROM  (SELECT id, 
       CAST(1000 + rev + .001 as CHAR) || '---' || CAST(content AS char) AS packed_col
       FROM yourtable
      ) 
GROUP BY id

Das Packen beginnt mit dem Erzwingen, dass die Spaltereveine Zahl bekannter Zeichenlänge ist, unabhängig vom Wert vonrev, so dass zum Beispiel

  • 3.2 wird 1003.201
  • 57 wird 1057.001
  • 923.88 wird zu 1923.881

Wenn Sie es richtig machen, sollte der Zeichenfolgenvergleich zweier Zahlen das gleiche "max" ergeben wie der Zahlenvergleich der beiden Zahlen. Es ist einfach, die ursprüngliche Zahl mithilfe der Teilzeichenfolge (die in der einen oder anderen Form verfügbar ist) zurück zu konvertieren überall).

44
David Foster

Ich denke, das ist die einfachste Lösung:

SELECT *
FROM
    (SELECT *
    FROM Employee
    ORDER BY Salary DESC)
AS employeesub
GROUP BY employeesub.Salary;
  • SELECT *: Alle Felder zurückgeben.
  • FROM Employee: Tabelle wird gesucht.
  • (SELECT * ...) Unterabfrage: Geben Sie alle Personen zurück, sortiert nach Gehalt.
  • GROUP BY employeeub.Salary:: Erzwinge, dass die am höchsten sortierte Gehaltszeile jedes Mitarbeiters das Ergebnis ist.

Wenn Sie nur eine Zeile benötigen, ist es noch einfacher:

SELECT *
FROM Employee
ORDER BY Employee.Salary DESC
LIMIT 1

Ich denke auch, dass es am einfachsten ist, andere Zwecke aufzubrechen, zu verstehen und zu modifizieren:

  • ORDER BY Employee.Salary DESC: Bestellen Sie die Ergebnisse nach dem Gehalt, wobei das höchste Gehalt zuerst angezeigt wird.
  • LIMIT 1: Gib nur ein Ergebnis zurück.

Das Verständnis dieses Ansatzes und das Lösen eines dieser ähnlichen Probleme wird zu einer Trivialität: Mitarbeiter mit dem niedrigsten Gehalt erhalten (DESC in ASC ändern), Top-Ten-verdienende Mitarbeiter (LIMIT 1 in LIMIT 10 ändern), nach einem anderen Feld sortieren (ORDER BY ändern Employee.Salary an ORDER BY Employee.Commission), etc ..

25
HoldOffHunger

Etwas wie das?

SELECT yourtable.id, rev, content
FROM yourtable
INNER JOIN (
    SELECT id, max(rev) as maxrev FROM yourtable
    WHERE yourtable
    GROUP BY id
) AS child ON (yourtable.id = child.id) AND (yourtable.rev = maxrev)
18
Marc B

Da dies die häufigste Frage in Bezug auf dieses Problem ist, werde ich hier noch eine weitere Antwort posten:

Es scheint so, als gäbe es einen einfacheren Weg (aber nur in MySQL):

select *
from (select * from mytable order by id, rev desc ) x
group by id

Bitte gib die Antwort des Benutzers Bohemian auf diese Frage für eine so prägnante und elegante Antwort auf dieses Problem.

EDIT: Obwohl diese Lösung für viele Menschen geeignet ist, kann sie auf lange Sicht nicht stabil sein, da MySQL nicht garantiert, dass die GROUP BY-Anweisung sinnvolle Werte für Spalten zurückgibt, die nicht in der GROUP BY-Liste enthalten sind. Verwenden Sie diese Lösung daher auf eigene Gefahr.

6
Yura

Ich benutze gerne eine NOT EXIST-basierte Lösung für dieses Problem:

SELECT id, rev
FROM YourTable t
WHERE NOT EXISTS (
   SELECT * FROM YourTable t WHERE t.id = id AND rev > t.rev
)
6
Bulat

Eine dritte Lösung, die ich kaum je sehe, ist MySQL-spezifisch und sieht folgendermaßen aus:

SELECT id, MAX(rev) AS rev
 , 0+SUBSTRING_INDEX(GROUP_CONCAT(numeric_content ORDER BY rev DESC), ',', 1) AS numeric_content
FROM t1
GROUP BY id

Ja, es sieht furchtbar aus (Umwandlung in String und zurück usw.), aber meiner Erfahrung nach ist es normalerweise schneller als die anderen Lösungen. Vielleicht nur für meine Anwendungsfälle, aber ich habe es für Tabellen mit Millionen Datensätzen und vielen eindeutigen IDs verwendet. Vielleicht liegt es daran, dass MySQL die anderen Lösungen ziemlich schlecht optimiert (zumindest in den 5,0 Tagen, in denen ich diese Lösung gefunden habe).

Eine wichtige Sache ist, dass GROUP_CONCAT eine maximale Länge für die Zeichenfolge hat, die es aufbauen kann. Sie möchten diese Grenze wahrscheinlich erhöhen, indem Sie die Variable group_concat_max_len einstellen. Denken Sie daran, dass dies eine Begrenzung der Skalierung darstellt, wenn Sie eine große Anzahl von Zeilen haben.

Das Obige funktioniert jedoch nicht direkt, wenn Ihr Inhaltsfeld bereits Text enthält. In diesem Fall möchten Sie wahrscheinlich ein anderes Trennzeichen verwenden, z. B.\0. Sie werden auch schneller auf das group_concat_max_len-Limit stoßen.

5
Jannes

Ich denke, du willst das?

select * from docs where (id, rev) IN (select id, max(rev) as rev from docs group by id order by id)  

SQL Fiddle: Hier prüfen

4
Abhishek Rana

Wenn Sie über viele Felder in der select-Anweisung verfügen und den neuesten Wert für alle diese Felder durch optimierten Code erhalten möchten:

select * from
(select * from table_name
order by id,rev desc) temp
group by id 
4
seahawk

NOT mySQL, aber für andere, die diese Frage finden und SQL verwenden, besteht eine andere Möglichkeit, das größte-pro-Gruppe Problem zu lösen, indem Cross Apply in MS SQL verwendet wird

WITH DocIds AS (SELECT DISTINCT id FROM docs)

SELECT d2.id, d2.rev, d2.content
FROM DocIds d1
CROSS APPLY (
  SELECT Top 1 * FROM docs d
  WHERE d.id = d1.id
  ORDER BY rev DESC
) d2

Hier ist ein Beispiel in SqlFiddle

4
KyleMit

Eine andere Möglichkeit, den Job auszuführen, ist die MAX()-Analysefunktion in der OVER PARTITION-Klausel

SELECT t.*
  FROM
    (
    SELECT id
          ,rev
          ,contents
          ,MAX(rev) OVER (PARTITION BY id) as max_rev
      FROM YourTable
    ) t
  WHERE t.rev = t.max_rev 

Die andere ROW_NUMBER() OVER PARTITION-Lösung, die bereits in diesem Beitrag dokumentiert ist, lautet

SELECT t.*
  FROM
    (
    SELECT id
          ,rev
          ,contents
          ,ROW_NUMBER() OVER (PARTITION BY id ORDER BY rev DESC) rank
      FROM YourTable
    ) t
  WHERE t.rank = 1 

Diese 2 SELECT funktionieren gut auf Oracle 10g.

MAX () - Lösung führt sicher schneller, dass ROW_NUMBER()-Lösung, weil MAX()-Komplexität O(n) ist, während ROW_NUMBER()-Komplexität mindestens O(n.log(n)) ist, wobei n die Anzahl der Datensätze in der Tabelle darstellt!

3
schlebe

Ich würde das verwenden:

select t.*
from test as t
join
   (select max(rev) as rev
    from test
    group by id) as o
on o.rev = t.rev

Die Unterabfrage SELECT ist vielleicht nicht zu effizient, aber in der JOIN-Klausel scheint das verwendbar zu sein. Ich bin kein Experte für die Optimierung von Abfragen, aber ich habe es bei MySQL, PostgreSQL und FireBird versucht, und es funktioniert sehr gut.

Sie können dieses Schema in mehreren Joins und mit der WHERE-Klausel verwenden. Es ist mein Arbeitsbeispiel (Lösung Ihres Problems mit Tabelle "firmy"):

select *
from platnosci as p
join firmy as f
on p.id_rel_firmy = f.id_rel
join (select max(id_obj) as id_obj
      from firmy
      group by id_rel) as o
on o.id_obj = f.id_obj and p.od > '2014-03-01'

Es wird an Tischen mit Teenagern und Aufzeichnungen gefragt, und bei wirklich nicht zu starken Maschinen dauert es weniger als 0,01 Sekunden.

Ich würde keine IN-Klausel verwenden (wie oben erwähnt). IN wird zur Verwendung mit kurzen Listen von constans und nicht als Abfragefilter verwendet, der auf der Unterabfrage basiert. Dies liegt daran, dass für jeden gescannten Datensatz eine Unterabfrage in IN ausgeführt wird, wodurch die Abfrage sehr lange dauern kann.

3
Marek Wysmułek

Wie wäre es damit:

SELECT all_fields.*  
FROM (SELECT id, MAX(rev) FROM yourtable GROUP BY id) AS max_recs  
LEFT OUTER JOIN yourtable AS all_fields 
ON max_recs.id = all_fields.id
3
inor
SELECT *
FROM Employee
where Employee.Salary in (select max(salary) from Employee group by Employe_id)
ORDER BY Employee.Salary
3
guru008

Keine dieser Antworten hat für mich funktioniert.

Das hat bei mir funktioniert.

with score as (select max(score_up) from history)
select history.* from score, history where history.score_up = score.max
2
qaisjp

Sortiere das Rev-Feld in umgekehrter Reihenfolge und gruppiere es dann nach der ID, die die erste Zeile jeder Gruppe ergab, die diejenige mit dem höchsten Rev-Wert ist.

SELECT * FROM (SELECT * FROM table1 ORDER BY id, rev DESC) X GROUP BY X.id;

Getestet in http://sqlfiddle.com/ mit den folgenden Daten

CREATE TABLE table1
    (`id` int, `rev` int, `content` varchar(11));

INSERT INTO table1
    (`id`, `rev`, `content`)
VALUES
    (1, 1, 'One-One'),
    (1, 2, 'One-Two'),
    (2, 1, 'Two-One'),
    (2, 2, 'Two-Two'),
    (3, 2, 'Three-Two'),
    (3, 1, 'Three-One'),
    (3, 3, 'Three-Three')
;

Dies ergab das folgende Ergebnis in MySql 5.5 und 5.6 

id  rev content
1   2   One-Two
2   2   Two-Two
3   3   Three-Two
2
blokeish

Hier ist ein schöner Weg, das zu tun

Verwenden Sie folgenden Code:

with temp as  ( 
select count(field1) as summ , field1
from table_name
group by field1 )
select * from temp where summ = (select max(summ) from temp)
2
shay

Ich mache das gerne, indem ich die Datensätze nach einer Spalte ordne. In diesem Fall werden die rev-Werte nach id gruppiert. Diejenigen mit einem höheren rev haben eine niedrigere Rangfolge. Das höchste rev wird also Rang 1 haben.

select id, rev, content
from
 (select
    @rowNum := if(@prevValue = id, @rowNum+1, 1) as row_num,
    id, rev, content,
    @prevValue := id
  from
   (select id, rev, content from YOURTABLE order by id asc, rev desc) TEMP,
   (select @rowNum := 1 from DUAL) X,
   (select @prevValue := -1 from DUAL) Y) TEMP
where row_num = 1;

Nicht sicher, ob die Einführung von Variablen das Ganze langsamer macht. Aber zumindest frage ich YOURTABLE nicht zweimal ab.

2
user5124980

Hier ist eine weitere Lösung zum Abrufen der Datensätze nur mit einem Feld, das den Maximalwert für dieses Feld enthält. Dies funktioniert für SQL400, die Plattform, an der ich arbeite. In diesem Beispiel werden die Datensätze mit dem maximalen Wert im Feld FIELD5 von der folgenden SQL-Anweisung abgerufen.

SELECT A.KEYFIELD1, A.KEYFIELD2, A.FIELD3, A.FIELD4, A.FIELD5
  FROM MYFILE A
 WHERE RRN(A) IN
   (SELECT RRN(B) 
      FROM MYFILE B
     WHERE B.KEYFIELD1 = A.KEYFIELD1 AND B.KEYFIELD2 = A.KEYFIELD2
     ORDER BY B.FIELD5 DESC
     FETCH FIRST ROW ONLY)
2
Cesar

hier ist eine andere Lösung, hoffe es hilft jemandem 

Select a.id , a.rev, a.content from Table1 a
inner join 
(SELECT id, max(rev) rev FROM Table1 GROUP BY id) x on x.id =a.id and x.rev =a.rev
2
Abdul Samad

Diese Lösung trifft nur eine Auswahl von YourTable und ist daher schneller. Laut Test auf sqlfiddle.com funktioniert es nur für MySQL und SQLite (für SQLite DESC entfernen). Vielleicht kann man daran arbeiten, an anderen Sprachen zu arbeiten, mit denen ich nicht vertraut bin.

SELECT *
FROM ( SELECT *
       FROM ( SELECT 1 as id, 1 as rev, 'content1' as content
              UNION
              SELECT 2, 1, 'content2'
              UNION
              SELECT 1, 2, 'content3'
              UNION
              SELECT 1, 3, 'content4'
            ) as YourTable
       ORDER BY id, rev DESC
   ) as YourTable
GROUP BY id
2
plavozont

Erläuterung

Dies ist kein reines SQL. Dies wird den SQLAlchemy ORM verwenden.

Ich bin hier hergekommen, um nach SQLAlchemy-Hilfe zu suchen. Ich werde die Antwort von Adrian Carneiro mit der Python/SQLAlchemy-Version, insbesondere dem Outer-Join-Teil, kopieren.

Diese Abfrage beantwortet die Frage von: 

"Können Sie mir die Datensätze in dieser Gruppe von Datensätzen (basierend auf derselben ID) zurückgeben, die die höchste Versionsnummer haben".  

Dadurch kann ich den Datensatz duplizieren, aktualisieren, die Versionsnummer erhöhen und die Kopie der alten Version so einstellen, dass ich die Änderungen im Laufe der Zeit anzeigen kann.

Code

MyTableAlias = aliased(MyTable)
newest_records = appdb.session.query(MyTable).select_from(join(
    MyTable, 
    MyTableAlias, 
    onclause=and_(
        MyTable.id == MyTableAlias.id,
        MyTable.version_int < MyTableAlias.version_int
    ),
    isouter=True
    )
).filter(
    MyTableAlias.id  == None,
).all()

Getestet in einer PostgreSQL-Datenbank.

0
Ian A McElhenny

Ich habe das Folgende verwendet, um ein eigenes Problem zu lösen. Ich habe zuerst eine temporäre Tabelle erstellt und den maximalen Umdrehungswert pro eindeutiger ID eingefügt.

CREATE TABLE #temp1
(
    id varchar(20)
    , rev int
)
INSERT INTO #temp1
SELECT a.id, MAX(a.rev) as rev
FROM 
    (
        SELECT id, content, SUM(rev) as rev
        FROM YourTable
        GROUP BY id, content
    ) as a 
GROUP BY a.id
ORDER BY a.id

Ich habe dann diese maximalen Werte (# temp1) mit allen möglichen ID/Content-Kombinationen verbunden. Auf diese Weise filtere ich natürlich die nicht-maximalen ID/Content-Kombinationen aus, und es verbleiben für jede nur die maximalen Drehzahlwerte.

SELECT a.id, a.rev, content
FROM #temp1 as a
LEFT JOIN
    (
        SELECT id, content, SUM(rev) as rev
        FROM YourTable
        GROUP BY id, content
    ) as b on a.id = b.id and a.rev = b.rev
GROUP BY a.id, a.rev, b.content
ORDER BY a.id
0
Richard Ball

Sie können die Auswahl ohne Join treffen, wenn Sie die rev und id zu einem maxRevId-Wert für MAX() kombinieren und ihn dann wieder in die ursprünglichen Werte aufteilen:

SELECT maxRevId & ((1 << 32) - 1) as id, maxRevId >> 32 AS rev
FROM (SELECT MAX(((rev << 32) | id)) AS maxRevId
      FROM YourTable
      GROUP BY id) x;

Dies ist besonders schnell, wenn anstelle einer einzelnen Tabelle ein komplexer Join vorhanden ist. Bei den traditionellen Ansätzen würde der komplexe Join zweimal durchgeführt werden.

Die obige Kombination ist mit Bitfunktionen einfach, wenn rev und idINT UNSIGNED (32 Bit) sind und der kombinierte Wert auf BIGINT UNSIGNED (64 Bit) passt. Wenn id & rev größer als 32-Bit-Werte ist oder aus mehreren Spalten besteht, müssen Sie den Wert in z. ein binärer Wert mit geeigneter Auffüllung für MAX().

0
zovio