Discussion :

[Lekno]

Bonjour à tous, je souhaite mettre en place une petite base de donnés avec la correspondance de synonymes, pour l'instant je compte procéder comme ci-dessous avec deux tables, j'ai également essayé d'écrire une ébauche de requête SQL afin de séléctionner mes synonymes, sauriez vous m'indiquer si cela est correct, et optimisé ?

Je suis relativement novice en SQL, si quelque chose vous choque signalez moi, je souhaiterai être sur de mon affaire avant de lancer la "moulinette"

Merci par avance à ceux qui sauront m'indiquer mes erreurs !

        TABLE				TABLE		
	Dictionnaire				synonymes		
							
id_mot	INT	AI		    id_mot	        INT		
synonyme	VARCHAR(50)	    id_synonyme	INT

Code sql :

Sélectionner tout - Visualiser dans une fenêtre à part

SELECT * FROM dictionnaire, synonymes WHERE dictionnaire.id_mot = synonymes.id_mot ODER BY synonyme

[Spartacusply]

C'est cohérent, c'est déjà bien, mais disons que l'ensemble est améliorable. Il faudra bien prendre en compte la transversalité du système : si a est synonyme de b, est-ce que b est toujours un synonyme de a ? (il me semble que oui mais c'est à réfléchir). Si tu appliques cette contrainte, alors le couple id_mot => id_synonyme se transforme en id_mot <=> id_synonyme, et bien que cela ne change pas tes tables, cela changera tes requêtes SQL.

D'autre part, en SQL, il faut privilégier pour des raisons de performances et de lisibilité de lier les tables entre elles avec le mot clef JOIN plutôt qu'avec des where qui sont là pour créer des conditions de sélection mais pas de jointure.

Autre chose, pense à différencier de manière visuelle les clefs primaires des clefs étrangères (par exemple, tu peux notés les clefs primaires comme ceci : id_nomdelatable et les clefs étrangères comme cela : nomdelatable_id).

[Dendrite]

Très amusant, ton problème.
Ceci dit, ta modélisation me paraît beaucoup trop réductrice.
Chaque mot est en lui-même un synonyme de 0 à n autres mots, et vice versa... et puis tout l'intérêt des synonymes, c'est que souvent, ce n'est pas de la pure redondance, mais qu'il y a des nuances entre eux.

Un autre problème, que fais-tu des homonymes ? 'son' par exemple (céréale ou bien bruit ou bien adjectif possessif) ?

Et je ne comprends pas bien comment tu comptes alimenter ta base ? Toi-même, à la main ?

Si oui, bon courage, mais moi, je vois plutôt ce genre de base, tu remplirais deux tables, et le reste coulerait de source :

mot (id, libelle, definition)
1, 'gentil','qui est tourné vers les autres'
2, 'aimable', 'qui est tourné vers les autres'
3, 'sympathique', 'qui est tourné vers les autres'
4, 'empathique', 'qui vibre avec les autres'
5, 'sympa', 'qui est tourné vers les autres, familier'
6, 'bon', 'qui aide les autres'

correspondance(id, mot_id)

Ici, il faut un moteur innoDb et une clé étrangère sur mot_id

1, 1
1, 2
1, 3
1, 4
1, 5
1, 6

Code SQL :

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
 
/*Une vue donnerait la chose suivante*/
 
create or replace view v_synonymes as
select 
correspondance.id as synonym,
correspondance.mot_id,
mot.libelle, 
mot.definition
from correspondance
inner join mot on correspondance.mot_id=mot.id
 
 
/*Et ta requête finale donnerait*/
 
select * from v_synonymes
where synonym=(
   select synonym
   from v_synonymes
   where libelle="sympathique"
)
order by libelle;
 
/*et tu règlerais aussi le problème des homonymies, tu irais chercher "le bon son" par son id*/
 
select * from v_synonymes
where synonym=(
   select synonym
   from v_synonymes
   where mot_id=159
)
order by libelle;
 
/*ou bien plus lourdingue*/
 
select * from v_synonymes
where synonym=(
   select synonym
   from v_synonymes
   where libelle="son" and definition like "%bruit%"
)
order by libelle;

[Lekno]

J'ai bien pris en compte vos remarques, pour la BD pas de soucis. J'utilise actuellement du code qui va me fournir directement sous la forme ci-dessous

Mot inital 1 :
- Synonyme 1
- Synonyme 2
- Synonyme 3

Mot inital 1 :
- Synonyme 1
- Synonyme 2
- Synonyme 3

Actuellement j'ai organisé mes tables comme ceci,

Dictionnaire

Code sql :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
 
