Creación y Gestión de Relaciones entre Modelos en Django

Me encanto el hack que mostraste para hacer interactiva la consola, muy buena esa funcionalidad

Excelente las explicaciones de cada clase, en esta me hubiese gustado que el ejemplo se basara en el modelo Car creado previamente, para continuar con el contexto de los "carros", es decir, para llevar una secuencia lógica del dominio del problema, por que en esta clase hablan de Libros y Editores, que creo no tiene mucho que ver con los Carros.

Aquí comparto la pagina <https://docs.djangoproject.com/en/5.0/ref/models/fields/#field-types>

tipos de datos mas comunes de Django <https://www.freecodecamp.org/news/common-django-model-fields-and-their-use-cases/>

De la documentación (https://docs.djangoproject.com/en/5.0/ref/models/fields/#django.db.models.TextField) es importante notar que `max_length` en un `TextField` solamente restringe la longitud del texto en un widget generado de este modelo; esta restricción no se aplica en el modelo en sí ni en la base de datos. Para hacer esto último se debe usar `CharField` en su lugar.

seria bueno tambien que eplicara en el ejemplo, para que poner el :*verbose\_name*= siento que es de utilidad

Django también tiene una interfaz gráfica por defecto en el admin para crear, actualizar y eliminar registros en las db's, les recomiendo que lo busquen y jueguen un poco con él, les puede ahorrar mucho tiempo si lo que están desarrollando no tiene una ui aún.

Brillante clase combinando SQL con Python. Muy buenos los hacks.

![]()**Relación uno a muchos**![]() Tenemos 2 clases, una depende de la otra. Publisher es un campo de Book así que ahí existe la relación  Ejemplo desde la shell para un registro de ejemplo: ![]()

En Django, las relaciones entre modelos permiten que los datos en diferentes tablas de la base de datos se conecten entre sí. Django ofrece tres tipos principales de relaciones: \*\*One-to-One (uno a uno)\*\*, \*\*One-to-Many (uno a muchos)\*\*, y \*\*Many-to-Many (muchos a muchos)\*\*. A continuación, te explico cómo crear y gestionar estas relaciones en Django. \### 1. \*\*One-to-One Relationship (Uno a Uno)\*\* Una relación uno a uno significa que cada fila en la primera tabla está relacionada con una y solo una fila en la segunda tabla, y viceversa. En Django, se usa `OneToOneField` para definir esta relación. \#### Ejemplo: Usuario y Perfil Supongamos que tienes un modelo `User` y un modelo `Profile`, donde cada usuario tiene exactamente un perfil y cada perfil está asociado a un único usuario. ```python from django.db import models from django.contrib.auth.models import User class Profile(models.Model): user = models.OneToOneField(User, on\_delete=models.CASCADE) bio = models.TextField() website = models.URLField() def \_\_str\_\_(self): return self.user.username ``` \- `on\_delete=models.CASCADE`: Si se elimina el usuario, el perfil también se eliminará automáticamente. \#### Acceso a Datos Relacionados: \- Acceder al perfil desde el usuario: ```python user = User.objects.get(username='john') profile = user.profile # Accede al perfil relacionado ``` \- Acceder al usuario desde el perfil: ```python profile = Profile.objects.get(user=user) user = profile.user # Accede al usuario relacionado ``` \### 2. \*\*One-to-Many Relationship (Uno a Muchos)\*\* Una relación uno a muchos significa que una fila en la primera tabla puede estar relacionada con muchas filas en la segunda tabla, pero cada fila en la segunda tabla está relacionada con una única fila en la primera tabla. En Django, se usa `ForeignKey` para definir esta relación. \#### Ejemplo: Autor y Libro Supongamos que tienes un modelo `Author` y un modelo `Book`, donde un autor puede escribir muchos libros, pero cada libro tiene un solo autor. ```python class Author(models.Model): name = models.CharField(max\_length=100) def \_\_str\_\_(self): return self.name class Book(models.Model): title = models.CharField(max\_length=200) author = models.ForeignKey(Author, on\_delete=models.CASCADE) def \_\_str\_\_(self): return self.title ``` \- `on\_delete=models.CASCADE`: Si se elimina un autor, todos sus libros asociados también se eliminarán. \#### Acceso a Datos Relacionados: \- Acceder a los libros de un autor: ```python author = Author.objects.get(name='J.K. Rowling') books = author.book\_set.all() # Accede a todos los libros relacionados con el autor ``` \- Acceder al autor de un libro: ```python book = Book.objects.get(title='Harry Potter') author = book.author # Accede al autor relacionado ``` \### 3. \*\*Many-to-Many Relationship (Muchos a Muchos)\*\* Una relación muchos a muchos significa que una fila en la primera tabla puede estar relacionada con muchas filas en la segunda tabla y viceversa. En Django, se usa `ManyToManyField` para definir esta relación. \#### Ejemplo: Estudiantes y Cursos Supongamos que tienes un modelo `Student` y un modelo `Course`, donde un estudiante puede inscribirse en muchos cursos, y un curso puede tener muchos estudiantes. ```python class Student(models.Model): name = models.CharField(max\_length=100) def \_\_str\_\_(self): return self.name class Course(models.Model): title = models.CharField(max\_length=200) students = models.ManyToManyField(Student) def \_\_str\_\_(self): return self.title ``` \#### Acceso a Datos Relacionados: \- Acceder a los cursos de un estudiante: ```python student = Student.objects.get(name='Alice') courses = student.course\_set.all() # Accede a todos los cursos en los que está inscrito el estudiante ``` \- Acceder a los estudiantes de un curso: ```python course = Course.objects.get(title='Math 101') students = course.students.all() # Accede a todos los estudiantes inscritos en el curso ``` \### 4. \*\*Personalización y Uso de Relaciones\*\* \#### Relación Inversa Django automáticamente crea relaciones inversas que te permiten acceder al modelo relacionado desde el otro lado de la relación. Puedes personalizar estas relaciones inversas usando el parámetro `related\_name`: ```python class Book(models.Model): title = models.CharField(max\_length=200) author = models.ForeignKey(Author, on\_delete=models.CASCADE, related\_name='books') \# Ahora puedes acceder a los libros de un autor usando author.books en lugar de author.book\_set. ``` \#### Filtrado y Consultas Avanzadas Puedes realizar consultas avanzadas en relaciones usando filtros: ```python \# Obtener todos los libros escritos por un autor específico books\_by\_author = Book.objects.filter(author\_\_name='J.K. Rowling') \# Obtener todos los estudiantes inscritos en un curso específico students\_in\_course = Student.objects.filter(course\_\_title='Math 101') ``` \### 5. \*\*Migraciones\*\* Cada vez que creas o modificas relaciones entre modelos, debes generar y aplicar migraciones para que los cambios se reflejen en la base de datos: ```bash python manage.py makemigrations python manage.py migrate ``` \### Conclusión Django facilita la creación y gestión de relaciones entre modelos, permitiéndote construir estructuras de datos complejas con facilidad. Dependiendo del tipo de relación que necesites (uno a uno, uno a muchos, o muchos a muchos), Django te ofrece herramientas flexibles para definir y manipular estas relaciones.

Okay, this new object that you've just instantiated is accessible from the **shell** \#### We can modify its fields values right there: *remember, the **save()** method needs to be applied to created objects* ```js car1.title= 'Audi' car1.save() ```car1.title= 'Audi' car1.save() . Then enter the **python manage.py dbshell** once again (new terminal tab) to query the tables and verify changes ```js sqlite> select * from my_first_app_car; ``` *don't forget the `;`* ```txt 1|Audi|2024|yellow ``` \#### We can as well delete it, again from the **python manage.py shell** ```js >>> car1.title 'Audi' >>> car1.delete() (1, {'my_first_app.Car': 1}) ``` **delete()** will always return a **tuple** with 2 fields (n°ofObjectsAffected, {the type of object}) Now coming back to the dbshell and repeating the past query we can verify the deletion