SQL

• Hasta ahora, hemos discutido cómo construir páginas web simples utilizando HTML y CSS, y cómo utilizar Git y GitHub para llevar un registro de los cambios en nuestro código y colaborar con otros. También nos familiarizamos con el lenguaje de programación Python y comenzamos a utilizar Django para crear aplicaciones web.
• Hoy aprenderemos a usar SQL y modelos de Django para almacenar y acceder eficientemente a datos.

Antes de adentrarnos en el uso de SQL, es fundamental comprender cómo se almacena la información. En SQL, generalmente trabajamos con bases de datosrelacionales, donde la información se organiza entablas. Cada tabla consta de columnas específicas y un número variable de filas.

Para nuestra ilustración en SQL, consideremos un sitio web de aerolínea que gestiona información sobre vuelos y pasajeros. En la siguiente tabla, registramos diversos vuelos, cada uno con un origen, destino y duración asociados.

Existen varios sistemas de gestión de bases de datos relacionales comúnmente utilizados para almacenar información y que pueden interactuar fácilmente con comandos SQL:

• MySQL
• PostgreeSQL
• SQLite

Los dos primeros, MySQL y PostgreSQL, son sistemas más robustos que generalmente se ejecutan en servidores distintos de aquellos que ejecutan un sitio web. SQLite, por otro lado, es un sistema más liviano que puede almacenar todos sus datos en un único archivo. Utilizaremos SQLite a lo largo de este curso, ya que es el sistema predeterminado utilizado por Django.

Así como trabajamos con varios tipos de variables en Python, SQLite tiene tipos que representan diferentes formas de información. Otros sistemas de gestión pueden tener tipos de datos diferentes, pero todos son bastante similares a los de SQLite:

• TEXT: Para cadenas de texto (por ejemplo, el nombre de una persona)
• NUMERIC: Una forma más general de datos numéricos (por ejemplo, una fecha o un valor booleano)
• INTEGER: Cualquier número no decimal (por ejemplo, la edad de una persona)
• REAL: Cualquier número real (por ejemplo, el peso de una persona)
• BLOB(Objeto Binario Grande): Cualquier otro dato binario que deseemos almacenar en nuestra base de datos (por ejemplo, una imagen)

Ahora, para comenzar a utilizar SQL para interactuar con una base de datos, empecemos por crear una nueva tabla. El comando para crear una nueva tabla se parece a algo como esto:

1CREATE TABLE flights(
2    id INTEGER PRIMARY KEY AUTOINCREMENT,
3    origin TEXT NOT NULL,
4    destination TEXT NOT NULL,
5    duration INTEGER NOT NULL
6);

En el comando anterior, estamos creando una nueva tabla que hemos decidido llamar "flights", y hemos añadido cuatro columnas a esta tabla:

1. id: A menudo es útil tener un número que nos permita identificar de manera única cada fila en una tabla. Aquí hemos especificado que "id" es un número entero y también que es nuestra clave primariaPRIMARY-KEY, lo que significa que es nuestro identificador único. Además, hemos especificado que será AUTOINCREMENT, lo que significa que no tendremos que proporcionar un id cada vez que agreguemos a la tabla, ya que se hará automáticamente.
2. origin: Hemos especificado que este será un campo de texto, y al escribir NOT NULL hemos requerido que tenga un valor.
3. destination: Nuevamente hemos especificado que este será un campo de texto y hemos evitado que sea nulo.
4. duration: Nuevamente, este valor no puede ser nulo, pero esta vez se representa como un número entero en lugar de texto.

Acabamos de ver las restricciones NOT NULL y PRIMARY KEY al hacer una columna, pero hay varias otrasrestrinccionesdisponibles:

• CHECK: Asegura que se cumplan ciertas restricciones antes de permitir que se agregue/modifique una fila.
• DEFAULT: Proporciona un valor predeterminado si no se proporciona ningún valor.
• NOT NULL: Garantiza que se proporcione un valor.
• PRIMARY KEY: Indica que esta es la principal manera de buscar una fila en la base de datos.
• UNIQUE: Asegura que no haya dos filas con el mismo valor en esa columna.
• ...

Ahora que hemos visto cómo crear una tabla, veamos cómo podemos agregar filas a ella. En SQL, hacemos esto mediante el comando INSERT:

