Forstå databaserelationer i Django

Læsere som dig hjælper med at støtte MUO. Når du foretager et køb ved hjælp af links på vores websted, kan vi optjene en affiliate-kommission.

En databaserelation beskriver forbindelsen mellem forskellige databasetabeller. Relationerne bestemmer, hvordan data lagres og hentes. Django fungerer godt med relationelle databasesystemer (RDBMS). Det understøtter derfor databasetabelrelationer.

Typerne af relationer afhænger af kravene til din applikation og de data, den modellerer. Gode ​​relationer mellem Django-modeller og databasen forbedrer datavedligeholdelsen. Det omfatter forbedring af forespørgselsydeevne og reduktion af dataduplikering.

Du kan lære, hvordan Django-databaserelationer påvirker applikationsydelsen ved at udforske de tre hovedtyper af relationer.

Database relationer

Relationelle databasesystemer understøtter tre typer databaserelationer. Disse relationer er en-til-mange, mange-til-mange og en-til-en. Typen af ​​databaserelation påvirker din applikations use cases.

Django modeller

repræsentere databasetabeller i appen. Du skal skabe gode relationer mellem tabeller for at skabe et godt databasesystem. Databaserelationer bestemmer, hvordan data lagres og præsenteres i din applikation.

For at forstå databaserelationer, start med oprettelse af et Django-projekt som hedder Emhætter. Appen bliver et socialt netværk i kvarteret. Det vil styre forskellige kvarterers sociale aktiviteter, sikkerhed og virksomheder.

Beboere kan registrere sig, logge ind og oprette profiler. De kan også oprette opslag og virksomhedsannoncer, som alle kan se.

For at komme i gang skal du oprette en database, der gemmer alle nabolagsdata. Derefter skal du oprette modellerne Profil, NeighborHood, Business og Post. For at oprette modellerne skal du bestemme den relation, databasetabellerne har brug for.

En-til-en databaserelation

Et en-til-en forhold indebærer, at en post i én Django-model relaterer sig til en anden post i en anden model. De to poster afhænger af hinanden. I dette tilfælde Profil model afhænger af Brugermodel at oprette beboerprofiler.

Så der kan kun være én profil for hver beboer registreret på appen. Uden en bruger kan en profil heller ikke eksistere.

fra django.db importere modeller
fradjango.bidrag.auth.modellerimportereBruger
klasseProfil(modeller. Model):
 bruger = modeller. OneToOneField (Bruger, on_delete=modeller. CASCADE, relateret_navn='profil')
 navn = modeller. CharField (max_length=80, blank=Rigtigt)
 bio = modeller. Tekstfelt (max_length=254, blank=Rigtigt)
 profile_picture = CloudinaryField('profilbillede', standard='default.png')
 placering = modeller. CharField (max_length=50, blank=Rigtigt, nul=Rigtigt)
 email = modeller. EmailField(nul=Rigtigt)
def__str__(selv):
Vend tilbage f'{selv.user.username} profil'

Djangos brugermodel er en indbygget autentificeringsmodel i Django. Du behøver ikke lave en model for det. Importer det i stedet fra django.contrib.auth. Det OneToOneField() på den Profil model definerer et en-til-en forhold.

Det on_delete=modeller. CASCADE argument forhindrer sletning af en af ​​disse poster. Du skal slette posterne fra begge tabeller.

Du kan bruge Django-admin-grænsefladen til at visualisere forholdet i din app. For at logge ind på Django admin skal du registrere dig som en admin-bruger kendt som en superbruger.

Opret en superbruger ved at køre følgende kommando på terminalen:

pythonstyre.pyskaber superbruger

Der vil være en prompt om at indtaste dit brugernavn, e-mail og adgangskode. Når du har gjort det, skal du starte serveren.

Åbn administratorsiden i en browser ved hjælp af URL'en http://127.0.0.1:8000/admin.

Du vil se admin-siden, hvor du kan logge ind med de legitimationsoplysninger, du oprettede tidligere. Når du er logget ind, vil du se Grupper og Brugere genstande. Django-godkendelsesrammen administrerer disse to modeller. Nederst vil du se Profil model.

