La sélection de max() de plusieurs colonnes

Ok, voici ma table:

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

Maintenant, je veux sélectionner la dernière version d'un produit, de sorte que la version avec le plus haut update_id & patch_id.

Par exemple, la dernière version de

produit 1 doit retourner 1, 2, 1
produit de 2 et de 3, 0, 1
produit 3 doit retourner 1, 0, 1

J'ai essayé toutes sortes de choses avec GROUP BY et HAVING, essayé des sous-requêtes, mais je n'ai pas encore trouver un moyen pour accomplir cette tâche.

Quelqu'un peut-il m'aider à trouver la bonne requête, ou devrais-je penser à écrire une fonction php pour cela?

Modifier

Quelques informations supplémentaires:
- Les colonnes sont la clé primaire (il y a plus de colonnes, mais pour ce problème, ils n'ont pas d'importance)
- Aucun des colonnes est en auto-increment

C'est la table:

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

Marqué comme en double, il n'est pas: L'autre question pour les enregistrements supérieur à une valeur pour l'une des trois colonnes différentes.

Dans cette question, nous recherchons pour le plus grand numéro de version regroupés par le product_id.

Modifier 3

rgz réponse me dit encore que c'est un doublon. Tout d'abord: cette question est plus. Deuxièmement, je ne pense pas que la réponse est la même.

rgz suggère d'utiliser la requête suivante:

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

PLUS grand(1,2,3) renvoie 3, à droite? Wat si nous avons ces valeurs:

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

Que je comprends, cette requête sera de retour:

  product_id  latest_version
  1                 1
  1                 8
  1                 3

Mais il doit retourner:

  product_id  version_id update_id  patch_id
  1           3          0          0

Je ne pense pas que le PLUS susceptible de l'aider. Si vous pensez qu'il va, merci de me prouver le contraire.

Je sais que c'est une vieille question, mais vous pouvez aussi faire ceci: SELECT * from db.patch COMMANDE PAR UPDATE_ID DESC, PATCH_ID DESC LIMIT 1;
Double Possible de Mysql valeur max à partir de 3 colonnes
Ce n'est pas un doublon. Voir mon edit.
Pour clarifier, est la condition pour que le retour lignes doivent être de la plus haute patch_id de la plus haute update_id de la plus haute version_id de chaque product_id?
Oui, c'est la condition.

InformationsquelleAutor Scuba Kay | 2011-12-14

mysql sql

C'est un exemple de cas unique identificateurs venir dans utile.

Imaginez que vous avez un autoincrememnting champ ID, vous pouvez trouver l'id que vous souhaitez pour chaque produit, en utilisant une sous-requête corrélée...

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
       )

L'équivalent sans un unique identifiant nécessite plusieurs corrélation des sous-requêtes...

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
                  )

Ce serait nettement plus lent que sur une table avec un identifiant unique colonne.

Une autre solution (sans identifiant unique) est de l'auto-jointure sur les différents niveaux d'agrégation.

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

il y a une virgule manquante avant patch_id btw (ce n'est pas un assez grand changement qui DONC va me permettre de modifier)
Qu'advient-il si cette ligne est dans la table (1,1,1,3) ?
Avec l'auto incrémentation du champ ID, chaque ligne a un identifiant unique. Ensuite, la sous-requête renvoie toutes les notices pour les associés product_id. Ensuite, seul le premier est choisi (Version la plus récente, mise à Jour, Patch). Alors que l'extérieur de la requête récupère les enregistrements avec cet id unique. En bref, il fonctionne toujours, quelles que soient les valeurs que vous avez.
Oublié de vous le dire, aucun des colonnes est en auto-increment. La clé primaire est product_id, version_id, update_id et patch_id ensemble. Donc, dans mon cas cela ne vous aide pas, ça va?
Correcte, vous devez ajouter une colonne à vos données. C'est un exemple où un identifiant unique (plutôt qu'une clé composite) peut être très utile.
Peut-être que je vais le faire, je vais d'abord jeter un oeil à quelques autres réponses.
J'ai essayé de vos requêtes sur les données de l'échantillon. Les 2e et 3e requêtes de l'excellent travail !!! +1 !!!
Eh bien, merci beaucoup. Je vais utiliser votre exemple avec la corrélation des sous-requêtes, fonctionne parfaitement!

InformationsquelleAutor MatBailie

3

