Étant donné qu'ils doivent être uniques, que dois-je nommer les FK dans une base de données MySQL?
Étant donné qu'ils doivent être uniques, que dois-je nommer les FK dans une base de données MySQL?
Réponses:
Dans MySQL, il n'est pas nécessaire de donner un nom symbolique aux contraintes de clé étrangère. Si aucun nom n'est donné, InnoDB crée automatiquement un nom unique.
Dans tous les cas, c'est la convention que j'utilise:
fk_[referencing table name]_[referenced table name]_[referencing field name]
Exemple:
CREATE TABLE users(
user_id int,
name varchar(100)
);
CREATE TABLE messages(
message_id int,
user_id int
);
ALTER TABLE messages ADD CONSTRAINT fk_messages_users_user_id
FOREIGN KEY (user_id) REFERENCES users(user_id);
J'essaie de m'en tenir aux mêmes noms de champ dans le référencement et les tables référencées, comme user_id
dans l'exemple ci-dessus. Lorsque ce n'est pas pratique, j'ajoute également le nom du champ référencé au nom de la clé étrangère.
Cette convention de dénomination me permet de "deviner" le nom symbolique simplement en regardant les définitions de table, et en plus elle garantit également des noms uniques.
member_id
~> lien vers le membre de la table, edited_id
~> clé étrangère pour l'utilisateur édité, également lien vers le membre de la table. Comment dois-je les nommer?
mon choix est différent. à mon avis, une table devrait avoir un id
champ, pas un user_id
seul, car la table est simplement appelée user
, donc:
CREATE TABLE users(
id int,
name varchar(100)
);
CREATE TABLE messages(
id int,
user_id int
);
user_id
in messages
table est un champ fk donc il doit indiquer clairement quel id est ( user_id
).
une convention de dénomination pleinement explicite, à mon avis, pourrait être:
fk_[referencing table name]_[referencing field name]_[referenced table name]_[referenced field name]
i.e.: `fk_messages_user_id_users_id`
Remarque:
ce fk pourrait être unique, car si une messages_user
table existe, le nom du champ de référence devrait être user_id
(et pas seulement id
) et le nom fk devrait être:
fk_messages_user_user_id_users_id
en d'autres termes, une convention de dénomination de clé étrangère vous garantit des noms uniques si vous utilisez également une convention de dénomination «champ référencé / référencé» (et vous pouvez choisir la vôtre, bien sûr).
$id
variable quelque part sans aucune idée de la table à laquelle elle appartient. Plus votre base de code est ancienne et plus les gens ont travaillé dessus, plus cela devient probable.
Si vous ne vous retrouvez pas à référencer les fk aussi souvent après leur création, une option est de rester simple et de laisser MySQL faire le nommage pour vous (comme Daniel Vassallo le mentionne au début de sa réponse ).
Bien que vous ne puissiez pas "deviner" de manière unique les noms des contraintes avec cette méthode, vous pouvez facilement trouver le nom de la contrainte de clé étrangère en exécutant une requête:
use information_schema;
select TABLE_NAME,COLUMN_NAME,CONSTRAINT_NAME, REFERENCED_TABLE_NAME,REFERENCED_COLUMN_NAME from KEY_COLUMN_USAGE where REFERENCED_TABLE_SCHEMA = 'your_db_schema_name' ORDER BY TABLE_NAME;
Par exemple, vous pouvez recevoir les éléments suivants de la requête:
+------------+-------------+-----------------+-----------------------+------------------------+
| TABLE_NAME | COLUMN_NAME | CONSTRAINT_NAME | REFERENCED_TABLE_NAME | REFERENCED_COLUMN_NAME |
+------------+-------------+-----------------+-----------------------+------------------------+
| note | taskid | note_ibfk_2 | task | id |
| note | userid | note_ibfk_1 | user | id |
| task | userid | task_ibfk_1 | user | id |
+------------+-------------+-----------------+-----------------------+------------------------+
Si cette étape supplémentaire n'est pas trop pour vous, vous devriez pouvoir trouver facilement le fk que vous recherchez.
fk-[referencing_table]-[referencing_field]
La raison est la combinaison de referencing_table
et referencing_field
est unique dans une base de données. De cette façon, le nom de la clé étrangère est facile à lire, par exemple:
table `user`:
id
name
role
table `article`:
id
content
created_user_id /* --> user.id */
reviewed_user_id /* --> user.id */
Nous avons donc deux clés étrangères:
fk-article-created_user_id
fk-article-reviewed_user_id
L'ajout d'un user
nom de table au nom de clé étrangère est redondant.
user_role
? user
et role
ont une relation manytomany et user_role
est la table qui contient toute la clé étrangère. Doit-il l'être fk_user_role_role
?