1INSERT INTO flights
2(origin, destination, duration)
3VALUES ("New York", "London", 415);

En el comando anterior, hemos especificado el nombre de la tabla en la que deseamos realizar la inserción, luego proporcionamos una lista de los nombres de las columnas para las cuales proporcionaremos información, y luego especificamos los VALORES que deseamos llenar en esa fila de la tabla, asegurándonos de que los VALORES estén en el mismo orden que nuestra lista correspondiente de columnas. Es importante destacar que no es necesario proporcionar un valor para "id" porque se incrementa automáticamente.

Una vez que se ha poblado una tabla con algunas filas, es probable que deseemos una manera de acceder a los datos dentro de esa tabla. Hacemos esto utilizando la consulta SELECT de SQL. La consulta SELECT más simple en nuestra tabla de vuelos podría verse algo así:

1SELECT * FROM flights;

La instrucción anterior (*) recupera todos los datos de nuestra tabla de vuelos.

Puede ser el caso de que realmente no necesitemos todas las columnas de la base de datos, solo origen y destino. Para acceder solo a estas columnas, podemos reemplazar el * con los nombres de las columnas a las que queremos acceder. La siguiente consulta devuelve todos los orígenes y destinos.

1SELECT origin, destination FROM flights;

A medida que nuestras tablas se vuelven más grandes, también querremos reducir las filas que devuelve nuestra consulta. Hacemos esto agregando un WHERE seguido de alguna condición. Por ejemplo, el siguiente comando selecciona solo la fila con un id de 3:

1SELECT * FROM flights WHERE id = 3;

Podemos filtrar por cualquier columna, ¡no solo por id!

1SELECT * FROM flights WHERE origin = "New York";

Ahora que conocemos algunos comandos básicos de SQL, ¡vamos a probarlos en la terminal! Para trabajar con SQLite en tu computadora, primero debes descargar SQLite. (No se usará en este curso, pero también puedes descargarDB Browserpara una forma más amigable de ejecutar consultas SQL).

Podemos empezar creando un archivo para nuestra base de datos, ya sea creando manualmente un nuevo archivo o ejecutandotouch flights.sqlen la terminal. Ahora, si ejecutamossqlite3 flights.sqlen la terminal, nos llevará a un prompt de SQLite donde podemos ejecutar comandos SQL:

1# Ingresando al prompt de SQLite
2(base) % sqlite3 flights.sql
3SQLite version 3.26.0 2018-12-01 12:34:55
4Ingrese ".help" para obtener sugerencias de uso.
5
6# Creando una nueva tabla
7sqlite> CREATE TABLE flights(
8   ...>     id INTEGER PRIMARY KEY AUTOINCREMENT,
9   ...>     origin TEXT NOT NULL,
10   ...>     destination TEXT NOT NULL,
11   ...>     duration INTEGER NOT NULL
12   ...> );
13
14# Listando todas las tablas actuales (solo vuelos por ahora)
15sqlite> .tables
16flights
17
18# Consultando todo dentro de vuelos (que ahora está vacío)
19sqlite> SELECT * FROM flights;
20
21# Agregando un vuelo
22sqlite> INSERT INTO flights
23   ...>     (origin, destination, duration)
24   ...>     VALUES ("Nueva York", "Londres", 415);
25
26# Verificando la nueva información, que ahora podemos ver
27sqlite> SELECT * FROM flights;
281|Nueva York|Londres|415
29
30# Agregando algunos vuelos más
31sqlite> INSERT INTO flights (origin, destination, duration) VALUES ("Shanghái", "París", 760);
32sqlite> INSERT INTO flights (origin, destination, duration) VALUES ("Estambul", "Tokio", 700);
33sqlite> INSERT INTO flights (origin, destination, duration) VALUES ("Nueva York", "París", 435);
34sqlite> INSERT INTO flights (origin, destination, duration) VALUES ("Moscú", "París", 245);
35sqlite> INSERT INTO flights (origin, destination, duration) VALUES ("Lima", "Nueva York", 455);
36
37# Consultando esta nueva información
38sqlite> SELECT * FROM flights;
391|Nueva York|Londres|415
402|Shanghái|París|760
413|Estambul|Tokio|700
424|Nueva York|París|435
435|Moscú|París|245
446|Lima|Nueva York|455
45
46# Cambiando la configuración para hacer que la salida sea más legible
47sqlite> .mode columns
48sqlite> .headers yes
49
50# Consultando toda la información nuevamente
51sqlite> SELECT * FROM flights;
52id          origin      destination  duration
53----------  ----------  -----------  ----------
541           Nueva York  Londres       415
552           Shanghái    París         760
563           Estambul    Tokio         700
574           Nueva York  París         435
585           Moscú       París         245
596           Lima        Nueva York    455
60
61# Buscando solo aquellos vuelos que tienen origen en Nueva York
62sqlite> SELECT * FROM flights WHERE origin = "Nueva York";
63id          origin      destination  duration
64----------  ----------  -----------  ----------
651           Nueva York  Londres       415
664           Nueva York  París         435