Essayer:
```
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
```
Excusez-moi, c'est @RolandoMySQLDBA. Pardonner à l'intrusion, mais je suis de l'affichage de votre requête et de sa sortie à l'encontre de l'échantillon de données:
```
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)
```
Votre requête fonctionne comme indiqué. Il est aussi plus simple à mon avis. Bon Spectacle !!!
- Le fait même de travailler dans un parrallised environnement où les différents threads peuvent être le traitement des différentes parties de la table? Et/ou avez-vous des citations qui montrent le maintien de l'ORDRE et pertinents pour la requête externe? [la chose entière de MySQL permettant à cette juste m'effraie un peu]
- Cela semble fonctionner, @Dems En débutant langue, quel est votre problème avec cette approche?
- J'ai pensé que j'avais lu que MySQL prend les valeurs à partir du premier enregistrement du groupe (commandé par index si aucune justification d'ordre de tri spécifié; des clauses order by ou après que le groupe ne sont appliqués que après le groupement), mais je ne trouve pas de citation pour ce. En revanche, le Manuel de Référence de MySQL, dans la section relative à "GROUP BY et HAVING avec les Colonnes Masquées", dit explicitement de non-colonnes groupées que "le résultat est indéterminé".
- Dems est préoccupé de constater que cette approche peut ne pas être fiable, même si elle fonctionne dans des conditions d'essai.
- Je suis surpris. J'ai essayé votre requête sur les données de l'échantillon dans ma question ET VOTRE REQUÊTE FONCTIONNE !!! + 1 !!!
- Comme MarkBannister dit, je ne suis pas certain à 100% que l'ordre des données garantie comment les résultats sont sélectionnés. Si, par exemple, plusieurs cœurs sont chargés de compléter cela, les résultats toujours être le même? Peut-être, mais c'est une dure épreuve pour l'ingénieur. Et il n'est pas semble pour être tout document confirmant celle-ci. Plus vraiment dire que vous vous ne pouvez pas être garanti, ce que seront les résultats. C'est pourquoi j'ai dit que cela m'effraie un peu 😉
InformationsquelleAutor

Je n'ai pas tester, mais je suis sûr que vous pouvez faire quelque chose comme ceci

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;

Excusez-moi, c'est @RolandoMySQLDBA. Pardonner à l'intrusion, mais je suis de l'affichage de votre requête et de sa sortie à l'encontre de l'échantillon de données:

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)

Bien que l'affichage est différent, votre requête logiquement travaille pour la question d'origine. +1 de moi !!!

InformationsquelleAutor Fred

0

Vous pourriez groupe par max(update_id * maxpatchidvalue + patch_id) pour obtenir ce que vous voulez.
- Je pense que la mise à jour 2, patch 0 est plus récente que la mise à jour 1 patch 1.
- assuminga max_patch_id de 100 : (2 * 100 + 0) > (1 * 100 + 1) => ce mécanisme fonctionne à condition de ne pas provoquer une erreur de dépassement de capacité.
InformationsquelleAutor fge

À l'aide de vos données d'entrée à partir de la question, et une table avec des pas de touches, ici, est plutôt malade approche qui fonctionne:

Tout d'abord, la requête que vous avez besoin est: est-ce

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;

Voici un exemple de code à l'aide de tous les nombres entiers, pas d'index, et votre exemple de données:

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;

Voici le résultat:

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>

Lui donner un essai !!!

Mise en garde

Ma réponse sera un soutien par produit

jusqu'à 99 versions
jusqu'à 99 mises à jour
jusqu'à 99 patches

La formule est différente. J'utilise version_id*10000+update_id*100+patch_id. @fge utilise update_id * maxpatchidvalue + patch_id
Ma réponse produit le résultat désiré basé sur les données fournies dans la question.

InformationsquelleAutor RolandoMySQLDBA

De l'essayer.

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

Vous devez joindre sur product_id ainsi. ORDER BY n'est pas nécessaire lorsque vous utilisez le MAX(). Alors, que faire si vous avez (2,0) et (1,1)? Votre mécanisme donne (2,1) que le résultat, même s'il n'existe pas.

InformationsquelleAutor Glenn

-1

MySQL a la GREATEST fonction de sorte que vous devriez l'utiliser comme ceci:
```
SELECT product_id, GREATEST(version_id, update_id, patch_id) AS latest_version FROM patch.
```
J'ai marqué cette question comme un doublon, car les deux questions sont fondamentalement demander la même chose, la sélection de la valeur maximale de plusieurs colonnes. Ici, vous l'utiliser dans la clause SELECT, dans l'autre la question de l'utiliser dans la clause where. Dans les deux cas, PLUS grand est le tour est joué.
- Vous avez marqué cette question comme un double d'une question d'un an de moins, par la manière.
- PLUS grand(1,2,3) renvoie 3, à droite? Wat si nous avons ces valeurs: product_id version_id update_id patch_id 1 1 0 0 1 1 2 8 1 3 0 0 ce Que je comprends, votre requête sera de retour: product_id latest_version 1 1 1 8 1 3, Mais il doit retourner: product_id version_id update_id patch_id 1 3 0 0
- > Vous avez marqué cette question comme un double d'une question d'un an de moins par la voie < je l'ai fait? Et alors? Je suis juste essayer de réduire le nombre de questions redondantes je ne pensais pas à l'ancienneté.
InformationsquelleAutor rgz

Vous devez vous connecter pour publier un commentaire.