Un SGBD-R permet de gérer les relations entre les éléments, et de les "enforce", c'est à dire d'en assurer l'intégrité.
 
Ainsi, on note deux systèmes de verroux de base et un personnalisable.
 
Les verroux de base.
Il s'agit des clés primaires et étrangères.
Pour ce qui est de la clé primaire, lorsqu'un champ (ou un tuple de champs) est spécifié comme clé primaire, alors le moteur de la base de données va interdire que ce tuple prennent plusieurs fois la même valeur.
Et niveau clé étrangère, cette fois le SGBD va s'assurer avant l'insertion de valeur dans ce tuple, que ces valeurs existent déjà dans la table de référence.
 
Ces deux systèmes de base permettent de s'assurer par exemple que deux clients n'auront pas le même numéro de client, ou qu'on ne pourra pas associer un produit qui n'existe pas à une commande.
 
Les verroux personnalisables.
Il s'agit des triggers. Plus que des verroux, un trigger permet de faire à peut près n'importe quelle action sur une action spécifique, sur un objet spécifique. Ainsi, on pourra par exemple se servir d'un trigger pour mettre à jour le prix total d'une commande lorsque la quantité d'un produit change. Etant des calculs évolués, cela permet au SGBD de se comporter exactement comme vous l'entendez.
 
Ces méthodes permettent de mettre en application les méthodes d'analyse tels que Merise, et d'assurer, au sein du stockage des données, l'intégralité et la cohérence de ces dernières.
 
 
Sur le papier, tout ça c'est très bien... Mais... Oui, il y a un mais...
 
Regardons ce qu'il se passe sur une clé primaire.
-> Lorsqu'on ajoute une valeur, le SGBD va en premier rechercher la présence de cette valeur dans la table, puis l'insérer si elle n'existe pas. PUIS, étant donné qu'une clé primaire est systématiquement associée à un index unique, elle va vérifier l'existance de cet élément dans l'index unique, et l'ajouter si elle n'existe pas (ce qui est forcément le cas si on est allé jusque là).
 
Ca fait pas mal de trucs... Voyons voir ce que ça donne si on supprime cette contrainte, et qu'on ne garde que l'index unique.
-> Recherche de la valeur dans l'index. Si elle n'existe pas, insertion de la donnée, mise à jour de l'index, sinon, erreur.
On a fait 2 traîtements de moins.
 
=> Il ne faut pas utiliser de clé primaire sur une table. Un index unique suffit, et offre le même résultat en un temps plus rapide.
Deplus, les clé alternatives n'existant que rarement dans les SGBD, elles sont habituellement traîtées de cette façon, alors qu'il n'y a pas de raison de les différencier.
 
Maintenant, penchons-nous sur la clé étrangère.
-> Lorsque j'insère une donnée dans la table "fille", je regarde si la donnée liée existe dans la table mère. Si elle existe, j'insère ma ligne, et si elle n'existe pas, je fait une erreur. Ceci peut prendre pas mal de temps si la table mère contient beaucoup de données, ou que le tuple servant de lien est gros.
Lorsque je supprime une donnée de la table "mère", je regarde si des données de la table fille y font référence. Si oui, alors je plante, sinon je supprime la ligne. Ceci est encore plus lent, puisque très généralement il y a plus de filles que de mères. Sans compter le fait que du côté mère, ce champ est forcément unique, tandis que côté fille, il ne l'est pas.
 
Quand j'ai un programme qui me permet de remplir un formulaire ou les données de la table mère sont listées dans une dropdown list, quel est l'intérêt d'aller vérifier qu'elle existent dans la table mère au moment de l'insertion ? Aucun, puisque ces données existes forcément !
Et dans un traîtement de suppression d'une donnée de référence, pour éviter de planter si des données existent dans la table fille, on va de toute façon nettoyer cette dernière en premier. Ainsi, au moment du delete sur la table mère, on est certains qu'il ne peut pas y avoir de filles, vu qu'on vient de toutes les effacer. A nouveau, aucun intérêt.
 
=> Les clé étrangères ne servent donc à rien, et c'est au programme de s'assurer de l'intégrité des données lors de ces accès à la base. Il vaut donc mieu éviter de les utiliser, afin d'économiser les traîtements inutiles.
 
A noter deplus le problème du CASCADE CONSTRAINTS. Cette fabuleuse commande permet de supprimer une mère et toutes ses filles en une ligne.
Elle a aussi la formidable capacité à vider la moitiée des tables de la base en une seconde si on écrit mal la requête... Dans ce cas, le segment de rollback étant sous-dimensionné, ça plante, et on ne peut plus faire rollback. La catastrophe. Sans clé étrangère, aucun risque, le CASCADE CONSTRAINTS ne retrouvant pas de cheminement entre les table, ne pourra faire aucun dégat.
 
-> Les triggers. Un trigger s'éxécute sur différents évèments et différentes actions sur différents objets. Un trigger est généralement utilisé sur une table (mais ça peut aussi bien être sur une vue pour les SGBD récents), avant ou après la modification de la table, sur une insertion, une suppression ou/et une mise à jour.
L'éxécution du trigger sera systématique lorsqu'un tel traîtement aura lieu sur son l'objet qu'il surveille. Ainsi, si un trigger s'occupe de mettre à jour le montant d'une commande en fonction des produits qui y sont rattachés, la moindre modification d'un libellé d'un produit dans la liste va déclencher le calcul, même si aucune quantité ni prix n'a été modifié.
 