También podemos utilizar más que solo la igualdad para filtrar nuestros vuelos. Para valores enteros y reales, podemos usar mayor que o menor que:

1SELECT * FROM flights WHERE duration > 500;

Y también podemos utilizar otras lógicas(AND, OR)como en Python:

1SELECT * FROM flights WHERE duration > 500 AND destination = "Paris";

1SELECT * FROM flights WHERE duration > 500 OR destination = "Paris";

También podemos usar la palabra clave IN para ver si un dato es una de varias opciones:

1SELECT * FROM flights WHERE origin IN ("New York", "Lima");

Incluso podemos usar expresiones regulares para buscar palabras de manera más amplia utilizando la palabra claveLIKE. La siguiente consulta encuentra todos los resultados con una"a"en el origen, utilizando"%"como un carácter comodín.

1SELECT * FROM flights WHERE origin LIKE "%a%";

También hay varias funciones de SQL que podemos aplicar a los resultados de una consulta. Estas pueden ser útiles si no necesitamos todos los datos devueltos por una consulta, sino solo algunas estadísticas resumidas de los datos.

• AVERAGE (PROMEDIO)
• COUNT (CONTAR)
• MAX (MÁXIMO)
• MIN (MÍNIMO)
• SUM (SUMA)
• ...

UPDATE (ACTUALIZAR) Hasta ahora, hemos visto cómo agregar y buscar en tablas, pero también es posible que deseemos actualizar filas de una tabla que ya existe. Hacemos esto utilizando el comandoUPDATE, como se muestra a continuación. Como podrías haber deducido al leer esto en voz alta, el comando encuentra todos los vuelos que van de Nueva York a Londres y luego establece sus duraciones en 430.

1UPDATE flights
2SET duration = 430
3WHERE origin = "New York"
4AND destination = "London";

También es posible que deseemos la capacidad de eliminar filas de nuestra base de datos, y podemos hacer esto utilizando el comando DELETE. El siguiente código eliminará todos los vuelos que aterrizan en Tokio:

1DELETE FROM flights WHERE destination = "Tokyo";

• LIMIT: Limita el número de resultados devueltos por una consulta.
• ORDER BY: Ordena los resultados basándose en una columna especificada.
• GROUP BY: Agrupa los resultados según una columna especificada.
• HAVING: Permite aplicar restricciones adicionales basadas en el número de resultados.

Hasta ahora, solo hemos estado trabajando con una tabla a la vez, pero en la práctica, muchas bases de datos están pobladas por varias tablas que se relacionan de alguna manera. En nuestro ejemplo de vuelos, imaginemos que también queremos agregar un código de aeropuerto junto con la ciudad. De la manera en que está actualmente configurada nuestra tabla, tendríamos que agregar dos columnas más para cada fila. También estaríamos repitiendo información, ya que tendríamos que escribir en varios lugares que la ciudad X está asociada con el código Y.

Una forma de resolver este problema es decidir tener una tabla que lleve un registro de los vuelos y luego otra tabla que lleve un registro de los aeropuertos. La segunda tabla podría tener un aspecto así:

Ahora tenemos una tabla que relaciona códigos y ciudades. En lugar de almacenar todo el nombre de la ciudad en nuestra tabla de vuelos, ahorraríamos espacio de almacenamiento si pudiéramos simplemente guardar elidde ese aeropuerto. Por lo tanto, deberíamos reescribir la tabla de vuelos en consecuencia. Dado que estamos utilizando la columna id de la tabla de aeropuertos para poblarorigin_idydestination_id, llamamos a esos valoresClaves Foráneas.

