Comprendere le relazioni di database in Django

Comprendere le relazioni di database in Django
I lettori come te aiutano a sostenere MUO. Quando effettui un acquisto utilizzando i link sul nostro sito, potremmo guadagnare una commissione di affiliazione.

Una relazione di database descrive la connessione tra diverse tabelle di database. Le relazioni determinano come archiviare e recuperare i dati. Django funziona bene con i sistemi di database relazionali (RDBMS). Pertanto, supporta le relazioni tra le tabelle del database.





I tipi di relazioni dipendono dai requisiti dell'applicazione e dai dati che modella. Buone relazioni tra i modelli Django e il database migliorano la manutenzione dei dati. Ciò include il miglioramento delle prestazioni delle query e la riduzione della duplicazione dei dati.



MAKEUSEOF VIDEO DEL GIORNO

Puoi scoprire come le relazioni del database Django influenzano le prestazioni dell'applicazione esplorando i tre principali tipi di relazione.





Relazioni di database

I sistemi di database relazionali supportano tre tipi di relazioni di database. Queste relazioni sono uno-a-molti, molti-a-molti e uno-a-uno. Il tipo di relazione del database influisce sui casi d'uso dell'applicazione.

Modelli Django rappresentano le tabelle del database nell'app. È necessario creare buone relazioni tra le tabelle per creare un buon sistema di database. Le relazioni del database determinano come archiviare e presentare i dati nell'applicazione.



Per comprendere le relazioni del database, inizia da creazione di un progetto Django di nome Cappe. L'app sarà un social network di quartiere. Gestirà le attività sociali, la sicurezza e le imprese di vari quartieri.

I residenti possono registrarsi, accedere e creare profili. Possono anche creare post e annunci commerciali che tutti possono vedere.



Per iniziare, crea un database che memorizzerà tutti i dati del quartiere. Quindi, creerai i modelli Profile, NeighborHood, Business e Post. Per creare i modelli, è necessario determinare la relazione necessaria alle tabelle del database.

Relazione uno a uno con il database

Una relazione uno a uno implica che un record in un modello Django sia correlato a un altro record in un altro modello. I due record dipendono l'uno dall'altro. In questo caso, il Modello di profilo dipende da Modello utente per creare profili residenti.



Quindi può esserci un solo profilo per ogni residente registrato sull'app. Inoltre, senza un utente, non può esistere un profilo.

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'

Modello utente di Django è un modello di autenticazione integrato in Django. Non devi creare un modello per questo. Invece, importalo da django.contrib.auth. Il UnoAUnoCampo() sul Modello di profilo definisce una relazione uno a uno.

Il on_delete=modelli.CASCADE argomento impedisce la cancellazione di uno di questi record. È necessario eliminare i record da entrambe le tabelle.

Puoi utilizzare l'interfaccia di amministrazione di Django per visualizzare la relazione nella tua app. Per accedere all'amministratore di Django, devi registrarti come utente amministratore noto come a superutente .

Crea un superutente eseguendo il seguente comando sul terminale:

python manage.py createsuperuser

Verrà richiesto di inserire nome utente, e-mail e password. Una volta fatto, avvia il server.

Apri la pagina di amministrazione in un browser utilizzando l'URL http://127.0.0.1:8000/admin.

Vedrai la pagina di amministrazione in cui puoi accedere con le credenziali che hai creato in precedenza. Una volta effettuato l'accesso, vedrai il Gruppi e Utenti oggetti. Il framework di autenticazione Django gestisce questi due modelli. In fondo, vedrai il Modello di profilo.

Apri il Profilo modello e procedere con l'aggiunta di un profilo. Vedrai apparire come segue:

L'amministratore di Django mostra la relazione tra profilo e modelli utente

Si noti che è possibile creare un profilo per un utente. Il tipo di dati OneToOneField() consente di creare profili per gli utenti autenticati. Questo è il modo in cui l'app gestisce le relazioni uno a uno.

il mio telefono non si connetterà al mio computer

Relazioni uno a molti

UN La relazione uno-a-molti implica che un record in un modello si associ a molti record in un altro modello. Si parla anche di relazione molti-a-uno.

Nel tuo caso, un amministratore può creare diversi quartieri. Ma ogni quartiere può appartenere a un solo amministratore. È possibile utilizzare il tipo di dati ForeignKey per definire tale relazione.

Django ha un'interfaccia di amministrazione integrata. Non devi creare un modello per questo. L'amministratore ha il diritto di gestire i contenuti e visualizzare l'app dal pannello di amministrazione.

Il modello che ospita molti record avrà l'estensione Chiave esterna . Definisce la relazione come uno a molti. Il codice seguente mostra dove posizionare la chiave.

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'

Puoi vedere la relazione sull'app come illustrato nell'immagine:

Il modello di vicinato mostra la scelta dell'amministratore aggiunta

Il Quartiere model ora ha un amministratore. Affinché chiunque possa creare un quartiere, deve disporre dei diritti di amministratore. E un quartiere non può avere molti amministratori.

Relazioni database molti-a-molti

In molti a molti relazioni, molti record in un modello si associano ad altri in un altro. Ad esempio, il Inviare e Affare i modelli possono avere diversi record l'uno dell'altro. Gli utenti possono inserire diversi annunci commerciali nei loro post e viceversa.

Tuttavia, la creazione di relazioni molti-a-molti può portare a dati imprecisi. In altri framework, dovresti creare una nuova tabella per unire le due tabelle.

Django ha una soluzione per questo. Quando usi il campo molti-a-molti, crea una nuova tabella che mappa insieme le due tabelle . Puoi inserire il campo molti-a-molti in uno dei due modelli, ma non dovrebbe essere in entrambi i modelli.

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'

Ora, quando visualizzi il file Inviare modello nel pannello di amministrazione, puoi allegare diverse attività a un post.

Il modello postale ha la possibilità di aggiungere diverse attività

Django semplifica le relazioni con i database

Il tipo di database che usi per la tua applicazione determina come sfruttare i dati. Django ha un sistema completo che semplifica la connessione e l'utilizzo di database relazionali.

Le funzionalità di Django semplificano l'archiviazione e il recupero dei dati dalle tabelle correlate. Dispone di API integrate che si connettono e creano relazioni di database per la tua app.

Le relazioni del database determinano il comportamento dell'applicazione. Se utilizzi relazioni uno a uno, uno a molti o molti a molti dipende da te.

Con Django, puoi configurare e testare le funzionalità senza interrompere la tua applicazione. Usa Django per proteggere i sistemi di database e ottimizzare la tua esperienza di sviluppatore.