Supprimer les doublons dans une table

Version imprimable

Bonjour à toutes et à tous,

Je dispose d'une table dont les données proviennent d'un formulaire.
Ce formulaire est complété par des tiers personnes.

Cette table sera susceptible de disposer de doublons.
J'aimerai créer un petit programme pour supprimer les doublons de cette table.

Je ne dispose pas encore d'un grand niveau en SQL du coup ce qui pourrait être simple et laborieux pour moi actuellement.

Je suis tombé sur un morceau de code que j'ai agrémenter à ma sauce mais, bien évidemment, cela ne marche pas :aie::ptdr:
Code:

1 2 3 4 5 6 7 8 <?php //Je vais supprimer les doublons SELECT COUNT(*) AS nbr_doublon, avis_clients_email, avis_clients_produits, avis_clients_commentaire FROM avis_clients_valides WHERE avis_clients_validation_webmaster ="N" GROUP BY avis_clients_email, avis_clients_produits, avis_clients_commentaire HAVING COUNT(*) > 1 ?>
Ce code me renvoie l'erreur suivante :
Parse error: syntax error, unexpected identifier "COUNT"

J'imagine que :
Soit COUNT devait être déterminé avant
Soit il y a une autre manière d'écrire ce morceau de code (oui j'ai encore un peu de mal à ce niveau la, je vois pas mal de façon de procéder pour écrire les instructions et je m'y perds encore un peu).

L'idée ici est de parcourir la table est :
1 - Si le commentaire n'a pas été validé par le webmaster
2 - Alors je vérifie si j'ai des lignes en doublon dont les champs email produit et commentaire sont strictement identiques
3 - Si oui, je supprime la ligne de ma table
3 - Si non je ne fais rien
1 - Si le commentaire a déjà été validé, je ne regarde pas cette ligne

D'avance merci pour votre aide :D

Je ne remarque rien pouvant expliquer l'erreur dans ta requête que j'aurais plutôt écrite comme ceci:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 SELECT count(1) AS nbr_doublon, avis_clients_email, avis_clients_produits, avis_clients_commentaire FROM avis_clients_valides WHERE avis_clients_validation_webmaster = "N" GROUP BY avis_clients_email, avis_clients_produits, avis_clients_commentaire HAVING nbr_doublon > 1
Par contre je ne suis pas fan de tes noms de colonnes et tables qui passent du singulier au pluriel et du pluriel au singulier, c'est un coup à se planter. Peut-être une erreur à ce niveau là?

PS: il est possible de créer une contrainte d'unicité sur plusieurs colonnes pour une table, empêchant de fait les doublons de se produire.

12/02/2025, 13h04
mathieu

vous avez mélangé du code php et requête sql. regardez le code que vous nous avez montré là :
https://www.developpez.net/forums/d2.../#post12068856

pour les requêtes sql complexes, je vous conseille de les tester d'abord dans un outil comme phpmyadmin. vous verrez mieux le résultat et cela vous aidera à exploiter le résultat dans votre code php.
12/02/2025, 13h31
BOU59000

Merci à vous pour vos réponses.

J'ai vérifié mes composantes et elles sont correctes.
L'erreur vient bien du code.

Oui tu as raison, il sera nécessaire que je trouve une manière d'écrire plus cohérente car avec des codes plus complexes... ça devient complexe sans une vraie organisation.

J'ai encore effectivement du mal à séparer le code PHP et SQL.
Et beaucoup de mal avec le code SQL (il existe différentes manière et je suis un peu perdu).
Je te remercie pour la piste que tu m'as donné, je veux bien un autre indice si possible ? :oops:
12/02/2025, 16h38
escartefigue

Bonjour,

L'usage est de nommer les tables au singulier, par exemple "avis_client_valide" plutôt que "avis_clients_valides", car une table est la version physique d'un type d'entité ou classe d'entité au niveau conceptuel, et l'on se doute bien qu'une table contient potentiellement plusieurs occurrences de l'entité.
Il en va de même pour les colonnes, là c'est parce qu'une occurrence de colonne n'est sensée contenir qu'une seule valeur.