Además de los vuelos y los aeropuertos, una aerolínea podría querer almacenar datos sobre sus pasajeros, como en qué vuelo estará cada pasajero. Utilizando la potencia de las bases de datos relacionales, podemos agregar otra tabla que almacene nombres y apellidos, y una clave foránea que represente el vuelo en el que se encuentran.

Podemos hacerlo aún mejor, ya que una misma persona puede estar en más de un vuelo. Para tener en cuenta esto, podemos crear una tabla depersonasque almacene nombres y apellidos, y una tabla depasajerosque vincule personas con vuelos.

Debido a que en este caso una sola persona puede estar en muchos vuelos y un solo vuelo puede tener muchas personas, llamamos a la relación entrevuelosypersonasuna relación de Muchos a Muchos. La tabla depasajerosque conecta ambas se conoce como una tabla de asociación.

Aunque ahora almacenamos nuestros datos de manera más eficiente, parece que puede ser más difícil realizar consultas en nuestros datos. Afortunadamente, SQL cuenta con una consultaJOINdonde podemos combinar dos tablas con el fin de realizar otra consulta.

Por ejemplo, digamos que queremos encontrar el origen, destino y nombre de cada viaje que un pasajero está tomando. También, para simplificar en esta tabla, vamos a estar utilizando la tabla depasajerosno optimizada que incluye el id del vuelo, el nombre y apellido. La primera parte de esta consulta se ve bastante familiar:

1SELECT first, origin, destination
2FROM ...

Pero nos encontramos con un problema aquí porque el nombrefirstse almacena en la tabla de pasajeros, mientras que el origenoriginy el destinodestinationse almacenan en la tabla de vuelos. Resolvemos esto uniendo las dos tablas utilizando el hecho de que elflight_iden la tabla de pasajeros corresponde aliden la tabla de vuelos:

1SELECT first, origin, destination
2FROM flights JOIN passengers
3ON passengers.flight_id = flights.id;

Acabamos de utilizar algo llamadoINNER JOIN, lo que significa que estamos ignorando las filas que no tienen coincidencias entre las tablas. Pero existen otros tipos de joins, incluyendoLEFT JOINs,RIGHT JOINsyFULL OUTER JOINs, que no discutiremos en detalle aquí.

Una forma de hacer que nuestras consultas sean más eficientes al trabajar con tablas grandes es crear un índice similar al índice que podrías ver en la parte posterior de un libro de texto. Por ejemplo, si sabemos que a menudo buscaremos pasajeros por su apellido, podríamos crear un índice desde el apellido hasta el id utilizando el comando:

1CREATE INDEX name_index ON passengers (last);

Ahora que conocemos los conceptos básicos de cómo utilizar SQL para trabajar con datos, es importante señalar las principales vulnerabilidades asociadas con el uso de SQL. Comenzaremos con laInyección SQL.

Usuario: ' OR '1'='1'; -- Contraseña: (dejar en blanco)

Si el sitio no está protegido contra inyecciones SQL, esta entrada podría manipular la consulta SQL y permitir al atacante eludir la autenticación y acceder a información no autorizada.

Cuando un usuario malintencionado ingresa código SQL como entrada en un sitio para eludir las medidas de seguridad del sitio. Por ejemplo, supongamos que tenemos una tabla que almacena nombres de usuario y contraseñas, y luego un formulario de inicio de sesión en la página principal del sitio. Podríamos buscar al usuario utilizando una consulta como:

1SELECT * FROM users
2WHERE username = username AND password = password;

Un usuario llamado Neo podría ir a este sitio y escribir"Neo"como nombre de usuario y"12345"como contraseña, en cuyo caso la consulta se vería así:

1SELECT * FROM users
2WHERE username = "neo" AND password = "12345";

Un hacker, por otro lado, podría escribir "neo"--como nombre de usuario y nada como contraseña. Resulta que--representa un comentario en SQL, lo que significa que la consulta se vería así:

1SELECT * FROM users
2WHERE username = "neo"--" AND password = "12345";

Esto podría permitir al hacker acceder a información sin proporcionar una contraseña válida. La Inyección SQL es un problema de seguridad grave, y es crucial tomar medidas para prevenirlo, como validar y sanitizar la entrada del usuario, y utilizar consultas preparadas o procedimientos almacenados. Debido a que en esta consulta se ha comentado la verificación de la contraseña, el hacker puede iniciar sesión en la cuenta de Neo sin conocer su contraseña. Para resolver este problema, podemos utilizar:

