Die Wahl von max() für mehrere Spalten

Ok, hier ist meine Tabelle:

product_id  version_id  update_id  patch_id
  1           1           0          0
  1           1           1          0
  1           1           1          1
  1           1           2          0
  1           1           2          1
  2           1           0          0
  2           2           0          0
  2           3           0          0
  2           3           0          1
  3           1           0          0
  3           1           0          1

Nun möchte ich wählen Sie die neueste version von einem Produkt, also die version mit der höchsten update_id & patch_id.

Beispielsweise die neueste version von

Produkt 1 sollten zurück 1, 2, 1
Produkt 2 zurückkehren sollte, 3, 0, 1
Produkt 3 zurückkehren sollte, 1, 0, 1

Ich versuchte alle Arten von Sachen, die mit GROUP BY und HAVING, versuchte Unterabfragen, aber ich kann immer noch nicht herausfinden, einen Weg, dies zu erreichen.

Kann mir jemand helfen den richtigen zu finden-Abfrage, oder sollte ich schreiben eine php-Funktion dafür?

Bearbeiten

Einige zusätzliche Infos:
- Die Spalten sind zusammen der Primärschlüssel (es sind mehr Spalten, aber für dieses problem Sie nicht betrifft)
- Keine der Spalten ist auto-increment

Dies ist die Tabelle:

CREATE  TABLE IF NOT EXISTS `db`.`patch` (
`product_id` INT NOT NULL ,
`version_id` INT NOT NULL ,
`update_id` INT NOT NULL ,
`patch_id` INT NOT NULL
PRIMARY KEY (`product_id`, `version_id`, `update_id`, `patch_id`) ,
INDEX `fk_patch_update1` (`product_id` ASC, `version_id` ASC, `update_id` ASC) )

Edit 2

Gekennzeichnet als Duplikate, es ist nicht: Die andere Frage scheint für Datensätze, die höher als ein Wert für jeden der drei verschiedenen Spalten.

In dieser Frage suchen wir nach der höchsten Versionsnummer gruppiert nach product_id.

Edit 3

landesvermessungsamtes Antwort sagt mir wieder, dass dies ein Duplikat ist. Zunächst einmal: diese Frage ist älter. Zweitens, ich glaube nicht, dass die Antwort ist die gleiche.

landesvermessungsamtes schlägt mit der folgenden Abfrage:

SELECT product_id, GREATEST(version_id, update_id, patch_id) AS latest_version FROM patch.

GRÖßTEN(1,2,3) liefert 3, richtig? Wat, wenn wir diese Werte:

  product_id  version_id  update_id  patch_id
  1           1           0          0
  1           1           2          8
  1           3           0          0

So wie ich das verstehe, ist diese Abfrage wil zurück:

  product_id  latest_version
  1                 1
  1                 8
  1                 3

Aber es sollte zurück:

  product_id  version_id update_id  patch_id
  1           3          0          0

Ich glaube nicht, GRÖßTEN helfen könnte. Wenn Sie denken, es wird, bitte beweisen mich nicht falsch.

Ich weiß, es ist eine alte Frage, aber Sie könnte dies auch tun: SELECT * FROM db.patch BESTELLUNG DURCH UPDATE_ID DESC, PATCH_ID DESC LIMIT 1;
Mögliche Duplikate von Mysql-max-Wert aus 3 verschiedenen Spalten
Dies ist kein Duplikat. Siehe mein edit.
Zu klären ist, ist die Bedingung, dass die Rückgabe von Zeilen muss die höchste patch_id der höchsten update_id des höchsten version_id jeder product_id?
Ja, das ist die Bedingung.

InformationsquelleAutor Scuba Kay | 2011-12-14

mysql sql

Dies ist ein Beispiel, wenn eine eindeutige identifers nützlich sein können.

Stellen Sie sich vor Sie haben eine autoincrememnting ID-Feld, dann können Sie die id für jedes Produkt über eine korrelierte sub-query...

SELECT
  *
