Des lecteurs comme vous aident à soutenir MUO. Lorsque vous effectuez un achat en utilisant des liens sur notre site, nous pouvons gagner une commission d'affiliation.
Une relation de base de données décrit la connexion entre différentes tables de base de données. Les relations déterminent comment stocker et récupérer les données. Django fonctionne bien avec les systèmes de bases de données relationnelles (RDBMS). Il prend donc en charge les relations entre les tables de base de données.
Les types de relations dépendent des exigences de votre application et des données qu'elle modélise. De bonnes relations entre les modèles Django et la base de données améliorent la maintenance des données. Cela inclut l'amélioration des performances des requêtes et la réduction de la duplication des données.
Vous pouvez découvrir comment les relations de la base de données Django affectent les performances des applications en explorant les trois principaux types de relations.
Relations de base de données
Les systèmes de bases de données relationnelles prennent en charge trois types de relations de base de données. Ces relations sont un à plusieurs, plusieurs à plusieurs et un à un. Le type de relation de base de données affecte les cas d'utilisation de votre application.
Modèles Django représentent les tables de base de données dans l'application. Vous devez créer de bonnes relations entre les tables pour créer un bon système de base de données. Les relations de base de données déterminent comment stocker et présenter les données dans votre application.
Pour comprendre les relations de la base de données, commencez par créer un projet Django nommé Cagoules. L'application sera un réseau social de quartier. Il gérera les activités sociales, la sécurité et les commerces des différents quartiers.
Les résidents peuvent s'inscrire, se connecter et créer des profils. Ils peuvent également créer des publications et des publicités commerciales que tout le monde peut voir.
Pour commencer, créez une base de données qui stockera toutes les données du quartier. Ensuite, vous créerez les modèles Profile, NeighborHood, Business et Post. Pour créer les modèles, vous devez déterminer la relation dont les tables de base de données ont besoin.
Relation de base de données un à un
Une relation un-à-un implique qu'un enregistrement dans un modèle Django est lié à un autre enregistrement dans un autre modèle. Les deux enregistrements dépendent l'un de l'autre. Dans ce cas, le Modèle de profil Depend de Modèle utilisateur pour créer des profils de résidents.
Il ne peut donc y avoir qu'un seul profil pour chaque résident inscrit sur l'application. De plus, sans utilisateur, un profil ne peut pas exister.
depuis django.db importer des modèles
depuisDjango.contrib.auth.des modèlesimporterUtilisateurclasseProfil(des modèles. Modèle):
utilisateur = modèles. OneToOneField (Utilisateur, on_delete=models. CASCADE, nom_associé='profil')
nom = modèles. CharField (max_length=80, vide=Vrai)
bio = modèles. Champ de texte (max_length=254, vide=Vrai)
profile_picture = CloudinaryField('image de profil', par défaut='défaut.png')
emplacement = modèles. CharField (max_length=50, vide=Vrai, nul=Vrai)
e-mail = modèles. ChampE-mail(nul=Vrai)
définitivement__str__(soi):
retour F'{soiprofil .user.username}'
Modèle utilisateur de Django est un modèle d'authentification intégré à Django. Vous n'avez pas besoin de créer un modèle pour cela. Au lieu de cela, importez-le depuis django.contrib.auth. Le UnÀUnChamp() sur le Modèle de profil définit une relation un à un.
Le on_delete=modèles. CASCADE L'argument empêche la suppression de l'un de ces enregistrements. Vous devez supprimer les enregistrements des deux tables.
Vous pouvez utiliser l'interface d'administration de Django pour visualiser la relation dans votre application. Pour vous connecter à Django admin, vous devez vous inscrire en tant qu'utilisateur admin connu sous le nom de superutilisateur.
Créez un superutilisateur en exécutant la commande suivante sur le terminal :
pythongérer.pycréer un superutilisateurVous serez invité à saisir votre nom d'utilisateur, votre adresse e-mail et votre mot de passe. Une fois que vous avez fait cela, démarrez le serveur.
Ouvrez la page d'administration dans un navigateur à l'aide de l'URL http://127.0.0.1:8000/admin.
Vous verrez la page d'administration où vous pourrez vous connecter avec les informations d'identification que vous avez créées précédemment. Une fois connecté, vous verrez le Groupes et Utilisateurs objets. Le framework d'authentification Django gère ces deux modèles. En bas, vous verrez le Modèle de profil.
Ouvrez le Profil modèle et procédez à l'ajout d'un profil. Vous verrez qu'il apparaît comme suit :
Notez que vous avez la possibilité de créer un profil pour un utilisateur. Le type de données OneToOneField() vous permet de créer des profils pour les utilisateurs authentifiés. C'est ainsi que l'application gère les relations individuelles.
Relations un-à-plusieurs
Une relation un-à-plusieurs implique qu'un enregistrement dans un modèle est associé à plusieurs enregistrements dans un autre modèle. On parle aussi de relation plusieurs-à-un.
Dans votre cas, un administrateur peut créer plusieurs quartiers. Mais chaque quartier ne peut appartenir qu'à un seul administrateur. Vous pouvez utiliser le type de données ForeignKey pour définir une telle relation.
Django a une interface d'administration intégrée. Vous n'avez pas besoin de créer un modèle pour cela. L'administrateur a le droit de gérer le contenu et de visualiser l'application à partir du panneau d'administration.
Le modèle qui accueille de nombreux enregistrements aura la Clé étrangère. Il définit la relation comme un-à-plusieurs. Le code ci-dessous montre où placer la clé.
classeQuartier(des modèles. Modèle):
admin = modèles. Clé étrangère("Profil", on_delete=modèles. CASCADE, nom_associé='capot')
nom = modèles. CharField (max_length=50)
emplacement = modèles. CharField (max_length=60)
hood_logo = CloudinaryField('hood_logo', par défaut='défaut.png')
description = modèles. Champ de texte()
health_tell = modèles. ChampEntier(nul=Vrai, vide=Vrai)
police_number = modèles. ChampEntier(nul=Vrai, vide=Vrai)
Compte = modèles. ChampEntier(nul=Vrai, vide=Vrai)
définitivement__str__(soi):
retour F'{soi.name} hotte'
Vous pouvez voir la relation sur l'application comme illustré dans l'image :
Le Quartier le modèle a maintenant un administrateur. Pour que quiconque puisse créer un quartier, il doit disposer des droits d'administrateur. Et un quartier ne peut pas avoir plusieurs administrateurs.
Relations de base de données plusieurs à plusieurs
Dans les relations plusieurs-à-plusieurs, de nombreux enregistrements d'un modèle s'associent à d'autres dans un autre modèle. Par exemple, le Poste et Entreprise les modèles peuvent avoir plusieurs enregistrements les uns des autres. Les utilisateurs peuvent faire plusieurs annonces commerciales dans leurs messages et vice versa.
Cependant, la création de relations plusieurs à plusieurs peut entraîner des données inexactes. Dans d'autres frameworks, vous devrez créer une nouvelle table pour joindre les deux tables.
Django a une solution pour cela. Lorsque vous utilisez le champ plusieurs à plusieurs, il crée une nouvelle table mappant les deux tables ensemble. Vous pouvez mettre le champ plusieurs-à-plusieurs dans l'un ou l'autre des deux modèles, mais il ne devrait pas être dans les deux modèles.
classePoste(des modèles. Modèle):
titre = modèles. CharField (max_length=120, nul=Vrai)
poste = modèles. Champ de texte()
date = modèles. DateTimeField (auto_now_add=Vrai)
utilisateur = modèles. ForeignKey (Profil, on_delete=models. CASCADE, nom_associé='post_owner')
hotte = modèles. ForeignKey (NeighbourHood, on_delete=models. CASCADE, nom_associé='hood_post')
entreprise = modèles. ManyToManyField (Entreprise)
définitivement__str__(soi):
retour F'{soi.title} message'
Maintenant, lorsque vous visualisez le Poste modèle sur le panneau d'administration, vous pouvez joindre plusieurs entreprises à un poste.
Django simplifie les relations avec les bases de données
Le type de base de données que vous utilisez pour votre application détermine comment exploiter les données. Django dispose d'un système complet qui facilite la connexion et l'exploitation des bases de données relationnelles.
Les fonctionnalités de Django facilitent le stockage et la récupération de données à partir de tables associées. Il dispose d'API intégrées qui se connectent et créent des relations de base de données pour votre application.
Les relations de base de données déterminent le comportement de votre application. Que vous utilisiez des relations un à un, un à plusieurs ou plusieurs à plusieurs dépend de vous.
Avec Django, vous pouvez configurer et tester des fonctionnalités sans casser votre application. Utilisez Django pour sécuriser les systèmes de base de données et optimiser votre expérience de développeur.