1. Caracteres de escape para asegurarnos de que SQL trate la entrada como texto plano y no como código SQL.
2. Una capa de abstracción sobre SQL que incluya su propio conjunto de caracteres de escape, para que no tengamos que escribir consultas SQL nosotros mismos.

La otra vulnerabilidad principal cuando se trata de SQL se conoce como una Condición de Carrera,Race Condition.

Una condición de carrera es una situación que ocurre cuando múltiples consultas a una base de datos se realizan simultáneamente. Cuando no se manejan adecuadamente, pueden surgir problemas en los momentos precisos en que las bases de datos se actualizan. Por ejemplo, supongamos que tengo $150 en mi cuenta bancaria. Una condición de carrera podría ocurrir si inicio sesión en mi cuenta bancaria tanto en mi teléfono como en mi computadora e intento retirar $100 en cada dispositivo. Si los desarrolladores de software del banco no manejan correctamente las condiciones de carrera, podría ser posible retirar $200 de una cuenta que solo tiene $150.

Una solución potencial para este problema sería bloquear la base de datos. No se permitiría ninguna otra interacción con la base de datos hasta que se haya completado una transacción. En el ejemplo del banco, después de hacer clic en la página "Realizar un retiro" en mi computadora, el banco podría no permitirme acceder a esa página en mi teléfono.

Losmodelos de Djangoson un nivel deabstracciónsobre SQL que nos permite trabajar con bases de datos utilizando clases y objetos de Python en lugar de consultas SQL directas.

Comencemos a usar modelos creando un proyecto de Django para nuestra aerolínea y creando una aplicación dentro de ese proyecto.

1django-admin startproject airline
2cd airline
3python manage.py startapp flights

Ahora tendremos que pasar por el proceso de agregar una aplicación como de costumbre:

1. Agrega 'flights' a la lista INSTALLED_APPS ensettings.py.
2. Agrega una ruta para 'flights' enurls.py:
python

1path("flights/", include("flights.urls")),

3. Crea un archivourls.pydentro de la aplicación "flights" y llénalo con las importaciones y listas estándar deurls.py.

Ahora, en lugar de crear rutas reales y empezar con views.py, crearemos algunos modelos en el archivo models.py. En este archivo, delinearemos los datos que queremos almacenar en nuestra aplicación. Luego, Django determinará la sintaxis SQL necesaria para almacenar información sobre cada uno de nuestros modelos. Echemos un vistazo a cómo podría ser el modelo para un vuelo individual:

1class Flight(models.Model):
2origin = models.CharField(max_length=64)
3destination = models.CharField(max_length=64)
4duration = models.IntegerField()

Echemos un vistazo a lo que está sucediendo en esta definición de modelo:

• En la primera línea, creamos un nuevo modelo que extiende la clase de modelo de Django.
• A continuación, agregamos campos para origen, destino y duración. Los dos primeros son camposChar, lo que significa que almacenan cadenas, y el tercero es un campoInteger. Estos son solo dos de las muchasclases de campos integradasen Django.
• Especificamos longitudes máximas de 64 para los dos campos de caracteres. Puedes verificar las especificaciones disponibles para un campo dado consultando ladocumentación.

Ahora, aunque hemos creado un modelo, aún no tenemos una base de datos para almacenar esta información. Para crear una base de datos a partir de nuestros modelos, navegamos al directorio principal de nuestro proyecto y ejecutamos el siguiente comando:

1python manage.py makemigrations

Este comando crea algunos archivos en Python que crearán o editarán nuestra base de datos para poder almacenar lo que tenemos en nuestros modelos. Deberías obtener una salida que se vea algo así como la que se muestra a continuación, y si navegas a tu directorio de migraciones, notarás que se creó un nuevo archivo para nosotros.

A continuación, para aplicar estas migraciones a nuestra base de datos, ejecutamos el siguiente comando:

1python manage.py migrate

Ahora verás que se han aplicado algunas migraciones predeterminadas junto con las nuestras, y también notarás que ahora tenemos un archivo llamadodb.sqlite3en el directorio de nuestro proyecto.