Ensuite, détecter les doublons, c'est une chose, mais il faut ensuite choisir laquelle des lignes redondantes est à conserver.
Si les colonnes sur lesquelles le regroupement est fait sont identiques, il est fort possible que les valeurs des autres colonnes soient différentes. Peut-être faut il conserver celle des lignes dont la mise à jour est la plus récente, peut-être la plus ancienne, peut-être est-ce un autre critère qui fait foi.
Donc attention, un programme ne saura peut-être pas toujours laquelle des lignes il faut conserver, si le volume est modeste, une sélection manuelle est possiblement préférable.
12/02/2025, 21h04
BOU59000

Merci pour vos retours

Je prends note pour l'usage qui est fait pour les tables ainsi que les colonnes.
Merci :D

Je suis d'accord pour les autres colonnes qui pourraient être différentes.
Dans le cas présent, les informations des autres colonnes ont moins d'importance pour l'usage que je veux en faire.
Du coup, le programme pourra conserver 1 ligne (par exemple la plus récente) et supprimer toutes les autres occurrences.

Citation:

Envoyé par mathieu

vous avez mélangé du code php et requête sql. regardez le code que vous nous avez montré là :
https://www.developpez.net/forums/d2.../#post12068856

pour les requêtes sql complexes, je vous conseille de les tester d'abord dans un outil comme phpmyadmin. vous verrez mieux le résultat et cela vous aidera à exploiter le résultat dans votre code php.

Comme je l'ai dis, j'ai beaucoup de mal avec le lien PHP/MySQL, je vois encore très peu comment les faire communiquer entre eux.
En suivant ton indice, j'imagine que le premier morceau pour les faire communiquer entre eux ressemble à cela :
Code:

1 2 3 4 $Programme=$acces_bdd->prepare('SELECT count(1) AS nbr_doublon, avis_clients_email, avis_clients_email, avis_clients_commentaire FROM avis_clients_valides WHERE avis_clients_validation_webmaster = "N" GROUP BY avis_clients_email, avis_clients_produits, avis_clients_commentaire HAVING nbr_doublon > 1');
Si je ne dis pas de bêtise, ce résultat (que je ne sais pas comment traiter en couple php/mySql) va me renvoyer une copie de ma table complète en prenant soin de retirer les doublons.
C'est bien cela ?

Si oui, cela veut dire que je dois :
. Soit stocker toutes ces données dans un tableau temporaire, vider ma table "avis_clients_valides" et réinscrire toutes les données de mon tableau temporaire dans ma table
. Soit avoir une table vierge à côté ou je colle ces données, puis je vide ma table principale, je colle mes données de la table 'vierge' dans ma table principale et enfin je vide ma table 'vierge'
Si c'est bien cela ? C'est préférable de ne pas avoir une trop grosse quantité de données pour faire cela. J'imagine alors (si mon cheminement est correct, qu'il existe des solutions plus efficaces que cela)

« Si le seul outil que vous avez est un marteau, vous tendez à voir tout problème comme un clou » Abraham Maslow...

Partant de la, voilà la solution "Mc Gyver" à laquelle j'ai pensé... :ptdr:

Code:

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
//Je vais supprimer les doublons	
		//Je compte le nombre de ligne de dépat dans ma table
			//Accès à la table
			$acces_bdd = $acces_bdd -> query('SELECT * FROM avis_clients_valides'); 
			$_nombre_initial_lignes = 0;
			while ($Ma_Recherche = $acces_bdd -> fetch())
			{
				$_nombre_initial_lignes = $_nombre_initial_lignes + 1; //Cela me servira de ligne de fin pour ma seconde boucle
			}
 
		//Je vais vérifer la ligne parcouru actuellement par mon while avec toutes les autres lignes de la table pour trouver les occurences
			//Accès à la table
			$acces_bdd = $acces_bdd-> query('SELECT * FROM avis_clients_valides'); 
			$_ligne_actuel_while = 0;
			$_lignes_supprimees = 0; // Ceci me permettra de mettre à niveau ma ligne de fin de ma seconde boucle, au plus je supprime, au moins il reste de ligne... 
			while ($Ma_Recherche = $acces_bdd -> fetch())
			{
				$_ligne_actuel_while = $_ligne_actuel_while + 1; //Ma ligne actuelle du while est ma ligne de départ de ma seconde boucle
				for($ligne = $_ligne_actuel_while; $ligne<=($_nombre_initial_lignes-$_lignes_supprimees);$ligne++)
				{
					if($Ma_Recherche['avis_clients_validation_webmaster']=="N") //Je ne touche pas aux lignes validées par le webmaster
					{
						//Je vais demander ici à ce que mes trois lignes correspondent à la ligne en cours => occurence
						if($Ma_Recherche['avis_clients_email']==$Ma_Recherche[$ligne]['avis_clients_email'] AND Ma_Recherche['avis_clients_produits']==$Ma_Recherche[$ligne]['avis_clients_produits'] AND    Ma_Recherche['avis_clients_commentaire']==$Ma_Recherche[$ligne]['avis_clients_commentaire'])
						{
							echo '<p>je decouvre un N -ID:'.$Ma_Recherche['id'].' while :'.$_ligne_actuel_while.'For :'.$ligne.'</p>';
							//J'insère ici la requete pour supprimer la ligne + j'incremente mon compteur $_lignes_supprimees
						}
					}
				}
			}

