Schéma de dénomination des clés étrangères

Je commence tout juste à travailler avec des clés étrangères pour la première fois et je me demande s'il existe un schéma de dénomination standard à utiliser pour elles?

Compte tenu de ces tableaux:

task (id, userid, title)
note (id, taskid, userid, note);
user (id, name)

Là où les tâches ont des notes, les tâches appartiennent aux utilisateurs et les utilisateurs créent des notes.

Comment les trois clés étrangères seraient-elles nommées dans cette situation? Ou bien, est-ce vraiment important ?

Mise à jour : cette question concerne les noms de clés étrangères, pas les noms de champs!

La convention standard dans SQL Server est:

FK_ForeignKeyTable_PrimaryKeyTable

Ainsi, par exemple, la clé entre les notes et les tâches serait:

FK_note_task

Et la clé entre les tâches et les utilisateurs serait:

FK_task_user

Cela vous donne une vue "en un coup d'œil" des tables impliquées dans la clé, ce qui permet de voir facilement de quelles tables dépend une table particulière (la première nommée) (la seconde nommée). Dans ce scénario, l'ensemble complet de clés serait:

FK_task_user
FK_note_task
FK_note_user

Ainsi, vous pouvez voir que les tâches dépendent des utilisateurs et que les notes dépendent à la fois des tâches et des utilisateurs.

J'utilise deux caractères de soulignement comme délimiteur ie

fk__ForeignKeyTable__PrimaryKeyTable 

En effet, les noms de table contiennent parfois eux-mêmes des caractères de soulignement. Cela suit la convention de dénomination des contraintes généralement parce que les noms des éléments de données contiennent souvent des caractères de soulignement, par exemple