Ahora, para empezar a trabajar añadiendo información y manipulando esta base de datos, podemos ingresar a la consola de Django, donde podemos ejecutar comandos de Python dentro de nuestro proyecto.

1python manage.py shell
2Python 3.7.2 (default, Dec 29 2018, 00:00:04)
3Type 'copyright', 'credits' or 'license' for more information
4IPython 6.5.0 -- An enhanced Interactive Python. Type '?' for help.

1# Importar nuestro modelo de vuelo
2En [1]: from flights.models import Flight
3
4# Crear un nuevo vuelo
5En [2]: f = Flight(origin="Nueva York", destination="Londres", duration=415)
6
7# Insertar ese vuelo en nuestra base de datos
8En [3]: f.save()
9
10# Consultar todos los vuelos almacenados en la base de datos
11En [4]: Flight.objects.all()
12Out[4]: <QuerySet [<Flight: Flight object (1)>]>

Cuando consultamos nuestra base de datos, vemos que obtenemos solo un vuelo llamadoFlight object (1). Este nombre no es muy informativo, pero podemos solucionarlo. Dentro de models.py, definiremos una función__str__que proporciona instrucciones sobre cómo convertir un objeto Flight en una cadena:

1class Flight(models.Model):
2origin = models.CharField(max_length=64)
3destination = models.CharField(max_length=64)
4duration = models.IntegerField()
5      
6def __str__(self):
7    return f"{self.id}: {self.origin} to {self.destination}"

Ahora, cuando regresamos a la consola, nuestra salida es un poco más legible:

1# Crear una variable llamada 'flights' para almacenar los resultados de una consulta
2En [7]: flights = Flight.objects.all()
3
4# Mostrar todos los vuelos
5En [8]: flights
6Out[8]: <QuerySet [<Flight: 1: Nueva York a Londres>]>
7
8# Aislar solo el primer vuelo
9En [9]: flight = flights.first()
10
11# Imprimir información del vuelo
12En [10]: flight
13Out[10]: <Flight: 1: Nueva York a Londres>
14
15# Mostrar el ID del vuelo
16En [11]: flight.id
17Out[11]: 1
18
19# Mostrar el origen del vuelo
20En [12]: flight.origin
21Out[12]: 'Nueva York'
22
23# Mostrar el destino del vuelo
24En [13]: flight.destination
25Out[13]: 'Londres'
26
27# Mostrar la duración del vuelo
28En [14]: flight.duration
29Out[14]: 415

Este es un buen comienzo, pero pensando en lo mencionado anteriormente, no queremos tener que almacenar el nombre de la ciudad como origen y destino para cada vuelo, así que probablemente queremos otro modelo para un aeropuerto que esté de alguna manera relacionado con el modelo de vuelo:

1class Airport(models.Model):
2code = models.CharField(max_length=3)
3city = models.CharField(max_length=64)
4        
5def __str__(self):
6    return f"{self.city} ({self.code})"
7        
8class Flight(models.Model):
9origin = models.ForeignKey(Airport, on_delete=models.CASCADE, related_name="departures")
10destination = models.ForeignKey(Airport, on_delete=models.CASCADE, related_name="arrivals")
11duration = models.IntegerField()
12        
13def __str__(self):
14    return f"{self.id}: {self.origin} to {self.destination}"

Hemos visto todo en nuestra nueva claseAirportantes, pero los cambios en los campos origen y destino dentro de la claseFlightson nuevos para nosotros:

• Especificamos que los campos origen y destino sonForeignKey, lo que significa que se refieren a otro objeto.
• Al ingresarAirportcomo nuestro primer argumento, estamos especificando el tipo de objeto al que se refiere este campo.
• El siguiente argumento,on_delete=models.CASCADE, proporciona instrucciones sobre qué debe suceder si se elimina un aeropuerto. En este caso, especificamos que cuando se elimine un aeropuerto, todos los vuelos asociados a él también deben ser eliminados. Hayotras varias opcionesademás deCASCADE.
• Proporcionamos un nombre relacionado, que nos brinda una forma de buscar todos los vuelos con un aeropuerto dado como origen o destino.
• Cada vez que realizamos cambios enmodels.py, debemos realizar migraciones y luego migrar. Ten en cuenta que es posible que debas eliminar tu vuelo existente de Nueva York a Londres, ya que no encaja con la nueva estructura de la base de datos.