Et comme disait ma prof de Maths... c'est en forgeant qu'on devient forgeron et...
Je dois encore m'améliorer avec le marteau :ptdr:
La ligne suivante ne passe pas :

Code:

1
2
if($Ma_Recherche['avis_clients_email']==$Ma_Recherche[$ligne]['avis_clients_email'] AND Ma_Recherche['avis_clients_produits']==$Ma_Recherche[$ligne]['avis_clients_produits'] AND Ma_Recherche['avis_clients_commentaire']==$Ma_Recherche[$ligne]['avis_clients_commentaire'])
Fatal error: Uncaught TypeError: Cannot access offset of type string on string in

Question :
Sur cette dernière ligne :
. est-ce une erreur d'écriture de ma part ? Si oui comment aurais-je du l'écrire ?
. si ce n'est pas une erreur de ma part, cela veut dire que mon idée de détourner mon "problème" SQL est seulement un mirage ?

D'avance merci pour vos retours et commentaire qui m'aident à résoudre mon problème mais aussi à comprendre et à m'améliorer

PS: J'avais bien pris en compte la remarque d'amélioration pour le nom des tables / colonnes. Je n'ai pas fait de modification ici afin de rester constant sur les différents paramètres de la problématique exposée initialement

1 pièce(s) jointe(s)

une démarche possible est de détecter les doublons, puis, de faire la liste des valeurs trouvées pour les lignes ayant des doublons.

Voici un exemple créé sous db<>fiddle dans lequel j'ai une table des personnes (identitifiant, nom, prénom, date de naissance, code, date de dernière màj)
Pour le test, je considère qu'il y a doublon si nom+prénom+ddn sont identiques (dans la vraie vie c'est très insuffisant ;))
Et pour chaque doublon, j'utilise la fonction GROUP_CONCAT pour lister les valeurs trouvées dans les autres colonnes, par ordre de date de mise à jour

La requête :

Code:

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
create table T1
      (  T1IDT   integer       primary key
       , T1NOM   varchar(50)   not null
       , T1PRN   varchar(50)   not null
       , T1DDN   date          not null
       , T1CD1   char(2)       not null
       , T1MAJ   date          not null
      )
;
insert into T1
values (001, 'Dupont', 'Micheline', '1935-02-16', 'XX', '2021-06-05')
     , (002, 'Martin', 'Louis', '1968-11-20', 'AB', '2020-01-10')
     , (003, 'Volfoni', 'Raoul', '1916-01-01', 'VA', '1995-12-21')
     , (004, 'Martin', 'Louis', '1968-11-20', 'ZZ', '2024-07-01')
     , (005, 'Lesage', 'Sidonie', '1996-05-04', 'U5', '2024-10-30')
     , (006, 'Volfoni', 'Raoul', '1916-01-01', 'VX', '1995-12-22')
     , (008, 'Volfoni', 'Raoul', '1916-01-01', 'X8', '2025-02-01')
     , (009, 'Abadie', 'Isabelle', '1998-02-20', 'BO', '2025-01-06')
