Bonjour à tous et à toutes....
J'utilise ce site pour tester : https://www.tutorialspoint.com/execute_sql_online.php
Ce que je demande là, je l'ai codé en Linq sous EntityFramework mais là, en SQL c'est un peu plus compliqué...

Voilà le problème : j'ai deux tables, jusque là c'est simple...
Table : Table commune :
Code : Sélectionner tout - Visualiser dans une fenêtre à part
CREATE TABLE Common(CommonID integer PRIMARY KEY, Name text, Version integer,Color text);
Elle contient :
1    |    Tom    |    1    |    rouge
2    |    Lucy   |    1    |    vert
3    |    Frank  |    1    |    bleu
4    |    Tom    |    3    |    yellow
5    |    Bob    |    1    |    blue
6    |    Lucy   |    3    |    black
7    |    Tom    |    2    |    purple
8    |    Lucy   |    2    |    orange
9    |    Frank  |    2    |    marron
Deuxième table :
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
CREATE TABLE MyTable(MyTableID integer PRIMARY KEY, AAA text, FKCommonID integer,
    CONSTRAINT FK_CommonID_Common FOREIGN KEY (FKCommonID)
        REFERENCES Common(CommonID)
        ON DELETE CASCADE
        ON UPDATE CASCADE
    );
11    |    Pluc    |    1
12    |    Plog    |    3
13    |    Toci    |    6
14    |    Pouc    |    9
15    |    Bloc    |    3
16    |    Plou    |    9
Une requête simple pour récupérer les informations via une jointure :
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
SELECT MyTable.MyTableID as ID,
       MyTable.AAA as Pseudo,
       Common.Name as Nom,
       Common.Version as Version,
       Common.Color as Couleur
FROM MyTable
JOIN Common ON MyTable.FKCommonID = Common.CommonID;
Résultat :
11    |    Pluc    |    Tom      |    1    |    rouge
12    |    Plog    |    Frank    |    1    |    bleu
13    |    Toci    |    Lucy     |    3    |    black
14    |    Pouc    |    Frank    |    2    |    marron
15    |    Bloc    |    Frank    |    1    |    bleu
16    |    Plou    |    Frank    |    2    |    marron
Bon jusque là rien de bien compliqué...
Là où cela se complique, c'est qu'en fait, le champ Common.Name est un champ contenant une version. Lorsque l'on récupère une ligne, j'aimerais savoir, si pour ce champ Nom, la ligne affiché est la version la plus grande de toutes les lignes qui ont ce nom.
En fait je référence des éléments dont les noms sont les clefs (en quelque sorte) et où chaque élément est versionné : aucun trou entre les versions, les versions commencent à 1.
Et ce qu'on veut savoir c'est si la donnée est la dernière version ou pas.