1# Crear nuevas Migraciones
2python manage.py makemigration
3
4# Migrar
5python manage.py migrate

Ahora vamos a probar estos nuevos modelos en la consola de Django

1# Importar todos los modelos
2In [1]: from flights.models import *
3
4# Crear algunos aeropuertos nuevos
5In [2]: jfk = Airport(code="JFK", city="New York")
6In [4]: lhr = Airport(code="LHR", city="London")
7In [6]: cdg = Airport(code="CDG", city="Paris")
8In [9]: nrt = Airport(code="NRT", city="Tokyo")
9
10# Guardar los aeropuertos en la base de datos
11In [3]: jfk.save()
12In [5]: lhr.save()
13In [8]: cdg.save()
14In [10]: nrt.save()
15
16# Añadir un vuelo y guardarlo en la base de datos
17f = Flight(origin=jfk, destination=lhr, duration=414)
18f.save()
19
20# Mostar alguna información sobre vuelos
21In [14]: f
22Out[14]: <Flight: 1: New York (JFK) to London (LHR)>
23In [15]: f.origin
24Out[15]: <Airport: New York (JFK)>
25
26# Utilizando el nombre relacionado para consultar por el aeropuerto de llegada:
27In [17]: lhr.arrivals.all()
28Out[17]: <QuerySet [<Flight: 1: New York (JFK) to London (LHR)>]>

Comenzando nuestra aplicación

Ahora podemos comenzar a construir una aplicación en torno a este proceso de utilizar modelos para interactuar con una base de datos. Comencemos creando una ruta de índice para nuestra aerolínea. Dentro deurls.py:

1urlpatterns = [
2    path('', views.index, name="index"),
3]

Dentro deviews.py

1from django.shortcuts import render
2from .models import Flight, Airport
3
4# Crea tus vistas aquí.
5
6def index(request):
7    return render(request, "flights/index.html", {
8        "flights": Flight.objects.all()
9})

Dentro de nuestro nuevolayout.html

1<!DOCTYPE html>
2<html lang="en">
3    <head>
4        <title>Flights</title>
5    </head>
6    <body>
7        {% block body %}
8        {% endblock %}
9    </body>
10</html>

Dentro de nuestro nuevoindex.html

1{% extends "flights/layout.html" %}
2
3{% block body %}
4    <h1>Flights:</h1>
5    <ul>
6        {% for flight in flights %}
7            <li>Flight {{ flight.id }}: {{ flight.origin }} to {{ flight.destination }}</li>
8        {% endfor %}
9    </ul>
10{% endblock %}

Lo que hemos hecho aquí es crear una página predeterminada donde tenemos una lista de todos los vuelos que hemos creado hasta ahora. Cuando abrimos la página ahora, se ve así:

Ahora, agreguemos algunos vuelos más a nuestra aplicación volviendo a la consola de Django:

1# Utilizando el comando filter para encontrar todos los aeropuertos con base en Nueva York
2En [3]: Airport.objects.filter(city="Nueva York")
3Out[3]: <QuerySet [<Airport: Nueva York (JFK)>]>
4
5# Utilizando el comando get para obtener solo un aeropuerto en Nueva York
6En [5]: Airport.objects.get(city="Nueva York")
7Out[5]: <Airport: Nueva York (JFK)>
8
9# Asignando algunos aeropuertos a nombres de variables:
10En [6]: jfk = Airport.objects.get(city="Nueva York")
11En [7]: cdg = Airport.objects.get(city="París")
12
13# Creando y guardando un nuevo vuelo:
14En [8]: f = Flight(origin=jfk, destination=cdg, duration=435)
15En [9]: f.save()

Ahora cuando visitemos de nuevo nuestro sitio veremos lo siguiente:

Dado que es tan común que los desarrolladores tengan que crear nuevos objetos como lo hemos estado haciendo en la consola, Django viene con una interfaz de administración predeterminada que nos permite hacer esto de manera más fácil. Para comenzar a usar esta herramienta, primero debemos crear un usuario administrativo:

1python manage.py createsuperuser

Luego, sigue las instrucciones para ingresar un nombre de usuario, una dirección de correo electrónico y una contraseña para el superusuario.

