Discussion :

[Djakisback]

Bonjour,
voilà je bloque sur le problème suivant qui me semble assez complexe. Le but est de générer automatiquement une condition SQL valide de type "FROM xxxx INNER JOIN xxxx ON xxxx.xx = xxxxx.xx", etc à partir de différentes définitions de clés étrangères et de leurs clés primaires associées.

Pour l'exemple je stocke les liaisons de tables (clés primaires / clés étrangères) dans un tableau, mettons que j'aie les 3 clés étrangères suivantes :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
foreignKeys[0]['name'] = 'id_user';
foreignKeys[0]['table'] = 'own';
foreignKeys[0]['primaryKeyName'] = 'id';
foreignKeys[0]['primaryKeyTableName'] = 'users';
 
foreignKeys[1]['name'] = 'id_user';
foreignKeys[1]['table'] = 'cards';
foreignKeys[1]['primaryKeyName'] = 'id';
foreignKeys[1]['primaryKeyTableName'] = 'users';
 
foreignKeys[2]['name'] = 'id_appt';
foreignKeys[2]['table'] = 'own';
foreignKeys[2]['primaryKeyName'] = 'id';
foreignKeys[2]['primaryKeyTableName'] = 'appts';

Pour ces tables SQL :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
USERS
id

OWN
#id_user
#id_appt

APPTS
id

CARDS
id
#id_user

Je voudrais pouvoir aboutir à une requête du type :

Code :

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

1
2
3
4
FROM users
	INNER JOIN own ON own.id_user = users.id 
	INNER JOIN appts ON appts.id = own.id_appt   
 	INNER JOIN cards ON cards.id_user = users.id

Mais il a y 2 problèmes qui se posent dûs à la syntaxe SQL :
1) un nom de table ne peut apparaître qu'une seule fois dans la requête, ceci ne fonctionne pas :
INNER JOIN own ON own.id_user = users.id
INNER JOIN own ON appts.id = own.id_appt

2) on ne peut utiliser une clé que si sa table a déjà été nommée, ex, ceci ne fonctionne pas :
FROM appts
INNER JOIN cards ON cards.id_user = users.id
INNER JOIN own ON own.id_appt = appts.id
INNER JOIN users ON own.id_user = users.id

Les index numériques du tableau foreignKeys sont censés ne pas avoir d'importance. Je suis parti dans l'idée de trier le tableau multi pour ensuite n'avoir plus qu'à le parcourir en construisant la chaîne (sans tests) mais je ne crois pas que cela soit possible sans tests.

Voilà, je ne suis pas sûr que le tableau soit la bonne structure de données pour stocker les liaisons. Si quelqu'un a une idée quelconque, je lui en serais reconnaissant
Merci d'avance.

[ALWEBER]

Une idée très intuitive consiterai à partir des formes normales de Boyce-Codd en phase de normalisation en respectant quelques règles comme celui de donner à chaque champ composant la clef Primaire de chaque table un nom unique dans le dictionnaire des données. Et d'autre part de classer ces tables dans l'ordre (?inverse) de la normalisation.
Ce type d'automatisme peut très bien fonctionner si le modèle relationnel a été conçu de manière rigoureuse.
Accompagne toujours tes foreignKeys d'index. Les temps de réponse et de vérification d'intégrité référentielle seront améliorés

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
USERS
id_user
 
OWN
#id_user
#id_appt
 
APPTS
id_appt
 
CARDS
id_cards
#id_user

[Djakisback]

Salut,
merci pour ta réponse et ta piste .
Après recherches et essais je n'arrive pas à voir où tu veux en venir, notamment en parlant d'"ordre" de normalisation en BCNF. Pourrais-tu m'aiguiller un peu plus dans l'idée ?

[ALWEBER]

Ci joint document sur les formes normales comprenant deux images de modèles physiques de données.
Le modèle physique de données représente un graphe dont les sommets sont les tables et les arêtes sont les liaisons
Donc le probleme se résume à un parcours de graphe en cherchant le plus petit chemin d'un point à un autre.

[Djakisback]

Je connais pas les graphes, je vais me renseigner là-dessus.
Merci pour ton aide

[ALWEBER]

Tu peux aller voir sur ce lien
http://ploug.eu.org/doc/cours-graphe...ithme-cnam.pdf
Il y a aussi sur le web des exemple en delphi de tels algorithmes.

[Djakisback]

Merci pour lien très instructif ^^

J'ai donc apparemment résolu mon problème (non sans galérer ^^).
Finalement, je trie simplement les sommets (tables) par nombre d'arêtes (liaisons) croissant. Et ensuite j'utilise une variable temporaire pour définir quelles tables ont déjà été utilisées. Si l'une des 2 tables d'une liaison a déjà été utilisée je prends l'autre.

(j'espère que cela fonctionne dans tous les cas, dans le cadre d'un MPD je ne pense pas que l'algo puisse arriver à épuisement des tables)
Bye