FROM
  yourTable
WHERE
  id = (
        SELECT   id
        FROM     yourTable AS lookup
        WHERE    lookup.product_id = yourTable.product_id
        ORDER BY version_id DESC, update_id DESC, patch_id DESC
        LIMIT    1
       )

Den Gegenwert ohne eine eindeutige Bezeichner erfordert mehrere korrelierte sub-queries...

SELECT
  *
FROM
  yourTable
WHERE
     version_id = (
                   SELECT   MAX(version_id)
                   FROM     yourTable AS lookup
                   WHERE    lookup.product_id = yourTable.product_id
                  )
  AND update_id = (
                   SELECT   MAX(update_id)
                   FROM     yourTable AS lookup
                   WHERE    lookup.product_id = yourTable.product_id
                     AND    lookup.version_id = yourTable.version_id
                  )
  AND patch_id  = (
                   SELECT   MAX(patch_id)
                   FROM     yourTable AS lookup
                   WHERE    lookup.product_id = yourTable.product_id
                     AND    lookup.version_id = yourTable.version_id
                     AND    lookup.update_id  = yourTable.update_id
                  )

Diese wäre deutlich langsamer als auf einer Tabelle mit einem eindeutigen identifier-Spalte.

Andere alternative (ohne unique identifier) ist self-join auf verschiedenen Ebenen der aggregation.

SELECT
  yourTable.*
FROM
  (SELECT product_id, MAX(version_id) AS max_version_id FROM yourTable GROUP BY product_id) AS version
INNER JOIN
  (SELECT product_id, version_id, MAX(update_id) AS max_update_id FROM yourTable GROUP BY product_id, version_id) AS update
    ON  update.product_id = version.product_id
    AND update.version_id = version.max_version_id
INNER JOIN
  (SELECT product_id, version_id, updatE_id, MAX(patch_id) AS max_patch_id FROM yourTable GROUP BY product_id, version_id) AS patch
    ON  patch.product_id = update.product_id
    AND patch.version_id = update.version_id
    AND patch.update_id  = update.max_update_id
INNER JOIN
  yourTable
    ON  yourTable.product_id = patch.product_id
    AND yourTable.version_id = patch.version_id
    AND yourTable.update_id  = patch.update_id
    AND yourTable.patch_id   = patch.max_patch_id

es ist ein Komma fehlt vor patch_id btw (es ist nicht eine, die groß genug ändern, SO wird mir erlauben, zu Bearbeiten)
danke, korrigiert 🙂
Was passiert, wenn diese Zeile in der Tabelle (1,1,1,3) ?
Mit der auto-increment-ID-Feld, jede Zeile hat eine eindeutige Kennung. Dann ist die sub-Abfrage findet alle Datensätze, die für die zugeordnete product_id. Dann, wird nur das erste ausgewählt wird (höchste Version, Update, Patch). Dann die äußere query holt die Datensätze mit eindeutiger id. Kurz gesagt, es funktioniert immer noch, was auch immer Werte, die Sie haben.
Habe vergessen zu sagen, keine der Spalten ist auto-increment. Der primäre Schlüssel ist, product_id, version_id, update_id und patch_id zusammen. Also, in meinem Fall, dies wird nicht helfen, oder?

InformationsquelleAutor MatBailie

3

Versuchen:
```
Select product_id, version_id, update_id, patch_id
from (select * from MyTable 
      order by product_id, version_id desc, update_id desc, patch_id desc) as v
group by product_id
```
Entschuldigen Sie mich, es ist @RolandoMySQLDBA. Verzeihen Sie die Störung, aber ich bin Entsendung Ihrer Abfrage, und Ihre Ausgabe gegen die Beispieldaten:
```
mysql> Select product_id, version_id, update_id, patch_id
    -> from (select * from prod
    ->       order by product_id, version_id desc, update_id desc, patch_id desc) as v
    -> group by product_id  ;
+------------+------------+-----------+----------+
| product_id | version_id | update_id | patch_id |
+------------+------------+-----------+----------+
|          1 |          1 |         2 |        1 |
|          2 |          3 |         0 |        1 |
|          3 |          1 |         0 |        1 |
+------------+------------+-----------+----------+
3 rows in set (0.00 sec)
```
Deine Abfrage funktioniert, wie dargestellt. Es ist auch einfacher als meine Antwort. Gute Show!!!!!

