Como ejemplo continuo en este capítulo y el siguiente, nos enfocaremos en una configuración de datos básica sobre libro/autor/editor. Usamos esto como ejemplo porque las relaciones conceptuales entre libros, autores y editores son bien conocidas, y es una configuración de datos comúnmente utilizada en libros de texto introductorios de SQL. Por otra parte, ¡estás leyendo un libro que fue escrito por autores y producido por un editor!
Supondremos los siguientes conceptos, campos y relaciones:
- Un autor tiene un título (ej.: Sr. o Sra.), nombre, apellido, dirección de correo electrónico y una foto tipo carnet.
- Un editor tiene un nombre, una dirección, una ciudad, un estado o provincia, un país y un sitio Web.
- Un libro tiene un título y una fecha de publicación. También tiene uno o más autores (una relación muchos-a-muchos con autores) y un único editor (una relación uno a muchos — también conocida como clave foránea — con editores).
El primer paso para utilizar esta configuración de base de datos con Django es
expresarla como código Python. En el archivo models.py que se creó con el
comando startapp, ingresa lo siguiente:
from django.db import models
class Publisher(models.Model):
name = models.CharField(maxlength=30)
address = models.CharField(maxlength=50)
city = models.CharField(maxlength=60)
state_province = models.CharField(maxlength=30)
country = models.CharField(maxlength=50)
website = models.URLField()
class Author(models.Model):
salutation = models.CharField(maxlength=10)
first_name = models.CharField(maxlength=30)
last_name = models.CharField(maxlength=40)
email = models.EmailField()
headshot = models.ImageField(upload_to='/tmp')
class Book(models.Model):
title = models.CharField(maxlength=100)
authors = models.ManyToManyField(Author)
publisher = models.ForeignKey(Publisher)
publication_date = models.DateField()Examinemos rápidamente este código para conocer lo básico. La primer cosa a
notar es que cada modelo es representado por una clase Python que es una
subclase de django.db.models.Model. La clase antecesora, Model,
contiene toda la maquinaria necesaria para hacer que estos objetos sean
capaces de interactuar con la base de datos — y que hace que nuestros modelos
sólo sean responsables de definir sus campos, en una sintaxis compacta y
agradable. Lo creas o no, éste es todo el código que necesitamos para tener
acceso básico a los datos con Django.
Cada modelo generalmente corresponde a una tabla única de la base de datos, y
cada atributo de un modelo generalmente corresponde a una columna en esa tabla.
El nombre de atributo corresponde al nombre de columna, y el tipo de campo
(ej.: CharField) corresponde al tipo de columna de la base de datos (ej.:
varchar). Por ejemplo, el modelo Publisher es equivalente a la
siguiente tabla (asumiendo la sintaxis de PostgreSQL para CREATE TABLE):
CREATE TABLE "books_publisher" (
"id" serial NOT NULL PRIMARY KEY,
"name" varchar(30) NOT NULL,
"address" varchar(50) NOT NULL,
"city" varchar(60) NOT NULL,
"state_province" varchar(30) NOT NULL,
"country" varchar(50) NOT NULL,
"website" varchar(200) NOT NULL
);En efecto, Django puede generar esta sentencia CREATE TABLE automáticamente
como veremos en un momento.
La excepción a la regla una-clase-por-tabla es el caso de las relaciones
muchos-a-muchos. En nuestros modelos de ejemplo, Book tiene un
ManyToManyField llamado authors. Esto significa que un libro tiene uno
o más autores, pero la tabla de la base de datos Book no tiene una columna
authors. En su lugar, Django crea una tabla adicional — una "tabla de
join" muchos-a-muchos — que maneja la correlación entre libros y autores.
Para una lista completa de tipos de campo y opciones de sintaxis de modelos, ver el Apéndice B.
Finalmente, debes notar que no hemos definido explícitamente una clave primaria
en ninguno de estos modelos. A no ser que le indiques lo contrario, Django dará
automáticamente a cada modelo un campo de clave primaria entera llamado id.
Es un requerimiento el que cada modelo Django tenga una clave primaria de
columna simple.