CREATE TABLE IF NOT EXISTS `dictionnaire` (
  `idDICT` int(11) NOT NULL AUTO_INCREMENT,
  `motDICT` varchar(250) NOT NULL,
  PRIMARY KEY (`idDICT`)
) ENGINE=InnoDB  DEFAULT CHARSET=latin1 AUTO_INCREMENT=5 ;

Code sql :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
 
CREATE TABLE IF NOT EXISTS `synonymes` (
  `idSYNONYME` int(11) NOT NULL AUTO_INCREMENT,
  `idDICT` int(11) DEFAULT NULL,
  `Amount` double DEFAULT NULL,
  PRIMARY KEY (`idSYNONYME`),
  KEY `idDICT` (`idDICT`)
) ENGINE=InnoDB  DEFAULT CHARSET=latin1 AUTO_INCREMENT=4 ;

J'ai lus plusieurs articles et certain conseil de passer par un "naturaal join"

Code sql :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
 
SELECT idDICT, motDICT
FROM dictionnaire NATURAL JOIN synonymes

Cela fonctionne avec un jeux de teste mais sans spécifier de mot précis, en revanche je ne comprend pas le Amount double présent dans ma table synonyme.... et surtout comment spécifier les synonymes à retourner

Code sql :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
SELECT idDICT, motDICT FROM dictionnaire NATURAL JOIN synonymes WHERE motDICT='manger'

Me retourne uniquement le mot "manger", je ne vois pas trop comment compléter ma requête afin de faire la relation

[Lekno]

Je peine sincèrement à créer ma requête de sélection,

L'utilisateur saisit un mot, et le requête me retourne automatiquement les synonymes associés, je reste actuellement sur l'ébauche de requête que je vous ai présenté ci-dessus

[patrickbaras]

tu conserve ta table dictionnaire:
tu change ta table synonymes:

Code sql :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
CREATE TABLE IF NOT EXISTS `synonymes` (
  `idSYNONYME` int(11) NOT NULL AUTO_INCREMENT,
  `idDICT` int(11) DEFAULT NULL,
  `idSyn` int(11) DEFAULT NULL,
  PRIMARY KEY (`idSYNONYME`),
  KEY `idDICT` (`idDICT`)
) ENGINE=InnoDB  DEFAULT CHARSET=latin1 AUTO_INCREMENT=1 ;

dans la colone idDICT (de la table synonymes) tu indique idDICT du mot dans ton dictionnaire et dans la colonne idSyn l'idDICT du synonyme.
par exemple dans dictionnaire tu a

idDICT	motDICT
1	       manger
2	       boire
3	       avaler
4	       se nourrir
5	       se sustenter
6	       se désaltérer
7	       se saouler

dans synonymes tu a

idSYNONYME	idDICT	idSyn
1	               1	         4             "manger" à comme synonyme "se nourrir"
2	               1	         5             "manger" à comme synonyme "se sustenter"
3	               2	         6             "boire" à comme synonyme "se désaltérer"
4	               2	         7             "boire" à comme synonyme "se saouler"

pour trouver les synonymes de "manger"

Code sql :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
SELECT 
  D2.`motDICT` as synonyme 
FROM 
  `dictionnaire` as D1
join synonymes 
   on synonymes.idDICT=D1.idDICT
join dictionnaire as D2 
   on synonymes.iDSyn = D2.idDICT
where D1.`motDICT`='manger'

ce qui donne

synonyme
se nourrir
se sustenter

[Spartacusply]

Un index sur idSyn me paraitrait également très pertinent. Au passage comparativement à la réponse de mon premier message, ce code indique que si a est synonyme de b, alors b n'est pas forcément synonyme de a.

De plus, je me répète, mais l'utilisation de clefs primaires formées différemment me paraît être un prérequis facile à appliquer si on ne veux pas se briser la tête contre un mur dès que notre bdd atteint ne serait ce que quelques tables.

[Lekno]

Merci pour ces explications, la solution correspond bien et tes explications détaillées me sont précieuses !

[Lekno]

Bonjour, je reviens vers vous dans ce sujet car j'ai une nouvelle question, sauriez vous m'indiquer la meilleur procédure pour supprimer les éventuels doublons que je peux avoir ?

Sachant que mes deux tables sont liées je ne voudrai pas suprimer uniquement les doublons de ma table dictionnaire et laisser ceux inutile dans ma table synonyme....

[patrickbaras]

tu doit d'abord effacer les références au doublons dans la table synonymes aussi bien dans idDICT que idSyn avant d'effacer le mot dans le dictionnaire

tu peux aussi regarder pour définir une "foreign key" (cléf étrangére) qui permet d'effectuer des effacements en cascade

[Lekno]

C'est bien cela, je vais me pencher sur le création de la requête je la posterai lorsqu'elle sera fonctionelle si cela peut servir. Je passe en résolu merci !