Nicht, dass auch die Arbeit in einem parrallised Umgebung, wo die verschiedenen threads könnte die Verarbeitung die verschiedenen Teile der Tabelle? Und/oder hast du irgendwelche Zitate, die zeigen, dass die REIHENFOLGE beibehalten wird und relevant ist, um die äußere Abfrage? [die ganze Sache mit MySQL so dass dieser nur erschreckt mich ein bisschen]
Dies scheint zu funktionieren, @Dems In newbie-Sprache, was ist Ihr problem mit diesem Ansatz?
Ich dachte, ich hätte gelesen, dass MySQL die Werte aus dem ersten Datensatz in der Gruppe (geordnet nach index, wenn keine überwiegenden Sortierreihenfolge angegeben ist; die order by-Klauseln mit oder nach der Gruppe werden nur übernommen, nachdem die Gruppierung), aber ich finde keine Quellenangabe für diese. Im Gegensatz dazu, die MySQL-Referenz-Handbuch, im Abschnitt über "die GROUP BY-und HAVING mit Ausgeblendeten Spalten", die explizit sagt, dass der nicht-gruppierten Spalten, dass "das Ergebnis ist unbestimmt".
Dems ist besorgt, dass dieser Ansatz möglicherweise nicht zuverlässig, auch wenn es funktioniert unter Testbedingungen.
Ich bin überrascht. Ich habe versucht die Abfrage der Beispiel-Daten in meine Frage UND DEINE ABFRAGE FUNKTIONIERT !!! + 1 !!!

InformationsquelleAutor

Habe ich nicht getestet, aber ich bin sicher, Sie können etwas tun, wie dieses

SELECT val.product_id, MAX(val.myVersion)
FROM (SELECT product_id, ((version_id * 10 + update_id) * 10 + patch_id) as myVersion
      FROM myTable) as val
GROUP by product_id;

Entschuldigen Sie mich, es ist @RolandoMySQLDBA. Verzeihen Sie die Störung, aber ich bin Entsendung Ihrer Abfrage, und Ihre Ausgabe gegen die Beispieldaten:

mysql> SELECT val.product_id, MAX(val.myVersion)
    -> FROM (SELECT product_id, ((version_id * 10 + update_id) * 10 + patch_id) as myVersion
    ->       FROM prod) as val
    -> GROUP by product_id;
+------------+--------------------+
| product_id | MAX(val.myVersion) |
+------------+--------------------+
|          1 |                121 |
|          2 |                301 |
|          3 |                101 |
+------------+--------------------+
3 rows in set (0.01 sec)

Obwohl die Anzeige unterschiedlich ist, wird die Abfrage logisch arbeitet für die ursprüngliche Frage. +1 von mir !!!

thx 😉

InformationsquelleAutor Fred

0

Könnten Sie durch max(update_id * maxpatchidvalue + patch_id) zu bekommen, was Sie wollen.

Ich denke, update 2, patch 0 ist Aktueller als das update 1, patch 1.
das ist richtig
assuminga max_patch_id von 100 : (2 * 100 + 0) > (1 * 100 + 1) => dieser Mechanismus funktioniert, vorausgesetzt, dass es nicht zu einem überlauf-Fehler.

InformationsquelleAutor fge

Verwenden Sie Ihre Eingabedaten von der Frage, und eine Tabelle ohne Schlüssel, hier ist ein ziemlich krankes Konzept, das funktioniert:

Zunächst die Abfrage, die Sie brauchen, ist diese:

