No tienes acceso a esta clase

¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera

Consulta de datos con tablas relacionadas

7/30
Recursos

¿Cómo consultar datos y sus relaciones en Laravel?

Cuando trabajamos con bases de datos en Laravel, es crucial no solo consultar datos individuales, sino también hacerlo de manera que incluyan las relaciones pertinentes con otras tablas. Imagina que buscas una categoría y necesitas que se incluyan todas las recetas asociadas a ella. Del mismo modo, al buscar etiquetas, estas deben estar vinculadas con sus recetas relevantes. Si buscas una receta específica, ella debe presentar su información relacionada, como la categoría a la que pertenece, su creador y las etiquetas asociadas.

¿Cómo establecer relaciones entre entidades?

Para que Laravel entienda cómo están relacionadas tus tablas, es necesario definir claramente estas relaciones en tus modelos. En el contexto de la clase, se explica cómo registrar relaciones de uno a muchos y de muchos a muchos directamente en el modelo. Aquí te mostramos cómo hacerlo con un ejemplo de categorías y recetas:

// Dentro del modelo de categoría.
public function recetas()
{
    return $this->hasMany(Receta::class);
}

Esta función recetas() indica que una categoría tiene muchas recetas. Así, cuando consultes una categoría, podrás incluir la información de las recetas vinculadas.

¿Cómo cargar relaciones al consultar datos?

En Laravel, existen diferentes maneras de cargar datos junto con sus relaciones. Podemos utilizar métodos como get() y load() dependiendo de si estamos comenzando una nueva consulta o si extendemos una ya existente. Ambos métodos nos permiten incluir datos relacionados para hacer nuestras consultas más ricas y completas.

  • Método get(): Se utiliza cuando se inicia una consulta desde cero. Permite personalizar las consultas para traer, por ejemplo, recetas junto con su categoría, etiquetas y usuario.

  • Método load(): Ideal cuando ya tienes una consulta existente y solo quieres añadir información relacionada. Se usa para cargar datos adicionales en consultas donde ya se ha definido el objeto principal.

¿Cómo aplicar estas configuraciones en otros controladores?

Lo esencial es replicar la misma lógica y estructura para diversas entidades que mantienen relaciones entre sí dentro de la base de datos. No solo aplicamos esto en el controlador de categorías, sino también en el de etiquetas y recetas.

Por ejemplo, al consultarse una etiqueta, es posible especificar que se traigan las recetas conectadas a la misma:

// Dentro del modelo de etiqueta.
public function recetas()
{
    return $this->belongsToMany(Receta::class);
}

Esto asegura que al consultar una etiqueta, Laravel cargue también todas las recetas que están marcadas con dicha etiqueta.

¿Qué consideraciones tener al trabajar con consultas relacionadas?

  • Registro de relaciones: Tener claro que aunque las relaciones existen físicamente en la base de datos, Laravel necesita directrices en el modelo sobre cómo utilizarlas.

  • Flexibilidad de consultas: Al usar métodos como get() y load(), puedes controlar cuánta información necesitas y cómo quieres combinarla.

  • Personalización y optimización: Ajustar las consultas para mostrar solo la información necesaria ayuda a mejorar el rendimiento y la eficiencia de la aplicación.

A medida que experimentas con Laravel, recuerda que práctica constante y una comprensión clara de tus datos y sus interrelaciones son fundamentales para diseñar aplicaciones robustas y eficientes. Si estás usando otro framework, comenta cómo gestionas estas relaciones; compartir experiencias enriquece nuestro aprendizaje mutuo.

Aportes 6

Preguntas 0

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad?

es muy interesante ver la forma como se explican estos conceptos el instructor es muy puntual y ayuda a que se entienda mejor la informacion
`with()` se utiliza cuando se quiere cargar las relaciones junto con el modelo principal durante la consulta inicial. Es útil cuando sabes que necesitarás acceder a las relaciones en el mismo contexto de la consulta principal. `with()` realiza una consulta adicional para cargar las relaciones, pero lo hace de manera eficiente utilizando la técnica de carga ansiosa (eager loading) \# `load()` se utiliza después de la consulta inicial cuando necesitas cargar relaciones en modelos ya recuperados. Es útil cuando necesitas cargar relaciones de modelos que ya tienes en memoria. `load()` realiza una consulta adicional por cada modelo en la colección, lo que puede ser menos eficiente que `with()` si se está cargando un gran número de modelos.

El profesor Italo es muy bueno, se nota que tiene gran manejo del tema y mucha experiencia. Estos conceptos me han quedado claros gracias a su muy buena explicación!

Podemos tambien dar formato a estos datos que vamos a entregar. Normalmente se utilizan  **Resources** para cada uno de los controladores: asi quedó el mio: ```js [ 'title' => $this->title, 'description' => $this->description, 'ingredients' => $this->ingredients, 'instruction' => $this->directions, 'image_url' => $this->image, 'created_at' => $this->created_at, 'owner' => $this->user->name, 'category' => $this->category->name, 'tags' => $this->tags->pluck('name'), ]; ``` Y esto es lo que entrega ```js { "title": "Quas minima in aut voluptas vero molestiae qui.", "description": "Quia dolor quos excepturi sed reprehenderit molestiae ducimus aliquam. Voluptas soluta sed quo aut autem aut voluptatibus. Id nisi inventore dolorum non ea. Harum eum iusto sequi fugit soluta est.", "ingredients": "Ut aut veritatis aut totam ducimus. Aspernatur sit unde facilis voluptate hic quia voluptatem. Dignissimos deleniti et numquam quo nisi. Sed molestias voluptates dolores cupiditate iure.", "instruction": null, "image_url": "https://via.placeholder.com/640x480.png/0022ff?text=asperiores", "created_at": "2024-04-05T03:25:34.000000Z", "owner": "Lenny Funk", "category": "Adipisci", "tags": [ "Rerum", "Dolor" ] }, ```Dejo el link para que le echen una miradita a los resources de eloquent: <https://laravel.com/docs/11.x/eloquent-resources#main-content>
Una cosa mas, puede suceder que en alguna otra parte del código (un código mucho más complejo) necesitemos de las relaciones y no tengamos seguridad si las relaciones ya fueron cargadas o no, para ello usaremos **loadMissing()** esto evitara que inadvertidamente dupliquemos las consultas a la DB. ![](https://static.platzi.com/media/user_upload/2024-10-23%2013.10.58-e3722e3c-9614-499b-b10b-d750192261ca.jpg)
Ya que el profesor hablo de los métodos **with() y load()** quisiera comentar: Esta técnica de cargar las relaciones durante la consulta del modelo principal se llama **EagerLoad (carga ansiosa)** y nos ayudan a prevenir un problema con las consultas hacia las bases de datos llamado **LazyLoad (carga perezosa)** que generan N+1 querys. (esto explicado fácil, es que por cada registro se generan N cantidad de consultas para ir a buscar el modelo relacionado). Por aquí les comparto un código que ubicado en el service provider ayuda a **prevenir Lazy Loads** mientras desarrollamos y así tener un código mas eficiente. El método handleLazyLoad… es para que nos muestra un mensaje amigable de donde estamos fallando. ![](https://static.platzi.com/media/user_upload/2024-08-06%2019.56.18-d35ba2f5-a47f-4d2b-921c-48a8a533c8c8.jpg)