Åbn Profil model og fortsæt med at tilføje en profil. Du vil se, at det ser ud som følger:

Bemærk, at du har mulighed for at oprette en profil for en bruger. Datatypen OneToOneField() giver dig mulighed for at oprette profiler til godkendte brugere. Sådan administrerer appen en-til-en-relationer.

En-til-mange forhold

Et en-til-mange forhold indebærer, at én post i en model associeres med mange poster i en anden model. Det omtales også som et mange-til-en forhold.

I dit tilfælde kan én administrator oprette flere kvarterer. Men hvert kvarter kan kun tilhøre én administrator. Du kan bruge ForeignKey-datatypen til at definere en sådan relation.

Django har en indbygget admin-grænseflade. Du behøver ikke lave en model for det. Administratoren har ret til at administrere indhold og visualisere appen fra administratorpanelet.

Modellen, der rummer mange plader, vil have Fremmed nøgle. Det definerer forholdet som én-til-mange. Koden nedenfor viser, hvor nøglen skal placeres.

klasseKvarter(modeller. Model):
 admin = modeller. Fremmed nøgle("Profil", on_delete=modeller. CASCADE, relateret_navn='hætte')
 navn = modeller. CharField (max_length=50)
 placering = modeller. CharField (max_length=60)
 hood_logo = CloudinaryField('hood_logo', standard='default.png')
 beskrivelse = modeller. Tekstfelt()
 health_tell = modeller. Heltalsfelt(nul=Rigtigt, blank=Rigtigt)
 politinummer = modeller. Heltalsfelt(nul=Rigtigt, blank=Rigtigt)
 Antal = modeller. Heltalsfelt(nul=Rigtigt, blank=Rigtigt)
def__str__(selv):
Vend tilbage f'{selv.name} hætte'

Du kan se forholdet på appen som illustreret på billedet:

Det Kvarter modellen har nu en admin. For at enhver kan oprette et kvarter, skal de have administratorrettigheder. Og et kvarter kan ikke have mange administratorer.

Mange-til-mange databaserelationer

I mange-til-mange-forhold forbindes mange poster i én model med andre i en anden. For eksempel Stolpe og Forretning modeller kan have flere registreringer af hinanden. Brugere kan lave flere virksomhedsannoncer i deres indlæg og omvendt.

Men at skabe mange-til-mange-relationer kan føre til unøjagtige data. I andre rammer skal du oprette en ny tabel for at forbinde de to tabeller.

Django har en løsning på dette. Når du bruger mange-til-mange-feltet, opretter det en ny tabel, der kortlægger de to tabeller sammen. Du kan sætte mange-til-mange-feltet i en af ​​de to modeller, men det bør ikke være i begge modeller.

klasseStolpe(modeller. Model):
 titel = modeller. CharField (max_length=120, nul=Rigtigt)
 post = modeller. Tekstfelt()
 dato = modeller. DateTimeField (auto_now_add=Rigtigt)
 bruger = modeller. ForeignKey (Profil, on_delete=models. CASCADE, relateret_navn='post_ejer')
 hætte = modeller. ForeignKey (NeighbourHood, on_delete=models. CASCADE, relateret_navn='hood_post')
 forretning = modeller. ManyToManyField (Business)
def__str__(selv):
Vend tilbage f'{selv.title} indlæg'

Nu, når du ser Stolpe model på administratorpanelet, kan du knytte flere virksomheder til et indlæg.

Django forenkler databaserelationer

Den type database, du bruger til din applikation, bestemmer, hvordan data skal udnyttes. Django har et omfattende system, der gør det nemt at forbinde og betjene relationelle databaser.

Django-funktioner gør det nemt at gemme og hente data fra relaterede tabeller. Den har indbyggede API'er, der forbinder og skaber databaserelationer til din app.

Databaserelationer bestemmer din applikations adfærd. Om du bruger en-til-en-, en-til-mange- eller mange-til-mange-forhold afhænger af dig.

Med Django kan du konfigurere og teste funktioner uden at ødelægge din applikation. Brug Django til at sikre databasesystemer og optimere din udvikleroplevelse.