Lezers zoals jij steunen MUO. Wanneer u een aankoop doet via links op onze site, kunnen we een aangesloten commissie verdienen.

Een databaserelatie beschrijft de verbinding tussen verschillende databasetabellen. De relaties bepalen hoe gegevens worden opgeslagen en opgehaald. Django werkt goed met relationele databasesystemen (RDBMS). Het ondersteunt daarom databasetabelrelaties.

De soorten relaties zijn afhankelijk van de vereisten van uw toepassing en de gegevens die worden gemodelleerd. Goede relaties tussen Django-modellen en de database verbeteren het gegevensbeheer. Dat omvat het verbeteren van queryprestaties en het verminderen van gegevensduplicatie.

U kunt leren hoe Django-databaserelaties de prestaties van applicaties beïnvloeden door de drie belangrijkste soorten relaties te verkennen.

Database-relaties

Relationele databasesystemen ondersteunen drie typen databaserelaties. Deze relaties zijn een-op-veel, veel-op-veel en een-op-een. Het type databaserelatie is van invloed op de use cases van uw toepassing.

Django-modellen vertegenwoordigen databasetabellen in de app. U moet goede relaties tussen tabellen maken om een ​​goed databasesysteem te creëren. Databaserelaties bepalen hoe gegevens in uw toepassing worden opgeslagen en gepresenteerd.

Om databaserelaties te begrijpen, begint u met een Django-project maken genaamd Kappen. De app wordt een sociaal buurtnetwerk. Het zal de sociale activiteiten, veiligheid en bedrijven van verschillende buurten beheren.

Bewoners kunnen zich registreren, inloggen en profielen aanmaken. Ze kunnen ook berichten en zakelijke advertenties maken die iedereen kan zien.

Maak om te beginnen een database waarin alle buurtgegevens worden opgeslagen. Vervolgens maakt u de modellen Profiel, Buurt, Bedrijf en Post. Om de modellen te maken, moet u de relatie bepalen die de databasetabellen nodig hebben.

Een-op-een databaserelatie

Een één-op-één-relatie houdt in dat een record in het ene Django-model betrekking heeft op een ander record in een ander model. De twee records zijn van elkaar afhankelijk. In dit geval de Profielmodel hangt af van de Gebruikersmodel bewonersprofielen maken.

Er kan dus maar één profiel zijn voor elke bewoner die op de app is geregistreerd. Ook zonder een gebruiker kan een profiel niet bestaan.

van django.db importeren modellen
vandjango.bijdragen.aut.modellenimporterenGebruiker
klasProfiel(modellen. Model):
 gebruiker = modellen. OneToOneField (Gebruiker, on_delete=models. CASCADE, gerelateerde_naam='profiel')
 naam = modellen. CharField (max_length=80, blanco=WAAR)
 bio = modellen. Tekstveld (max_length=254, blanco=WAAR)
 profile_picture = CloudinaryField('profielfoto', standaard='standaard.png')
 locatie = modellen. CharField (max_length=50, blanco=WAAR, nul=WAAR)
 e-mail = modellen. E-mailVeld(nul=WAAR)
def__str__(zelf):
opbrengst F'{zelf.user.username} profiel'

Het gebruikersmodel van Django is een ingebouwd authenticatiemodel in Django. Je hoeft er geen model voor te maken. Importeer het in plaats daarvan van django.contrib.auth. De OneToOneField() op de Profielmodel definieert een een-op-een relatie.

De on_delete=modellen. CASCADE argument verhindert de verwijdering van een van deze records. U moet de records uit beide tabellen verwijderen.

U kunt de Django-beheerdersinterface gebruiken om de relatie in uw app te visualiseren. Om u aan te melden bij Django admin, moet u zich registreren als een admin-gebruiker die bekend staat als een Super gebruiker.

Maak een superuser door de volgende opdracht op de terminal uit te voeren:

Pythonbeheren.pysupergebruiker maken

Er zal een prompt verschijnen om uw gebruikersnaam, e-mailadres en wachtwoord in te voeren. Zodra je dit hebt gedaan, start je de server.

Open de beheerpagina in een browser met behulp van de URL http://127.0.0.1:8000/admin.

U ziet de beheerderspagina waar u kunt inloggen met de inloggegevens die u eerder hebt gemaakt. Eenmaal ingelogd, ziet u de Groepen En Gebruikers voorwerpen. Het authenticatieframework van Django beheert deze twee modellen. Onderaan zie je de Profielmodel.