Typiquement, j'aimerais une requête qui me retourne :
11    |    Pluc    |    Tom      |    1    |    rouge      |    False (ici la dernière version de Tom est '3' et cette ligne pointe sur un Tom dont la version est '1'
12    |    Plog    |    Frank    |    1    |    bleu       |    False (ici la dernière version de Franck est '2' et cette ligne pointe sur un Franck dont la version est '1'
13    |    Toci    |    Lucy     |    3    |    black      |    True  (ici la dernière version de Lucy est '3' et cette ligne pointe sur un Lucy dont la version est '3'
14    |    Pouc    |    Frank    |    2    |    marron     |    True  (ici la dernière version de Franck est '2' et cette ligne pointe sur un Franck dont la version est '2'
15    |    Bloc    |    Frank    |    1    |    bleu       |    False (ici la dernière version de Franck est '2' et cette ligne pointe sur un Franck dont la version est '1'
16    |    Plou    |    Frank    |    2    |    marron     |    True  (ici la dernière version de Franck est '2' et cette ligne pointe sur un Franck dont la version est '2'
Le première étape consisterait à récupérer le MAX des versions via un GROUP BY NAME.
Déjà là je pèche : le WHERE Name = Nom, Nom est inconnu mais c'est ça l'idée => grouper par le nom, le nom qui est le résultat de la requête avec la jointure...
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
SELECT MyTable.MyTableID as ID,
       MyTable.AAA as Pseudo,
       Common.Name as Nom,
       Common.Version as Version,
       Common.Color as Couleur,
       (SELECT MAX(Version)
        FROM Common
        JOIN MyTable
        ON Common.CommonID = MyTable.FKCommonID
        WHERE Name = Nom
        GROUP BY Name
) As MaxVersion
FROM MyTable
JOIN Common
ON MyTable.FKCommonID = Common.CommonID;
Après l'idée, est que si j'ai le MAX de la version, je devrais pouvoir avoir une colonne de type bool avec Version = MaxVersion qui me donnerait true ou False....
Je vous donne tout le code que j'ai écris sur le site pour pouvoir tester :
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
DROP TABLE IF EXISTS Common;
DROP TABLE IF EXISTS MyTable;
 
BEGIN TRANSACTION;
 
/* Création de la table Common */
CREATE TABLE Common(CommonID integer PRIMARY KEY, Name text, Version integer,Color text);
 
/* Create few records in this table */
INSERT INTO Common VALUES(1,'Tom' ,  1, 'rouge');
INSERT INTO Common VALUES(2,'Lucy',  1, 'vert');
INSERT INTO Common VALUES(3,'Frank', 1, 'bleu');
INSERT INTO Common VALUES(4,'Tom',   3, 'yellow');
INSERT INTO Common VALUES(5,'Bob',   1, 'blue');
INSERT INTO Common VALUES(6,'Lucy',  3, 'black');
INSERT INTO Common VALUES(7,'Tom',   2, 'purple');
INSERT INTO Common VALUES(8,'Lucy',  2, 'orange');
INSERT INTO Common VALUES(9,'Frank', 2, 'marron');
 
/* Création de la table MyTable */
CREATE TABLE MyTable(MyTableID integer PRIMARY KEY, AAA text, FKCommonID integer,
    CONSTRAINT FK_CommonID_Common FOREIGN KEY (FKCommonID)
        REFERENCES Common(CommonID)
        ON DELETE CASCADE    
        ON UPDATE CASCADE    
    );
 
INSERT INTO MyTable VALUES(11, 'Pluc' , 1);
INSERT INTO MyTable VALUES(12, 'Plog',  3);
INSERT INTO MyTable VALUES(13, 'Toci',  6);
INSERT INTO MyTable VALUES(14, 'Pouc',  9);
INSERT INTO MyTable VALUES(15, 'Bloc',  3);
INSERT INTO MyTable VALUES(16, 'Plou',  9);
 
COMMIT;
 
/* Vérification que la clef étrangère fonctionne bien 
DELETE FROM Common WHERE Name = 'Frank';
*/
 
/* Display all the records from the table */
/*
SELECT MyTable.MyTableID as ID,
       MyTable.AAA as Pseudo,
       Common.Name as Nom,
       Common.Version as Version,
       Common.Color as Couleur
FROM MyTable
JOIN Common ON MyTable.FKCommonID = Common.CommonID;
*/
/*
SELECT *, MAX(Version)
        FROM Common
        GROUP BY Name;
*/
 
SELECT MyTable.MyTableID as ID,
       MyTable.AAA as Pseudo,
       Common.Name as Nom,
       Common.Version as Version,
       Common.Color as Couleur,
       (SELECT MAX(Version)
        FROM Common
        JOIN MyTable
        ON Common.CommonID = MyTable.FKCommonID
        WHERE Name = Nom
        GROUP BY Name
) As MaxVersion
FROM MyTable
JOIN Common
ON MyTable.FKCommonID = Common.CommonID;
Voilà, s'il y a des cadors ici, merci de votre aide !