-> Un trigger fonctionne dans sa propre sous-transaction
-> Un trigger peut tout à fait déclencher d'autres triggers
-> A savoir qu'une sous-transaction fonctionne comme de la récusrivité : c'est la transaction principale qui encaisse tout. On voit rapidement que pour certains trigger un rollback segment fault risque d'arriver, avec toutes les erreurs et incohérences que cela peut engendrer.
-> Un trigger, étant écrit à la main, ne peut pas bénéficier des optimisation des PK et FK (qui sont en réalité des triggers automatiques), et se contenteront d'utiliser du code SQL et dérivés (PL/SQL ou T-SQL pour ne citer qu'eux), ce qui risque rapidement de prendre du temps.
 
=> La plus part des traîtements par trigger peuvent être évités en faisant attention à ce qu'on fait au niveau du programme qui utilise la base de données. Le calcul d'un total d'une commande notamment, n'a rien à faire dans la base, il a sa place dans le programme, d'autant plus que c'est plus évident de modifier un programme pour y rajouter des frais de port ou la TVA que dans un trigger...
 
En bref, les triggers sont à éviter autant que possible. Les seuls qui sont vraiment acceptables, sont ceux qui vont s'occuper de générer un identifiant (pour les bases qui n'ont pas de fonction native).
 
On crééra alors un trigger "on before insert" qui s'occupera d'aller récupérer la valeur d'une séquence par exemple. Sorti de ça, les tests comme exclusion de champs, surtout lorsque le trigger se lève sur un traîtement fréquent, et lorsque ses traîtements sont longs, doivent impérativement déportés dans l'application.
 
 
Voilà. C'était juste parceque j'avais rien à faire et que j'ai pas de question à poser, et y'a pas de réponse auxquelles répondre, donc j'étalle ma science, ça peu toujours servir si un jour une personne se pose la question  

Grossomodo :
-> Faire les filtres les filtres et les jointures regroupés table par table.
-> Toujours faire les jointures avant les filtres (sauf pour la première, qui n'est pas fille d'une jointure)
-> Pour les jointures, réutiliser les tables qui contiennent le moins de données possibles, même si au niveau du modèle ça ne correspond pas aux relations qu'on a fait.
 
Exemple :
 
PROPRIETAIRE
----
UID
NOM
PRENOM
PERMIS_ID
 
 
ADRESSE
------
AID
NUMERO
RUE
VILLE
CP
PAYS
TYPE
PROPRIETAIRE_ID
 
VOITURE
-------
IMMATRICULATION
PROPRIETAIRE_ID
 
Maintenant, le problème est :
 
Retrouver l'adresse de résidence principaledu conducteur de la voiture immatriculée 1234AB56 (histoire de lui envoyer un PV par exemple)
 
Tu commences par le filtre le plus restrictif, donc ici, l'imatriculation, puisque c'est un identifiant (une ligne retournée)
 
where v.immatriculation = '1234AB56'
 
Ensuite, tu ne vas pas t'amuser à lier les utilisateurs aux adresses, sinon tu vas te retrouver avec un nombre incalculable de lignes - autant qu'il y a d'adresse dans la base -, qui devront être filtrées au moment de la jointure (perte de temps).  
 
Donc tu commences par retrouver le conducteur.
 
and p.uid = v.proprietaire_id
 
Puis, tu vas chercher les adresses du conducteur (NON, ne fait pas le filtre sur le type d'adresse AVANT, sinon tu vas filtrer les adresses habitation de TOUS les propriétaires. Donc à nouveau, trop de lignes. Tu vas donc chercher la liste des adresses du conducteur, qui représentent beaucoup moins de lignes.
 
and a.PROPRIETAIRE_ID = u.UID
 
Et enfin (et seulement maintenant) tu vas filtrer le type d'adresse.
 
and a.type = 'PRINCIPALE'
 
Ensuite, dans le FROM, il faut mettre les tables dans l'ordre inverse de leur position dans la requête.
 
Truc à bien garder en tête aussi :
 
and a.PROPRIETAIRE_ID = u.UID
 
est différent de  
 
and u.UID = a.PROPRIETAIRE_ID
 
En effet, le second va recherche tous les UID qui sont présents dans les adresses, et ensuite va filter pour retrouver les UID qui connerspondent aux précédents critères. Alors que le premier va rechercher les adresses qui correspondent uniquement aux prorpiétaires déjà filtrés.
 
Le requête est donc :
 
SELECT p.NOM, p.PRENOM, a.NUMERO, a.RUE, a.CP, a.VILLE, a.PAYS
FROM adresse a, proprietaire p, voiture v
WHERE v.immatriculation = '1234AB56'
AND p.uid = v.proprietaire_id
AND a.PROPRIETAIRE_ID = u.UID
AND a.type = 'PRINCIPALE'
 
Et non pas un truc monstrueux genre :
 
SELECT p.NOM, p.PRENOM, a.NUMERO, a.RUE, a.CP, a.VILLE, a.PAYS
FROM proprietaire p, voiture v, adresse a
WHERE a.PROPRIETAIRE_ID = v.PROPRIETAIRE_ID
AND a.PROPRIETAIRE = p.UID
AND a.TYPE = 'PRINCIPALE'
and v.IMMATRICULATION = '1234AB56'
 
La seconde est tout ce qu'il y a de plus immonde  
... mais elle fonctionne aussi (c'est bien ça le problème...)

...
il ne faut pas faire une BASE, ni même une TABLE par utilsateur crée
...
 
... peut on faire une table sans clé ?
--> Non
 
...
il se peut qu'une table n'aie aucun lien avec les autres (par exemple les logs)  
mais pourquoi la mettre dans une autre base ? ça n'apporte rien, si ce n'est du travail supplémentaire