Open de Profiel model en ga verder met het toevoegen van een profiel. Je zult zien dat het er als volgt uitziet:

Merk op dat je de mogelijkheid hebt om een ​​profiel voor een gebruiker aan te maken. Met het gegevenstype OneToOneField() kunt u profielen maken voor geverifieerde gebruikers. Zo beheert de app één-op-één-relaties.

Een-op-veel-relaties

Een een-op-veel-relatie houdt in dat één record in een model is gekoppeld aan veel records in een ander model. Dit wordt ook wel een veel-op-een-relatie genoemd.

In jouw geval kan één beheerder meerdere buurten maken. Maar elke buurt kan slechts tot één beheerder behoren. U kunt het gegevenstype ForeignKey gebruiken om zo'n relatie te definiëren.

Django heeft een ingebouwde admin-interface. Je hoeft er geen model voor te maken. De beheerder heeft het recht om inhoud te beheren en de app te visualiseren vanuit het beheerderspaneel.

Het model dat veel records herbergt, heeft de Vreemde sleutel. Het definieert de relatie als een-op-veel. Onderstaande code laat zien waar de sleutel geplaatst moet worden.

klasBuurt(modellen. Model):
 beheerder = modellen. Vreemde sleutel("Profiel", on_delete=modellen. CASCADE, gerelateerde_naam='kap')
 naam = modellen. CharField (max_length=50)
 locatie = modellen. CharField (max_length=60)
 hood_logo = CloudinaryField('hood_logo', standaard='standaard.png')
 beschrijving = modellen. TekstVeld()
 health_tell = modellen. IntegerVeld(nul=WAAR, blanco=WAAR)
 politienummer = modellen. IntegerVeld(nul=WAAR, blanco=WAAR)
 Tellen= modellen. IntegerVeld(nul=WAAR, blanco=WAAR)
def__str__(zelf):
opbrengst F'{zelf.name} kap'

U kunt de relatie op de app zien zoals geïllustreerd in de afbeelding:

De Buurt model heeft nu een beheerder. Iedereen die een buurt wil maken, moet beheerdersrechten hebben. En één buurt kan niet veel bestuurders hebben.

Veel-op-veel-databaserelaties

In veel-op-veel-relaties associëren veel records in het ene model met andere in een ander model. Bijvoorbeeld de Na En Bedrijf modellen kunnen meerdere records van elkaar hebben. Gebruikers kunnen verschillende zakelijke advertenties in hun berichten plaatsen en vice versa.

Het creëren van veel-op-veel-relaties kan echter leiden tot onnauwkeurige gegevens. In andere frameworks zou u een nieuwe tabel moeten maken om de twee tabellen samen te voegen.

Django heeft hier een oplossing voor. Wanneer u het veel-op-veel-veld gebruikt, wordt er een nieuwe tabel gemaakt die de twee tabellen aan elkaar toewijst. U kunt het veel-op-veel-veld in elk van de twee modellen plaatsen, maar het zou niet in beide modellen moeten voorkomen.

klasNa(modellen. Model):
 titel = modellen. CharField (max_length=120, nul=WAAR)
 posten = modellen. TekstVeld()
 datum = modellen. DateTimeField (auto_now_add=WAAR)
 gebruiker = modellen. ForeignKey (Profiel, on_delete=models. CASCADE, gerelateerde_naam='post_eigenaar')
 kap = modellen. ForeignKey (NeighbourHood, on_delete=models. CASCADE, gerelateerde_naam='hood_post')
 zaken = modellen. ManyToManyField (zakelijk)
def__str__(zelf):
opbrengst F'{zelf.title} bericht'

Nu, wanneer u de Na model op het beheerderspaneel, kunt u meerdere bedrijven aan één bericht toevoegen.

Django vereenvoudigt databaserelaties

Het type database dat u voor uw toepassing gebruikt, bepaalt hoe u gegevens kunt gebruiken. Django heeft een uitgebreid systeem dat het koppelen en bedienen van relationele databases eenvoudig maakt.

Django-functies maken het gemakkelijk om gegevens uit gerelateerde tabellen op te slaan en op te halen. Het heeft ingebouwde API's die verbinding maken en databaserelaties voor uw app creëren.

Databaserelaties bepalen het gedrag van uw toepassing. Of u een-op-een-, een-op-veel- of veel-op-veel-relaties gebruikt, hangt van u af.

Met Django kunt u functies configureren en testen zonder uw applicatie te onderbreken. Gebruik Django om databasesystemen te beveiligen en uw ontwikkelaarservaring te optimaliseren.