;
-- considérons qu'il y a doublon si même nom, prénom et date de naissance
with dbl (dblnom, dblprn, dblddn, dblcnt) as
    (select T1NOM
          , T1PRN
          , T1DDN
          , count(*)
     from T1
     group by T1NOM
            , T1PRN
            , T1DDN
     having count(*) > 1 
    )
select dblnom
     , dblprn
     , dblddn
     , dblcnt
     , GROUP_CONCAT(concat(T1MAJ,' : ', T1IDT, '-', T1CD1)
                    order by T1MAJ asc
                    separator ", ") as "Dtmaj : ident - Code"
from dbl
inner join T1
   on T1NOM = dblnom
  and T1PRN = dblprn
  and T1DDN = dblddn
group by dblnom
       , dblprn
       , dblddn
       , dblcnt

Le résultat :

Pièce jointe 664468

On n'affiche bien que les lignes présentant des doublons (Martin et Volfoni)

À partir de cette liste, on pourra décider de ce qu'il convient de faire. Par exemple ne conserver que les lignes dont la date de dernière MàJ est la plus récente.

Une manière d'éviter les doublons avec une contrainte: un exemple avec des clients qui commentent des produits.

Il s'agit d'éviter qu'un même client fasse plusieurs fois le même commentaire sur un même produit, typiquement:

Le mécontent bien décidé à montrer sa rage à la face du monde
Le trop enthousiaste
L'amnésique
Celui qui veut remonter la file des commentaires

Les tables:

Code:

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
CREATE TABLE IF NOT EXISTS t_client (
   cli_id INTEGER NOT NULL auto_increment,
   cli_name VARCHAR(100) NOT NULL,
   cli_forname VARCHAR(100) NOT NULL,
   cli_mail VARCHAR(255) NOT NULL,
 
   PRIMARY KEY pk_cli_id (cli_id)
) ENGINE = InnoDB;
 
CREATE TABLE IF NOT EXISTS t_product (
   pro_id INTEGER NOT NULL auto_increment,
   pro_name VARCHAR(255) NOT NULL,
   pro_description TEXT,
 
   PRIMARY KEY pk_pro_id (pro_id)
) ENGINE = InnoDB;
 
CREATE TABLE IF NOT EXISTS t_comment (
  com_id INTEGER NOT NULL auto_increment,
  cli_id INTEGER NOT NULL,
  pro_id INTEGER NOT NULL,
  com_comment VARCHAR(2048) NOT NULL,
  com_print BINARY(16)
    GENERATED ALWAYS AS (unhex(md5(com_comment))) STORED,
  com_date DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
  com_valid BIT NOT NULL DEFAULT 0,
 
  PRIMARY KEY pk_com_id (com_id),
 
  FOREIGN KEY fk_cli_id (cli_id)
    REFERENCES t_client (cli_id)
    ON DELETE CASCADE
    ON UPDATE CASCADE,
 
  FOREIGN KEY fk_pro_id (pro_id)
    REFERENCES t_product (pro_id)
    ON DELETE CASCADE
    ON UPDATE CASCADE,
 
  UNIQUE uc_cli_id_pro_id_com_print (cli_id, pro_id, com_print)
) ENGINE = InnoDB;