select A.* from prod A LEFT JOIN
(select product_id,max(tagnum) maxtag from
(select *,(version_id*10000+update_id*100+patch_id) tagnum from prod) AA
group by product_id) B
USING (product_id)
WHERE (version_id*10000+update_id*100+patch_id) = B.maxtag;

Ist hier einige Beispiel-code mit allen zahlen, nicht Indizes und Ihrer Daten Beispiel:

DROP TABLE IF EXISTS prod;
CREATE TABLE prod
(
product_id INT,
version_id INT,
update_id INT,
patch_id INT
) ENGINE=MyISAM;
INSERT INTO prod VALUES
( 1,  1,  0, 0 ),
( 1,  1,  1, 0 ),
( 1,  1,  1, 1 ),
( 1,  1,  2, 0 ),
( 1,  1,  2, 1 ),
( 2,  1,  0, 0 ),
( 2,  2,  0, 0 ),
( 2,  3,  0, 0 ),
( 2,  3,  0, 1 ),
( 3,  1,  0, 0 ),
( 3,  1,  0, 1 );
select * from prod;
select *,(version_id*10000+update_id*100+patch_id) tagnum from prod;
select A.* from prod A LEFT JOIN
(select product_id,max(tagnum) maxtag from
(select *,(version_id*10000+update_id*100+patch_id) tagnum from prod) AA
group by product_id) B
USING (product_id)
WHERE (version_id*10000+update_id*100+patch_id) = B.maxtag;

Hier ist das Ergebnis:

mysql> DROP TABLE IF EXISTS prod;
Query OK, 0 rows affected (0.00 sec)

mysql> CREATE TABLE prod
    -> (
    -> product_id INT,
    -> version_id INT,
    -> update_id INT,
    -> patch_id INT
    -> ) ENGINE=MyISAM;
Query OK, 0 rows affected (0.04 sec)

mysql> INSERT INTO prod VALUES
    -> ( 1,  1,  0, 0 ),
    -> ( 1,  1,  1, 0 ),
    -> ( 1,  1,  1, 1 ),
    -> ( 1,  1,  2, 0 ),
    -> ( 1,  1,  2, 1 ),
    -> ( 2,  1,  0, 0 ),
    -> ( 2,  2,  0, 0 ),
    -> ( 2,  3,  0, 0 ),
    -> ( 2,  3,  0, 1 ),
    -> ( 3,  1,  0, 0 ),
    -> ( 3,  1,  0, 1 );
Query OK, 11 rows affected (0.00 sec)
Records: 11  Duplicates: 0  Warnings: 0

mysql> select * from prod;
+------------+------------+-----------+----------+
| product_id | version_id | update_id | patch_id |
+------------+------------+-----------+----------+
|          1 |          1 |         0 |        0 |
|          1 |          1 |         1 |        0 |
|          1 |          1 |         1 |        1 |
|          1 |          1 |         2 |        0 |
|          1 |          1 |         2 |        1 |
|          2 |          1 |         0 |        0 |
|          2 |          2 |         0 |        0 |
|          2 |          3 |         0 |        0 |
|          2 |          3 |         0 |        1 |
|          3 |          1 |         0 |        0 |
|          3 |          1 |         0 |        1 |
+------------+------------+-----------+----------+
11 rows in set (0.00 sec)

mysql> select *,(version_id*10000+update_id*100+patch_id) tagnum from prod;
+------------+------------+-----------+----------+--------+
| product_id | version_id | update_id | patch_id | tagnum |
+------------+------------+-----------+----------+--------+
|          1 |          1 |         0 |        0 |  10000 |
|          1 |          1 |         1 |        0 |  10100 |
|          1 |          1 |         1 |        1 |  10101 |
|          1 |          1 |         2 |        0 |  10200 |
|          1 |          1 |         2 |        1 |  10201 |
|          2 |          1 |         0 |        0 |  10000 |
|          2 |          2 |         0 |        0 |  20000 |
|          2 |          3 |         0 |        0 |  30000 |
|          2 |          3 |         0 |        1 |  30001 |
|          3 |          1 |         0 |        0 |  10000 |
|          3 |          1 |         0 |        1 |  10001 |
+------------+------------+-----------+----------+--------+
11 rows in set (0.01 sec)

