Estructura y Claves Foráneas en Django ORM¶

1. Introducción¶

En este tema, vamos a aprender sobre las claves foráneas en Django, un concepto fundamental cuando trabajamos con bases de datos relacionales. Una clave foránea es un campo que se utiliza para establecer una relación entre dos tablas. Esta clave guarda una referencia a la clave primaria de otra tabla, lo que permite que los datos de una tabla estén relacionados con los datos de otra.

Las claves foráneas son útiles cuando queremos modelar relaciones como uno a muchos (por ejemplo, un autor puede tener muchos posts, pero cada post pertenece solo a un autor).

2. Crear un Nuevo Proyecto `myBlog`¶

Primero, vamos a crear un nuevo proyecto en Django llamado myBlog. Abre la terminal y ejecuta los siguientes comandos para crear el proyecto y configurar el entorno virtual:

# Crear el entorno virtual
python -m venv .venv
source .venv/bin/activate  # Windows: .venv\\\\Scripts\\\\activate

# Instalar Django
pip install django

# Crear el proyecto
django-admin startproject myBlog .

3. Crear una Aplicación Llamada `post`¶

A continuación, crearemos una nueva aplicación llamada posts para gestionar las publicaciones del blog. Ejecuta el siguiente comando:

# Crear la app 'posts'
python manage.py startapp posts

4. Configurar la Aplicación, Añadirla y Comprobar¶

En el archivo settings.py del proyecto myBlog, añade la aplicación posts a la lista INSTALLED_APPS para que Django la reconozca. Abre el archivo myBlog/settings.py y añade 'posts' a la lista.

# myBlog/settings.py
INSTALLED_APPS = [
    # ...
    'posts',
]

También recordemos que hay que añadir templates en el DIRS de TEMPLATES y configurar los archivos estáticos:

# myBlog/settings.py
TEMPLATES = [
    {
      ...
        'DIRS': [BASE_DIR / 'templates'],  # Añadir esta línea
      ... 
    },
]   
STATIC_URL = '/static/'
STATICFILES_DIRS = [BASE_DIR / 'static']

Luego, comprueba que la configuración es correcta ejecutando el comando check:

python manage.py check

5. Delegar las Rutas a la Aplicación `posts`¶

Ahora vamos a delegar las rutas de la aplicación posts a su propio archivo urls.py. Primero, creamos el archivo urls.py dentro de la aplicación posts y definimos las rutas allí.

En posts/urls.py, inicialmente dejaremos los patrones vacíos, pero se incluirán dentro del archivo urls.py del proyecto principal.

# posts/urls.py
from django.urls import path

urlpatterns = [
    # Rutas de la app post (por ahora vacías)
]

Luego, en el archivo myBlog/urls.py del proyecto, incluimos las rutas de posts usando include.

# myBlog/urls.py
from django.contrib import admin
from django.urls import path, include

urlpatterns = [
    path('admin/', admin.site.urls),
    path('posts/', include('posts.urls')),
]

6. Modelado de Datos: Autores y Entradas al Blog¶

Vamos a crear dos modelos de datos:

Author: que representará a los autores del blog.
Post: que representará las entradas o artículos del blog.

6.1 Crear la Clase `Author`¶

El modelo Author tendrá los campos name (nombre del autor) y email (correo electrónico). Además, definiremos el método __str__ para que el nombre del autor sea lo que se muestre cuando se visualice el objeto.

# posts/models.py
from django.db import models

class Author(models.Model):
    name = models.CharField(max_length=200)
    email = models.EmailField()

    def __str__(self):
        return self.name

6.2 Crear la Clase `Post`¶

El modelo Post tendrá los siguientes campos:

headLine: Título de la entrada.
bodyText: Cuerpo del artículo.
public_date: Fecha de publicación, que por defecto será la fecha actual.
rating: Puntuación de la entrada (por defecto 5).

También definiremos el método __str__ para que el título de la entrada sea lo que se muestre cuando se visualice el objeto.

# posts/models.py
from django.db import models
from datetime import datetime

class Post(models.Model):
    headLine = models.CharField(max_length=255)
    bodyText = models.TextField()
    public_date = models.DateTimeField(default=datetime.now)
    rating = models.IntegerField(default=5)

    def __str__(self):
        return self.headLine

7. Relacionar los Modelos con Claves Foráneas¶

Ahora vamos a establecer una relación entre los modelos Post y Author. Un autor puede tener muchos posts, pero un post solo puede tener un autor, por lo que usaremos una clave foránea en el modelo Post que apunte al modelo Author.

7.1 Añadir el Campo `author` a `Post`¶

En el modelo Post, añadimos un campo author, que será una clave foránea que hará referencia al modelo Author. Esto representará la relación entre un autor y sus publicaciones. Usaremos el parámetro on_delete=models.CASCADE para que, si un autor es eliminado, se eliminen también sus posts relacionados. Además, usamos related_name='posts' para poder acceder a todos los posts de un autor a través de author.posts.

# posts/models.py
class Post(models.Model):
    headLine = models.CharField(max_length=255)
    bodyText = models.TextField()
    public_date = models.DateTimeField(default=datetime.now)
    rating = models.IntegerField(default=5)
    author = models.ForeignKey(Author, on_delete=models.CASCADE, related_name='posts')

    def __str__(self):
        return self.headLine

Explicación: La relación de clave foránea entre Post y Author permite acceder desde un objeto Author a todos sus Post asociados mediante author.posts.

8. Migraciones: Comprobar que se Han Creado las Tablas¶

Después de haber definido los modelos, debemos realizar las migraciones para crear las tablas en la base de datos. Ejecuta los siguientes comandos para crear y aplicar las migraciones:

# Crear las migraciones
python manage.py makemigrations

# Aplicar las migraciones
python manage.py migrate

Para comprobar que las tablas se han creado correctamente, puedes acceder a la base de datos usando el shell de Django o una herramienta como VSCode.

# Iniciar el shell de Django
python manage.py dbshell

# Consultar las tablas creadas
SELECT * FROM posts_post;

Deberías ver las tablas correspondientes a los modelos Post y Author.

9. Resumen¶

En este tema, hemos aprendido cómo usar claves foráneas en Django para crear relaciones entre modelos. Vimos cómo:

Crear un nuevo proyecto y una nueva aplicación.
Definir modelos para autores y entradas del blog.
Establecer relaciones entre modelos utilizando claves foráneas.
Realizar migraciones para crear las tablas correspondientes en la base de datos.

Ahora tenemos un modelo de datos básico para un blog con autores y publicaciones, y hemos utilizado claves foráneas para relacionar los datos de manera eficiente.

Estructura y Claves Foráneas en Django ORM¶

1. Introducción¶

2. Crear un Nuevo Proyecto myBlog¶

3. Crear una Aplicación Llamada post¶