Dans la table t_comment, j'ai ajouté une contrainte d'unicité sur les colonnes cli_id (l'id du client), pro_id (l'id du produit) et com_print (l'empreinte du commentaire). La colonne com_print est générée automatiquement lors de l'insertion à partir de la colonne com_comment, il s'agit de l'empreinte md5 du commentaire. La raison pour laquelle je ne prends pas le commentaire lui-même mais son empreinte md5, est que cette dernière a une taille fixe de 32 octets (quelque soit la taille du commentaire correspondant) et qu'une contrainte d'unicité est limitée en taille (ce qui ne collerait pas avec le VARCHAR(2048) du commentaire).

Les données (avec des commentaires redondants du même client pour un même produit):

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
INSERT INTO t_client (cli_name, cli_forname, cli_mail)
VALUES ('Goudard', 'Micheline', 'micheline.goudard@youpi.net'),
       ('Langlois', 'Maurice', 'maurice.langlois@bidule.org'),
       ('Picard', 'Huguette', 'huguette.picard@ouanadou.fr'),
       ('Jambier', 'Lucien', 'legroslulu@frit.fr');
 
INSERT INTO t_product (pro_name, pro_description)
VALUES ('aspirateur traîneau', 'conception germanique, assemblé en Turquie, il est l''outil idéal contre la poussière'),
       ('mixeur plongeant', 'devenez le roi de la soupe'),
       ('four à pyrolyse', 'Avec son mode tourne-broche, réussissez vos poulets rôtis comme personne');
 
INSERT IGNORE INTO t_comment (cli_id, pro_id, com_comment, com_valid)
VALUES (4, 3, 'Je mange du poulet tous les jours', 1),
       (4, 3, 'Je mange du poulet tous les jours', 0),
       (1, 2, 'La notice papier n''est pas fournie', 0),
       (4, 3, 'Désormais, je mange du poulet tous les jours', 0),
       (2, 1, 'Je n''aime pas faire le ménage', 1),
       (2, 1, 'Je n''aime pas faire le ménage', 0),
       (2, 1, 'Je n''aime pas faire le ménage', 0),
       (3, 1, 'Je n''aime pas faire le ménage', 0),
       (3, 1, 'Il est relativement bruyant', 1),
       (2, 2, 'L''appareil chauffe vite', 1);

On regarde le résultat:

Code:

1
2
3
4
5
6
7
8
9
SELECT
  t_product.pro_name as produit,
  t_comment.com_comment as avis,
  concat(t_client.cli_forname, ' ', t_client.cli_name) as client,
  if (t_comment.com_valid, 'oui', 'non') as 'validé'
FROM t_comment
JOIN t_client ON t_comment.cli_id = t_client.cli_id
JOIN t_product ON t_comment.pro_id = t_product.pro_id
ORDER BY t_product.pro_name, t_comment.com_date DESC;

démo

15/02/2025, 10h33
escartefigue
Les contraintes d'unicité sont en effet la meilleure façon d'éviter les doublons.

Quelques remarques à ce sujet :
- une contrainte d'unicité est une règle de gestion, elle doit donc être rédigée en tant que telle et modélisée dès l'étape conceptuelle (MCD) pour apparaitre clairement. Cette contrainte sera automatiquement générée dans le modèle tabulaire avec tout bon logiciel de modélisation ;
- pour rappel, une contrainte primary key est implicitement une contrainte d'unicité ;
- quand il y a déjà des doublons, c'est soit qu'il n'y a jamais eu de contrainte, soit qu'on l'a supprimée. Il est nécessaire de supprimer les doublons avant de réactiver ou d'installer la contrainte.
19/02/2025, 09h46
BOU59000

Bonjour,

Merci pour vos retours.

Désolé j'ai été assez occupé ces derniers jours.
Je règle un autre petit soucis en premier puis je reviens lire vos messages pour test/ mis en application (et progression en langage par la même occasion :D)
09/03/2025, 09h03
BOU59000

Bonjour,

Suite à vos retours, j'ai mis un peu de temps afin de déterminer quelle approche je devais aborder afin de régler ce problème.
A noter que c'est grâce à vos retours et réflexions que j'ai pu aboutir à ma conclusion actuelle :king:

L'approche que j'ai choisi n'est pas la meilleure approche, c'est juste l'approche à ma portée suivant mon niveau de connaissances actuelles et le temps que je peux y accorder (il y a de nombreux sujets sur lesquels je dois progresser et je ne peux pas tout faire en même temps).

Je suis donc parti sur un mixte entre :
. Effacer 'manuellement' les lignes (au travers d'une interface quand même, faut pas déconner :ptdr:
. Ralentir les 'rageux' => utilisation d'une SESSION['Tu_as_posté___j'ai_ton_message____faut_attendre_pour_en_poster_un_autre'] =>
Avantage : Cela permet d'éviter de surcharger ma table pour rien, et aussi de m'éviter de devoir effacer manuellement 50 fois le même message
Inconvénient : La personne qui s'est trompée dans son message et souhaite en renvoyer un autre... devra attendre avant de poster de nouveau son message.

La solution n'est donc pas idéale mais me parait être un bon compromis en l'état.

J'ai placé dans mes pistes de progression perso de la partie Base de Données. (Elle commence à devenir longue ma liste :aie:)

Un grand merci à tous pour vos retours :D