Forstå databaserelasjoner i Django

Lesere som deg er med på å støtte MUO. Når du foretar et kjøp ved å bruke lenker på nettstedet vårt, kan vi tjene en tilknyttet provisjon.

En databaserelasjon beskriver forbindelsen mellom ulike databasetabeller. Relasjonene bestemmer hvordan man lagrer og henter data. Django fungerer godt med relasjonsdatabasesystemer (RDBMS). Den støtter derfor databasetabellrelasjoner.

Relasjonstypene avhenger av kravene til applikasjonen din og dataene den modellerer. Gode relasjoner mellom Django-modeller og databasen forbedrer datavedlikeholdet. Dette inkluderer forbedring av søkeytelse og reduksjon av dataduplisering.

MAKEUSE AV DAGENS VIDEO

Du kan lære hvordan Django-databaserelasjoner påvirker applikasjonsytelsen ved å utforske de tre hovedtypene relasjoner.

Databaserelasjoner

Relasjonsdatabasesystemer støtter tre typer databaserelasjoner. Disse relasjonene er en-til-mange, mange-til-mange og en-til-en. Typen databaserelasjon påvirker applikasjonens brukstilfeller.

Django-modeller representerer databasetabeller i appen. Du må skape gode relasjoner mellom tabeller for å skape et godt databasesystem. Databaserelasjoner bestemmer hvordan du lagrer og presenterer data i applikasjonen din.

For å forstå databaserelasjoner, start med lage et Django-prosjekt navngitt Hetter. Appen vil være et sosialt nettverk i nabolaget. Den vil administrere ulike nabolags sosiale aktiviteter, sikkerhet og virksomheter.

Beboere kan registrere seg, logge på og opprette profiler. De kan også lage innlegg og bedriftsannonser som alle kan se.

For å komme i gang, lag en database som vil lagre alle nabolagsdata. Deretter oppretter du modellene Profile, NeighborHood, Business og Post. For å lage modellene må du bestemme forholdet databasetabellene trenger.

En-til-en databaserelasjon

Et en-til-en-forhold innebærer at en post i en Django-modell er relatert til en annen post i en annen modell. De to postene er avhengige av hverandre. I dette tilfellet Profilmodell kommer an på Brukermodell å opprette beboerprofiler.

Så det kan bare være én profil for hver beboer registrert på appen. Uten en bruker kan det heller ikke eksistere en profil.

from django.db import models 
from django.contrib.auth.models import User 
  
class Profile(models.Model): 
    user = models.OneToOneField(User, on_delete=models.CASCADE, related_name='profile') 
    name = models.CharField(max_length=80, blank=True) 
    bio = models.TextField(max_length=254, blank=True) 
    profile_picture = CloudinaryField('profile_picture', default='default.png') 
    location = models.CharField(max_length=50, blank=True, null=True) 
    email = models.EmailField(null=True) 
  
    def __str__(self): 
        return f'{self.user.username} profile'

Djangos brukermodell er en innebygd autentiseringsmodell i Django. Du trenger ikke lage en modell for det. I stedet importerer du den fra django.contrib.auth. De OneToOneField() på Profilmodell definerer et en-til-en forhold.

De on_delete=modeller.CASCADE argument forhindrer sletting av en av disse postene. Du må slette postene fra begge tabellene.

Du kan bruke Django-administrasjonsgrensesnittet til å visualisere forholdet i appen din. For å logge inn på Django admin, må du registrere deg som en admin-bruker kjent som en superbruker .

Opprett en superbruker ved å kjøre følgende kommando på terminalen:

python manage.py createsuperuser

Det vil bli bedt om å skrive inn brukernavn, e-post og passord. Når du har gjort det, start serveren.

Åpne admin-siden i en nettleser ved å bruke URL-en http://127.0.0.1:8000/admin.

hvordan være usynlig på facebook chat

Du vil se admin-siden hvor du kan logge på med legitimasjonen du opprettet tidligere. Når du er logget inn, vil du se Grupper og Brukere gjenstander. Django-autentiseringsrammeverket administrerer disse to modellene. Nederst vil du se Profilmodell.