mysql> select A.* from prod A LEFT JOIN
    -> (select product_id,max(tagnum) maxtag from
    -> (select *,(version_id*10000+update_id*100+patch_id) tagnum from prod) AA
    -> group by product_id) B
    -> USING (product_id)
    -> WHERE (version_id*10000+update_id*100+patch_id) = B.maxtag;
+------------+------------+-----------+----------+
| product_id | version_id | update_id | patch_id |
+------------+------------+-----------+----------+
|          1 |          1 |         2 |        1 |
|          2 |          3 |         0 |        1 |
|          3 |          1 |         0 |        1 |
+------------+------------+-----------+----------+
3 rows in set (0.00 sec)

mysql>

Probieren Sie es aus !!!

VORBEHALT

Meine Antwort wird die Unterstützung pro Produkt

bis zu 99 Versionen
bis zu 99 updates
bis zu 99 patches

Gleiche wie fge Antwort.
Die Formel ist anders. Ich benutze version_id*10000+update_id*100+patch_id. @fge verwendet update_id * maxpatchidvalue + patch_id
Meine Antwort erzeugt die gewünschte Ausgabe auf der Grundlage der input-Daten, die in die Frage.

InformationsquelleAutor RolandoMySQLDBA

Versuchen.

SELECT
  version_id,
  max_update.update_id,
  max_patch.patch_id
FROM
  TABLE
    OUTER APPLY
    (
      SELECT TOP 1
        update_id
      FROM
        TABLE t1
      WHERE
        TABLE.version_id = t1.version_id
        AND TABLE.product_id = t1.product_id
      ORDER BY update_id DESC
    ) max_update
    OUTER APPLY
    (
      SELECT TOP 1
        patch_id 
      FROM
        TABLE t1
      WHERE
        TABLE.version_id = t1.version_id
        AND TABLE.product_id = t1.product_id
        AND max_update.update_id = t1.update_id
      ORDER BY patch_id DESC
    ) max_patch

Sie müssen sich auf product_id als gut. ORDER BY ist nicht erforderlich, wenn Sie verwenden Sie MAX(). Dann, was ist, wenn Sie (2,0) und (1,1)? Ihr Mechanismus gibt (2,1) als das Ergebnis, auch wenn es ihn nicht gibt.
Gute Punkte, ich habe überarbeitet.

InformationsquelleAutor Glenn

-1

MySQL hat die GREATEST - Funktion, so sollten Sie es verwenden, wie diese:
```
SELECT product_id, GREATEST(version_id, update_id, patch_id) AS latest_version FROM patch.
```
Markierte ich diese Frage als Duplikat, weil beide Fragen sind im Grunde Fragen, die gleiche Sache, die Auswahl der maximale Wert der verschiedenen Spalten. Hier verwenden Sie in der SELECT-Klausel, in der anderen Frage, die Sie verwenden Sie in der WHERE-Klausel. In jedem Fall GRÖßTE der trick funktioniert.

Sie markiert diese Frage als Duplikat eine Frage, die ein Jahr jünger durch die Art und Weise.
GRÖßTE(1,2,3) liefert 3, richtig? Wat, wenn wir diese Werte: version_id product_id update_id patch_id 1 1 0 0 1 1 2 8 1 3 0 0 so Wie ich das verstehe, wird die Abfrage wil zurück: product_id latest_version 1 1 1 8 1 3, Aber es sollte zurück: version_id product_id update_id patch_id 1 3 0 0
> Sie markiert diese Frage als Duplikat eine Frage, die ein Jahr jünger durch die Art, wie < habe ich? So what? Ich bin nur versuchen, zu reduzieren die Anzahl der redundanten Fragen, die ich gar nicht denken, der Dauer der Betriebszugehörigkeit.

InformationsquelleAutor rgz

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.