Förstå databasrelationer i Django

Förstå databasrelationer i Django
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.





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() 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:

  Django admin visar relationen mellan profil och användarmodeller

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:

  Grannskapsmodellen visar att administratörsval har lagts till

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.

  Postmodellen har möjlighet att lägga till flera företag

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.