Åpne Profil modell og fortsett for å legge til en profil. Du vil se det ser ut som følger:

Django admin viser forholdet mellom profil og brukermodeller

Legg merke til at du har muligheten til å opprette en profil for en bruker. Datatypen OneToOneField() lar deg opprette profiler for autentiserte brukere. Slik administrerer appen en-til-en-forhold.

En-til-mange forhold

EN en-til-mange-forhold innebærer at én post i en modell assosieres med mange poster i en annen modell. Det blir også referert til som et mange-til-en-forhold.

I ditt tilfelle kan én administrator opprette flere nabolag. Men hvert nabolag kan bare tilhøre én administrator. Du kan bruke ForeignKey-datatypen for å definere et slikt forhold.

Django har et innebygd administrasjonsgrensesnitt. Du trenger ikke lage en modell for det. Administratoren har rett til å administrere innhold og visualisere appen fra administrasjonspanelet.

Modellen som rommer mange plater vil ha ForeignKey . Det definerer forholdet som en-til-mange. Koden nedenfor viser hvor nøkkelen skal plasseres.

class NeighbourHood(models.Model): 
    admin = models.ForeignKey("Profile", on_delete=models.CASCADE, related_name='hood') 
    name = models.CharField(max_length=50) 
    location = models.CharField(max_length=60) 
    hood_logo = CloudinaryField('hood_logo', default='default.png') 
    description = models.TextField() 
    health_tell = models.IntegerField(null=True, blank=True) 
    police_number = models.IntegerField(null=True, blank=True) 
    Count= models.IntegerField(null=True, blank=True) 
  
    def __str__(self): 
        return f'{self.name} hood'

Du kan se forholdet på appen som illustrert på bildet:

Nabolagsmodellen viser Admin-valg lagt til

De Nabolag modellen har nå en admin. For at alle skal kunne opprette et nabolag, må de ha administratorrettigheter. Og ett nabolag kan ikke ha mange administratorer.

Mange-til-mange-databaserelasjoner

I mange-til-mange relasjoner, mange poster i en modell assosieres med andre i en annen. For eksempel Post og Virksomhet modeller kan ha flere registreringer av hverandre. Brukere kan lage flere bedriftsannonser i innleggene sine og omvendt.

Å lage mange-til-mange-relasjoner kan imidlertid føre til unøyaktige data. I andre rammer må du opprette en ny tabell for å slå sammen de to tabellene.

Django har en løsning på dette. Når du bruker mange-til-mange-feltet, oppretter det en ny tabell som kartlegger de to tabellene sammen . Du kan sette mange-til-mange-feltet i en av de to modellene, men det bør ikke være i begge modellene.

class Post(models.Model): 
    title = models.CharField(max_length=120, null=True) 
    post = models.TextField() 
    date = models.DateTimeField(auto_now_add=True) 
    user = models.ForeignKey(Profile, on_delete=models.CASCADE, related_name='post_owner') 
    hood = models.ForeignKey(NeighbourHood, on_delete=models.CASCADE, related_name='hood_post') 
    business = models.ManyToManyField(Business) 
  
    def __str__(self): 
        return f'{self.title} post'

Nå, når du ser på Post modell på administrasjonspanelet, kan du legge ved flere virksomheter til ett innlegg.

Postmodellen har mulighet for å legge til flere virksomheter

Django forenkler databaserelasjoner

Databasetypen du bruker for applikasjonen din, avgjør hvordan data skal utnyttes. Django har et omfattende system som gjør det enkelt å koble til og betjene relasjonsdatabaser.

Django-funksjoner gjør det enkelt å lagre og hente data fra relaterte tabeller. Den har innebygde APIer som kobler til og oppretter databaserelasjoner for appen din.

Databaseforhold bestemmer oppførselen til applikasjonen din. Om du bruker en-til-en-, en-til-mange- eller mange-til-mange-forhold avhenger av deg.

Med Django kan du konfigurere og teste funksjoner uten å ødelegge applikasjonen din. Bruk Django til å sikre databasesystemer og optimalisere utvikleropplevelsen din.