CREATE TABLE NaturalPersons (
   ...
   person_death_date DATETIME, 
   person_death_reason VARCHAR(30) 
      CONSTRAINT person_death_reason__not_zero_length
         CHECK (DATALENGTH(person_death_reason) > 0), 
   CONSTRAINT person_death_date__person_death_reason__interaction
      CHECK ((person_death_date IS NULL AND person_death_reason IS NULL)
              OR (person_death_date IS NOT NULL AND person_death_reason IS NOT NULL))
        ...

Et pourquoi pas FK_TABLENAME_COLUMNNAME?

K EEP I t S œuvre S tupid chaque fois que possible.

Une note de Microsoft concernant SQL Server:

Une contrainte FOREIGN KEY ne doit pas être liée uniquement à une contrainte PRIMARY KEY dans une autre table; il peut également être défini pour référencer les colonnes d'une contrainte UNIQUE dans une autre table.

donc, j'utiliserai des termes décrivant la dépendance au lieu des termes conventionnels de relation primaire / étrangère.

Lors du référencement de la CLÉ PRIMAIRE de la table indépendante (parent) par la ou les colonnes de nom similaire dans la table dépendante (enfant) , j'omets le (s) nom (s) de colonne:

FK_ChildTable_ParentTable

Lors du référencement d'autres colonnes, ou les noms de colonnes varient entre les deux tables, ou simplement pour être explicite:

FK_ChildTable_childColumn_ParentTable_parentColumn

Habituellement, je laisse simplement mon ID nommé PK, puis je concatène le nom de ma table et le nom de la colonne clé lors de la dénomination des FK dans d'autres tables. Je ne me soucie jamais de la casse camel, car certaines bases de données ignorent la casse et renvoient simplement tous les noms en majuscules ou minuscules de toute façon. Dans tous les cas, voici à quoi ressemblerait ma version de vos tableaux:

task (id, userid, title);
note (id, taskid, userid, note);
user (id, name);

Notez que je nomme également mes tables au singulier, car une ligne représente l'un des objets que je persiste. Beaucoup de ces conventions sont des préférences personnelles. Je suggérerais qu'il est plus important de choisir une convention et de toujours l'utiliser que d'adopter la convention de quelqu'un d'autre.

C'est probablement sur-tuer, mais cela fonctionne pour moi. Cela m'aide beaucoup lorsque je traite en particulier des VLDB. J'utilise ce qui suit:

CONSTRAINT [FK_ChildTableName_ChildColName_ParentTableName_PrimaryKeyColName]

Bien sûr, si pour une raison quelconque vous ne référencez pas une clé primaire, vous devez référencer une colonne contenue dans une contrainte unique, dans ce cas:

CONSTRAINT [FK_ChildTableName_ChildColumnName_ParentTableName_ColumnInUniqueConstaintName]

Cela peut-il être long, oui. Cela a-t-il aidé à garder les informations claires pour les rapports, ou m'a-t-il permis de savoir rapidement que le problème potentiel se produisait lors d'une alerte de production? 100% aimeraient connaître les opinions des gens sur cette convention de dénomination.

Mon approche habituelle est

FK_ColumnNameOfForeignKey_TableNameOfReference_ColumnNameOfReference

Ou en d'autres termes

FK_ChildColumnName_ParentTableName_ParentColumnName

De cette façon, je peux nommer deux clés étrangères qui référencent la même table comme une table history_info tablewith column actionBy and actionTofromusers_info

Ce sera comme

FK_actionBy_usersInfo_name - For actionBy
FK_actionTo_usersInfo_name - For actionTo

Notez que:

Je n'ai pas inclus le nom de la table enfant car cela me semble logique, je suis dans la table de l'enfant donc je peux facilement assumer le nom de la table de l'enfant. Le caractère total de celui-ci est de 26 et correspond bien à la limite de 30 caractères d'oracle qui a été déclarée par Charles Burns dans un commentaire ici

Remarque pour les lecteurs: la plupart des bonnes pratiques répertoriées ci-dessous ne fonctionnent pas dans Oracle en raison de sa limite de nom de 30 caractères. Un nom de table ou de colonne peut déjà contenir près de 30 caractères, donc une convention combinant les deux en un seul nom nécessite une norme de troncature ou d'autres astuces. - Charles Burns

Sur la base des réponses et des commentaires ici, une convention de dénomination qui inclut la table FK, le champ FK et la table PK (FK_FKTbl_FKCol_PKTbl) devrait éviter les collisions de noms de contraintes FK.

Donc, pour les tableaux donnés ici:

fk_task_userid_user
fk_note_userid_user

Donc, si vous ajoutez une colonne pour suivre la dernière modification d'une tâche ou d'une note ...

fk_task_modifiedby_user
fk_note_modifiedby_user

Si vous ne faites pas souvent référence à vos FK et que vous utilisez MySQL (et InnoDB), vous pouvez simplement laisser MySQL nommer le FK pour vous.

Plus tard, vous pouvez trouver le nom FK dont vous avez besoin en exécutant une requête .

Essayez d'utiliser l'UUID de la version 4 en majuscules avec le premier octet remplacé par FK et '_' (trait de soulignement) au lieu de '-' (tiret).

Par exemple

• FK_4VPO_K4S2_A6M1_RQLEYLT1VQYV
• FK_1786_45A6_A17C_F158C0FB343E
• FK_45A5_4CFA_84B0_E18906927B53

La justification est la suivante

• Algorithme de génération strict => noms uniformes ;
• La longueur de la clé est inférieure à 30 caractères , ce qui est une limitation de longueur de dénomination dans Oracle (avant 12c);
• Si le nom de votre entité change, vous n'avez pas besoin de renommer votre FK comme dans l'approche basée sur le nom d'entité (si DB prend en charge l'opérateur de changement de nom de table);
• On utiliserait rarement le nom de la contrainte de clé étrangère. Par exemple, l'outil DB montre généralement à quoi s'applique la contrainte. Pas besoin d'avoir peur du look cryptique, car vous pouvez éviter de l'utiliser pour le "décryptage".