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.
MAKEUSE AV DAGENS VIDEO
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 är beroende av varandra. I det här fallet Profilmodell beror på Användarmodell 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.
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 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.
hur man får gratis Google Play -böcker
De on_delete=modeller.CASCADE 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:
python manage.py createsuperuser
Det 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 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 objekt. 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.
hur tar man bort xbox -profiler
En-till-många-relationer
A ett-till-många-förhållande 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.
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 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, många poster i en modell associerar 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.
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'
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.
hur man mittklickar på mac
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.