Ahora, debemos agregar nuestros modelos a la aplicación de administración al ingresar al archivoadmin.pydentro de nuestra aplicación, e importar y registrar nuestros modelos. Esto le dice a Django a qué modelos queremos tener acceso en la aplicación de administración.

1from django.contrib import admin
2from .models import Flight, Airport
3
4# Registra tus modelos aquí.
5admin.site.register(Flight)
6admin.site.register(Airport)

Ahora, cuando visitamos nuestro sitio y agregamos/admina la URL, podemos iniciar sesión en una página que se ve así:

Después de iniciar sesión, serás llevado a una página como la que se muestra a continuación, donde puedes crear, editar y eliminar objetos almacenados en la base de datos.

Ahora, agreguemos algunas páginas más a nuestro sitio. Comenzaremos por agregar la capacidad de hacer clic en un vuelo para obtener más información al respecto. Para hacer esto, creemos una ruta de URL que incluya el id de un vuelo:

1path("<int:flight_id>", views.flight, name="flight")

Luego, enviews.py, crearemos una funciónflightque tome un id de vuelo y renderice una nueva página HTML:

1def flight(request, flight_id):
2flight = Flight.objects.get(id=flight_id)
3return render(request, "flights/flight.html", {
4    "flight": flight
5})

Ahora crearemos una plantilla para mostrar esta información del vuelo con un enlace de regreso a la página de inicio:

1{% extends "flights/layout.html" %}
2
3{% block body %}
4    <h1>Flight {{ flight.id }}</h1>
5    <ul>
6        <li>Origin: {{ flight.origin }}</li>
7        <li>Destination: {{ flight.destination }}</li>
8        <li>Duration: {{ flight.duration }} minutes</li>
9    </ul>
10    <a href="{% url 'index' %}">All Flights</a>
11{% endblock %}

Finalmente, necesitamos agregar la capacidad de enlazar de una página a otra, así que modificaremos nuestra página de índice para incluir enlaces:

1{% extends "flights/layout.html" %}
2{% block body %}
3<h1>Flights:</h1>
4<ul>
5  {% for flight in flights %}
6  <li><a href="{% url 'flight' flight.id %}">Flight {{ flight.id }}</a>
7  : {{ flight.origin }} to {{ flight.destination }}</li>
8  {% endfor %}
9</ul>
10{% endblock %}

Nuestra página inicial se verá así:

Y cuando hacemos clic en el vuelo 5, por ejemplo, nos lleva a esta página.

Ahora, trabajemos en integrar a los pasajeros en nuestros modelos. Crearemos un modelo de pasajero para empezar:

1class Passenger(models.Model):
2first = models.CharField(max_length=64)
3last = models.CharField(max_length=64)
4flights = models.ManyToManyField(Flight, blank=True, related_name="passengers")
5      
6def __str__(self):
7    return f"{self.first} {self.last}"

Como discutimos, los pasajeros tienen una relación de muchos a muchos con los vuelos, que describimos en Django utilizando el campo ManyToManyField. El primer argumento en este campo es la clase de objetos a la que está relacionado. Hemos proporcionado el argumentoblank=True, lo que significa que un pasajero puede no tener vuelos. También hemos agregado unrelated_nameque cumple el mismo propósito que antes: nos permitirá encontrar a todos los pasajeros en un vuelo dado.

Para realizar estos cambios, debemos realizar migraciones y migrar. Luego podemos registrar el modelo de Pasajero enadmin.pyy visitar la página de administración para crear algunos pasajeros.

Ahora que hemos agregado algunos pasajeros, actualicemos nuestra página de vuelos para que muestre todos los pasajeros en un vuelo. Primero visitaremosviews.pyy actualizaremos nuestra vista de vuelo para proporcionar una lista de pasajeros como contexto. Accedemos a la lista utilizando elrelated_nameque definimos anteriormente.

1def flight(request, flight_id):
2flight = Flight.objects.get(id=flight_id)
3passengers = flight.passengers.all()
4return render(request, "flights/flight.html", {
5    "flight": flight,
6    "passengers": passengers
7})

Ahora agregamos una lista de pasajeros aflight.html:

1<h2>Passengers:</h2>
2<ul>
3    {% for passenger in passengers %}
4        <li>{{ passenger }}</li>
5    {% empty %}
6        <li>No Passengers.</li>
7    {% endfor %}
8</ul>