Läsare som du hjälper till att stödja MUO. När du gör ett köp med hjälp av länkar på vår webbplats kan vi tjäna en affiliate-provision.
En databasrelation beskriver kopplingen mellan olika databastabeller. Relationerna avgör hur man lagrar och hämtar data. Django fungerar bra med relationsdatabassystem (RDBMS). Den stöder därför databastabellrelationer.
Typerna av relationer beror på kraven för din applikation och de data som den modellerar. Goda relationer mellan Django-modeller och databasen förbättrar dataunderhållet. Det inkluderar att förbättra frågeprestanda och minska dataduplicering.
Du kan lära dig hur Django-databasrelationer påverkar applikationsprestanda genom att utforska de tre huvudtyperna av relationer.
Databasrelationer
Relationella databassystem stöder tre typer av databasrelationer. Dessa relationer är en-till-många, många-till-många och en-till-en. Typen av databasrelation påverkar din applikations användningsfall.
Django modeller representerar databastabeller i appen. Du måste skapa goda relationer mellan tabeller för att skapa ett bra databassystem. Databasrelationer avgör hur data lagras och presenteras i din applikation.
För att förstå databasrelationer, börja med skapa ett Django-projekt som heter Huvor. Appen kommer att vara ett socialt nätverk i grannskapet. Det kommer att hantera olika stadsdelars sociala aktiviteter, säkerhet och företag.
Invånare kan registrera sig, logga in och skapa profiler. De kan också skapa inlägg och företagsannonser som alla kan se.
För att komma igång, skapa en databas som lagrar all grannskapsdata. Sedan kommer du att skapa modellerna Profile, NeighborHood, Business och Post. För att skapa modellerna måste du bestämma vilken relation databastabellerna behöver.
En-till-en-databasrelation
En en-till-en relation innebär att en post i en Django-modell relaterar till en annan post i en annan modell. De två rekorden beror på varandra. I det här fallet Profilmodell beror på Användarmodell för att skapa invånarprofiler.
Så det kan bara finnas en profil för varje invånare som är registrerad i appen. Dessutom kan en profil inte existera utan en användare.
från django.db importera modeller
fråndjango.contrib.auth.modellerimporteraAnvändareklassProfil(modeller. Modell):
användare = modeller. OneToOneField (Användare, on_delete=modeller. CASCADE, relaterat_namn='profil')
namn = modeller. CharField (max_length=80, blank=Sann)
bio = modeller. TextField (max_length=254, blank=Sann)
profile_picture = CloudinaryField('profilbild', standard='default.png')
plats = modeller. CharField (max_length=50, blank=Sann, null=Sann)
e-post = modeller. EmailField(null=Sann)
def__str__(själv):
lämna tillbaka f'{själv.user.username} profil"
Djangos användarmodell är en inbyggd autentiseringsmodell i Django. Du behöver inte skapa en modell för det. Importera den istället från django.contrib.auth. De OneToOneField() på Profilmodell definierar en en-till-en relation.
De on_delete=modeller. KASKAD argument förhindrar radering av en av dessa poster. Du måste ta bort posterna från båda tabellerna.
Du kan använda Djangos administratörsgränssnitt för att visualisera förhållandet i din app. För att logga in på Django admin måste du registrera dig som adminanvändare känd som en superanvändare.
Skapa en superanvändare genom att köra följande kommando på terminalen:
pytonormhantera.pyskapar superanvändareDet kommer att bli en uppmaning att ange ditt användarnamn, e-postadress och lösenord. När du har gjort det startar du servern.
Öppna administratörssidan i en webbläsare med hjälp av URL: en http://127.0.0.1:8000/admin.
Du kommer att se administratörssidan där du kan logga in med de referenser du skapade tidigare. När du har loggat in kommer du att se Grupper och Användare föremål. Django-autentiseringsramverket hanterar dessa två modeller. Längst ner ser du Profilmodell.
Öppna Profil modell och fortsätt för att lägga till en profil. Du kommer att se att det ser ut som följer:
Observera att du har möjlighet att skapa en profil för en användare. Datatypen OneToOneField() låter dig skapa profiler för autentiserade användare. Så här administrerar appen en-till-en-relationer.
En-till-många-relationer
En en-till-många-relation innebär att en post i en modell associeras med många poster i en annan modell. Det kallas också en många-till-en-relation.
I ditt fall kan en administratör skapa flera stadsdelar. Men varje stadsdel kan bara tillhöra en administratör. Du kan använda datatypen ForeignKey för att definiera en sådan relation.
Django har ett inbyggt administratörsgränssnitt. Du behöver inte skapa en modell för det. Administratören har rätt att hantera innehåll och visualisera appen från adminpanelen.
Modellen som rymmer många skivor kommer att ha Främmande nyckel. Den definierar relationen som en-till-många. Koden nedan visar var nyckeln ska placeras.
klassGrannskap(modeller. Modell):
admin = modeller. Främmande nyckel("Profil", on_delete=modeller. CASCADE, relaterat_namn='huva')
namn = modeller. CharField (max_length=50)
plats = modeller. CharField (max_length=60)
hood_logo = CloudinaryField('hood_logo', standard='default.png')
beskrivning = modeller. Textfält()
health_tell = modeller. Heltalsfält(null=Sann, blank=Sann)
polisnummer = modeller. Heltalsfält(null=Sann, blank=Sann)
Räkna = modeller. Heltalsfält(null=Sann, blank=Sann)
def__str__(själv):
lämna tillbaka f'{själv.name} huva'
Du kan se förhållandet på appen som illustreras på bilden:
De Grannskap modellen har nu en admin. För att alla ska kunna skapa en stadsdel måste de ha administratörsrättigheter. Och en stadsdel kan inte ha många administratörer.
Många-till-många databasrelationer
I många-till-många-relationer associeras många poster i en modell med andra i en annan. Till exempel Posta och Företag modeller kan ha flera uppgifter om varandra. Användare kan göra flera företagsannonser i sina inlägg och vice versa.
Men att skapa många-till-många-relationer kan leda till felaktiga uppgifter. I andra ramverk måste du skapa en ny tabell för att ansluta de två tabellerna.
Django har en lösning på detta. När du använder många-till-många-fältet skapas en ny tabell som mappar de två tabellerna tillsammans. Du kan sätta många-till-många-fältet i någon av de två modellerna, men det bör inte vara i båda modellerna.
klassPosta(modeller. Modell):
titel = modeller. CharField (max_length=120, null=Sann)
post = modeller. Textfält()
datum = modeller. DateTimeField (auto_now_add=Sann)
användare = modeller. ForeignKey (Profil, on_delete=modeller. CASCADE, relaterat_namn='post_owner')
huva = modeller. ForeignKey (NeighbourHood, on_delete=modeller. CASCADE, relaterat_namn='hood_post')
affär = modeller. ManyToManyField (Business)
def__str__(själv):
lämna tillbaka f'{själv.title} inlägg'
Nu, när du tittar på Posta modell på adminpanelen kan du bifoga flera företag till ett inlägg.
Django förenklar databasrelationer
Typen av databas du använder för din applikation avgör hur data ska användas. Django har ett heltäckande system som gör det enkelt att ansluta och driva relationsdatabaser.
Django-funktioner gör det enkelt att lagra och hämta data från relaterade tabeller. Den har inbyggda API: er som ansluter och skapar databasrelationer för din app.
Databasrelationer avgör hur din applikation fungerar. Om du använder en-till-en-, en-till-många- eller många-till-många-relationer beror på dig.
Med Django kan du konfigurera och testa funktioner utan att skada din applikation. Använd Django för att säkra databassystem och optimera din utvecklarupplevelse.
