\u00bfQu\u00e9 Son las Relaciones en Eloquent?<\/h2>\n
Cuando trabajamos con tablas en una base de datos relacional, podemos caracterizar las relaciones como conexiones entre tablas. Esto te ayuda a organizar y estructurar los datos sin esfuerzo, lo que permite una mayor legibilidad y manejo de los datos. En la pr\u00e1ctica, existen tres tipos de relaciones en las bases de datos:<\/p>\n
- \n
- uno a uno – Un registro de una tabla se asocia con uno, y s\u00f3lo uno, de otra tabla. Por ejemplo, una persona y un n\u00famero de la Seguridad Social.<\/li>\n<\/ul>\n
- \n
- uno a varios – Un registro est\u00e1 asociado a varios registros de otra tabla. Por ejemplo, un escritor y sus blogs.<\/li>\n<\/ul>\n
- \n
- varios-a-varios – Varios registros de una tabla est\u00e1n asociados a varios registros de otra tabla. Por ejemplo, los alumnos y los cursos en los que est\u00e1n matriculados.<\/li>\n<\/ul>\n
Laravel facilita la interacci\u00f3n y la gesti\u00f3n de las relaciones entre bases de datos utilizando la sintaxis orientada a objetos de Eloquent.<\/p>\n
Junto con estas definiciones, Laravel introduce m\u00e1s relaciones, a saber:<\/p>\n
- \n
- Has Many Through<\/li>\n
- Relaciones Polim\u00f3rficas<\/li>\n
- Polim\u00f3rficas de Varios a Varios<\/li>\n<\/ul>\n
Tomemos, por ejemplo, una tienda cuyo inventario contiene diversos art\u00edculos, cada uno en su propia categor\u00eda. Por tanto, dividir la base de datos en varias tablas tiene sentido desde el punto de vista empresarial. Esto conlleva sus propios problemas, ya que no quieres consultar todas y cada una de las tablas.<\/p>\n
Podemos crear f\u00e1cilmente una relaci\u00f3n simple de uno a muchos en Laravel para ayudarnos, por ejemplo, cuando necesitemos consultar los productos, podemos hacerlo utilizando el modelo Producto.<\/p>\n
![\"Esquema](\"https:\/\/kinsta.com\/wp-content\/uploads\/2023\/05\/pasted-image-0-6.png\")
Esquema de base de datos con tres tablas y una tabla conjunta que representa una relaci\u00f3n polim\u00f3rfica<\/figcaption><\/figure>\n Relaci\u00f3n Uno a Uno<\/h2>\n
Al ser la primera relaci\u00f3n b\u00e1sica que ofrece Laravel, asocian dos tablas de forma que una fila de la primera tabla est\u00e1 correlacionada con una sola fila de la otra tabla.<\/p>\n
Para ver esto en acci\u00f3n, tenemos que crear dos modelos con su propia migraci\u00f3n:<\/p>\n
php artisan make:model Tenant \nPhp artisan make:model Rent<\/code><\/pre>\nEn este punto, tenemos dos modelos, uno es el \u00abTenant\u00bb (Inquilino) y el otro es su \u00bb Rent\u00bb (Alquiler).<\/p>\n
<?php\n\nnamespace<\/span> App<\/span>\\Models;\nuse Illuminate\\Database<\/span>\\Eloquent\\Model<\/span>;\n\nclass Tenant extends Model\n{\n \/**\n * Get the rent of a Tenant\n *\/\n public function rent() \n {\n return $this->hasOne(Rent::class);\n }\n}<\/code><\/pre>\nComo eloquent determina la relaci\u00f3n de clave ajena bas\u00e1ndose en el nombre del modelo padre (Inquilino en este caso), el modelo Alquiler asume que existe una clave ajena tenant_id<\/strong>.<\/p>\n
Podemos sobrescribirla f\u00e1cilmente como con un argumento adicional al m\u00e9todo hasOne<\/strong>:<\/p>\n
return $this- >hasOne(Rent::class, \"custom_key\");<\/code><\/pre>\nEloquent tambi\u00e9n asume que existe una coincidencia entre la clave ajena definida y la clave primaria del padre (modelo Inquilino). Por defecto, buscar\u00e1 la coincidencia de tenant_id<\/strong> con la clave id<\/strong> del registro Tenant. Podemos sobrescribir esto con un tercer argumento en el m\u00e9todo hasOne<\/strong>, de forma que coincida con otra clave:<\/p>\n
return $this->hasOne(Rent::class, \"custom_key\", \"other_key\"); <\/code><\/pre>\nAhora que hemos definido la relaci\u00f3n uno a uno entre los modelos, podemos utilizarla f\u00e1cilmente, as\u00ed:<\/p>\n
$rent = Tenant::find(10)->rent;<\/code><\/pre>\nCon esta l\u00ednea de c\u00f3digo, obtenemos el alquiler del inquilino con el id 10 si existe.<\/p>\n
Relaci\u00f3n Uno a Varios<\/h2>\n
Al igual que la relaci\u00f3n anterior, \u00e9sta definir\u00e1 relaciones entre un modelo monoparental y varios modelos hijos. Es poco probable que nuestro Inquilino tenga s\u00f3lo una factura de Alquiler porque es un pago recurrente, por lo tanto, tendr\u00e1 m\u00faltiples pagos.<\/p>\n
En este caso, nuestra relaci\u00f3n anterior tiene defectos, y podemos solucionarlos:<\/p>\n
<?php\n\nnamespace<\/span> App<\/span>\\Models;\nuse Illuminate\\Database<\/span>\\Eloquent\\Model<\/span>;\n\nclass Tenant extends Model\n{\n \/**\n * Get the rents of a Tenant\n *\/\n public function rent() \n {\n return $this->hasMany(Rent::class);\n }\n}<\/code><\/pre>\nAntes de llamar al m\u00e9todo para obtener los alquileres, conviene saber que las relaciones sirven como constructores de consultas, por lo que podemos a\u00f1adir m\u00e1s restricciones (como alquiler entre fechas, pago m\u00ednimo, etc.) y encadenarlas para obtener nuestro resultado deseado:<\/p>\n
$rents = Tenant::find(10)->rent()->where('payment', '>', 500)->first();<\/code><\/pre>\nY como en la relaci\u00f3n anterior, podemos sobrescribir las claves for\u00e1neas y locales pasando argumentos adicionales:<\/p>\n
return $this->hasMany(Rent::class, \"foreign_key\");<\/code><\/pre>\nreturn $this->hasMany(Rent::class, \"foreign_key\", \"local_key\");<\/code><\/pre>\nAhora tenemos todos los alquileres de un inquilino, pero \u00bfqu\u00e9 hacemos cuando conocemos el alquiler y queremos averiguar a qui\u00e9n pertenece? Podemos hacer uso de la propiedad belongsTo<\/strong>:<\/p>\n
<?php\n\nnamespace<\/span> App<\/span>\\Models;\nuse Illuminate\\Database<\/span>\\Eloquent\\Model<\/span>;\n\nclass Rent extends Model\n{\n \/**\n * Return the tenant for the rent\n *\/\n public function tenant() \n {\n return $this->belongsTo(Tenant::class);\n }\n}<\/code><\/pre>\nY ahora podemos obtener el inquilino f\u00e1cilmente:<\/p>\n
$tenant = Rent::find(1)->tenant;<\/code><\/pre>\nPara el m\u00e9todo belongsTo<\/strong>, tambi\u00e9n podemos sobrescribir las claves for\u00e1neas y locales como hicimos antes.<\/p>\n
Relaci\u00f3n Has-One-Of-Many<\/h2>\n
Como nuestro modelo de Inquilino puede estar asociado a muchos modelos de Alquiler, queremos recuperar f\u00e1cilmente el modelo relacionado m\u00e1s reciente o m\u00e1s antiguo de las relaciones.<\/p>\n
Una forma c\u00f3moda de hacerlo es combinar los m\u00e9todos hasOne<\/strong> y ofMany<\/strong>:<\/p>\n
public function latestRent() {\n return $this->hasOne(Rent::class)->latestOfMany();\n}\n\npublic function oldestRent() {\n return $this->hasOne(Rent::class)->oldestOfMany();\n}<\/code><\/pre>\nPor defecto, obtenemos los datos bas\u00e1ndonos en la clave primaria, que es ordenable, pero podemos crear nuestros propios filtros para el m\u00e9todo ofMany<\/strong>:<\/p>\n
return $this->hasOne(Rent::class)->ofMany('price', 'min');<\/code><\/pre>\nRelaciones HasOneThrough y HasManyThrough<\/h2>\n
Los m\u00e9todos -Through <\/strong>sugieren que nuestros modelos tendr\u00e1n que pasar por otro modelo para establecer una relaci\u00f3n con el modelo deseado. Por ejemplo, podemos asociar el Alquiler con el Arrendador, pero el Alquiler debe pasar primero por el Arrendatario para llegar al Arrendador.<\/p>\n
Las claves de las tablas necesarias para ello tendr\u00edan el siguiente aspecto:<\/p>\n
rent\n id - integer\n name - string\n value - double\n\ntenants\n id - integer\n name - string\n rent_id - integer\n\nlandlord\n id - integer\n name - string\n tenant_id - integer<\/code><\/pre>\nDespu\u00e9s de visualizar el aspecto de nuestras tablas, podemos hacer los modelos:<\/p>\n
<?php\n\nnamespace<\/span> App<\/span>\\Models;\nuse Illuminate\\Database<\/span>\\Eloquent\\Model<\/span>;\n\nclass Rent extends Model\n{\n \/**\n * Return the rents' landlord\n *\/\n public function rentLandlord() \n {\n return $this->hasOneThrough(Landlord::class, Tenant::class);\n }\n}<\/code><\/pre>\nEl primer argumento del m\u00e9todo hasOneThrough<\/strong> es el modelo al que quieres acceder, y el segundo argumento es el modelo por el que pasar\u00e1s.<\/p>\n
Y al igual que antes, puedes sobrescribir las claves for\u00e1neas y locales. Ahora que tenemos dos modelos, tenemos dos de cada para sobrescribir en este orden:<\/p>\n
public function rentLandlord() \n{\n return $this->hasOneThrough(\n Landlord::class,\n Tenant::class,\n \"rent_id\", \/\/ Foreign key on the tenant table\n \"tenant_id\", \/\/ Foreign key on the landlord table\n \"id\", \/\/ Local key on the tenant class\n \"id\" \/\/ Local key on the tenant table\n );\n}<\/code><\/pre>\nDel mismo modo, la relaci\u00f3n \u00abHas Many Through\u00bb de Laravel Eloquent es \u00fatil cuando quieres acceder a registros de una tabla lejana a trav\u00e9s de una tabla intermedia. Consideremos un ejemplo con tres tablas:<\/p>\n
- \n
- pa\u00eds<\/li>\n
- usuarios<\/li>\n
- juegos<\/li>\n<\/ul>\n
Cada Pa\u00eds tiene muchos Usuarios, y cada Usuario tiene muchos Juegos. Queremos recuperar todos los Juegos pertenecientes a un Pa\u00eds a trav\u00e9s de la tabla Usuario.<\/p>\n
Definir\u00edas las tablas as\u00ed<\/p>\n
country\n id - integer\n name - string\n\nuser\n id - integer\n country_id - integer\n name - string\n\ngames\n id - integer\n user_id - integer\n title - string<\/code><\/pre>\nAhora debes definir el modelo Eloquent para cada una de las tablas:<\/p>\n
<?php\n\nnamespace<\/span> App<\/span>\\Models;\nuse Illuminate\\Database<\/span>\\Eloquent\\Model<\/span>;\n\nclass Country extends Model\n{\n protected $fillable = ['name'];\n\n public function users()\n {\n return $this->hasMany(User::class);\n }\n\n public function games()\n {\n return $this->hasManyThrough(Games::class, User::class);\n }\n}<\/code><\/pre>\n<?php\n\nnamespace<\/span> App<\/span>\\Models;\nuse Illuminate\\Database<\/span>\\Eloquent\\Model<\/span>;\n\nclass User extends Model\n{\n protected $fillable = [article_id, 'name'];\n\n public function country()\n {\n return $this->belongsTo(Country::class);\n }\n\n public function posts()\n {\n return $this->hasMany(Post::class);\n }\n}<\/code><\/pre>\n<?php\n\nnamespace<\/span> App<\/span>\\Models;\nuse Illuminate\\Database<\/span>\\Eloquent\\Model<\/span>;\n\nclass Game extends Model\n{\n protected $fillable = ['user_id', 'title'];\n\n public function user()\n {\n return $this->belongsTo(User::class);\n }\n}<\/code><\/pre>\nAhora podemos llamar al m\u00e9todo games() <\/strong>del modelo Pa\u00eds para obtener todos los juegos porque hemos establecido la relaci\u00f3n \u00abHas Many Through\u00bb entre Pa\u00eds y Juego a trav\u00e9s del modelo Usuario.<\/p>\n
<?php\n\n$country = Country::find(159);\n \n\/\/ Retrieve all games for the country\n$games = $country->games;<\/code><\/pre>\nRelaci\u00f3n Varios-a-Varios<\/h2>\n
La relaci\u00f3n varios-a-varios es m\u00e1s complicada. Un buen ejemplo es un empleado que tiene varios roles. Un rol tambi\u00e9n puede asignarse a varios empleados. \u00c9sta es la base de la relaci\u00f3n de muchos a muchos.<\/p>\n
Para ello, debemos tener las tablas employees<\/strong>,\u00a0roles<\/strong> y\u00a0role_employees<\/strong>.<\/p>\n
La estructura de las tablas de nuestra base de datos ser\u00e1 la siguiente<\/p>\n
employees\n id - integer\n name - string\n\nroles \n id - integer\n name - string\n\nrole_employees\n user_id - integer\n role_id - integer<\/code><\/pre>\nConociendo la estructura de tablas de la relaci\u00f3n, podemos definir f\u00e1cilmente nuestro modelo de Employee<\/strong> para belongsToMany Role<\/strong> model.<\/p>\n
<?php\n\nnamespace<\/span> App<\/span>\\Models;\nuse Illuminate\\Database<\/span>\\Eloquent\\Model<\/span>;\n\nclass Employee extends Model\n{\n public function roles() \n {\n return $this- >belongsToMany(Role::class);\n }\n}<\/code><\/pre>\nUna vez definido esto, podemos acceder a todos los roles de un empleado e incluso filtrarlos:<\/p>\n
$employee = Employee::find(1);\n$employee->roles->forEach(function($role) { \/\/ });\n\n\/\/ OR \n\n$employee = Employee::find(1)->roles()->orderBy('name')->where('name', 'admin')->get();<\/code><\/pre>\nComo todos los dem\u00e1s m\u00e9todos, podemos sobrescribir las claves for\u00e1neas y locales del m\u00e9todo belongsToMany<\/strong>.<\/p>\n
Para definir la relaci\u00f3n inversa del belongsToMany<\/strong> simplemente utilizamos el mismo m\u00e9todo pero sobre el m\u00e9todo hijo ahora, con el padre como argumento.<\/p>\n
<?php\n\nnamespace<\/span> App<\/span>\\Models;\nuse Illuminate\\Database<\/span>\\Eloquent\\Model<\/span>;\n\nclass Role extends Model\n{\n public function employees() \n {\n return $this->belongsToMany(Employee::class);\n }\n}<\/code><\/pre>\nUsos de la tabla intermedia<\/h3>\n
Como habr\u00e1s notado, cuando utilizamos la relaci\u00f3n varios-a-varios, siempre se supone que tenemos una tabla intermedia. En este caso, estamos utilizando la tabla role_employees<\/strong>.<\/p>\n
Por defecto, nuestra tabla pivotante contendr\u00e1 s\u00f3lo los atributos id. Si queremos otros atributos, tenemos que especificarlos as\u00ed:<\/p>\n
return $this->belongsToMany(Employee::class)->withPivot(\"active\", \"created_at\");<\/code><\/pre>\nSi queremos abreviar el pivote para las marcas de tiempo, podemos hacerlo:<\/p>\n
return $this->belongsToMany(Employee::class)->withTimestamps();<\/code><\/pre>\nUn truco que hay que saber es que podemos personalizar el nombre \u00abpivote\u00bb en cualquier cosa que se adapte mejor a nuestra aplicaci\u00f3n:<\/p>\n
return $this->belongsToMany(Employee::class)->as('subscription')->withPivot(\"active\", \"created_by\");<\/code><\/pre>\nFiltrar los resultados de una consulta elocuente es un conocimiento imprescindible para cualquier desarrollador que quiera dar un paso adelante y optimizar sus aplicaciones Laravel<\/a>.<\/p>\n
Por lo tanto, Laravel proporciona una fant\u00e1stica caracter\u00edstica de pivotes que se puede utilizar para filtrar los datos que queremos recopilar. As\u00ed, en lugar de utilizar otras funciones como las transacciones de base de datos<\/a> para obtener nuestros datos a trozos, podemos filtrarlos con m\u00e9todos \u00fatiles como wherePivot, wherePivotIn, wherePivotNotIn, wherePivotBetween, wherePivotNotBetween, wherePivotNull, wherePivotNotNull<\/strong> \u00a1y podemos utilizarlos al definir relaciones entre tablas!<\/p>\n
return $this->belongsToMany(Employee::class)->wherePivot('promoted', 1);\nreturn $this->belongsToMany(Employee::class)->wherePivotIn('level', [1, 2]);\nreturn $this->belongsToMany(Employee::class)->wherePivotNotIn('level', [2, 3]);\nreturn $this->belongsToMany(Employee::class)->wherePivotBetween('posted_at', ['2023-01-01 00:00:00', '2023-01-02 00:00:00']);\nreturn $this->belongsToMany(Employee::class)->wherePivotNull('expired_at');\nreturn $this->belongsToMany(Employee::class)->wherePivotNotNull('posted_at');<\/code><\/pre>\nUna \u00faltima caracter\u00edstica sorprendente es que podemos ordenar por pivotes:<\/p>\n
return $this->belongsToMany(Employee::class)\n ->where('promoted', true)\n ->orderByPivot('hired_at', 'desc');<\/code><\/pre>\nRelaciones Polim\u00f3rficas<\/h2>\n
La palabra Polim\u00f3rfico viene del griego, y significa \u00abmuchas formas\u00bb As\u00ed, un modelo de nuestra aplicaci\u00f3n puede adoptar muchas formas, es decir, puede tener m\u00e1s de una asociaci\u00f3n. Imagina que estamos construyendo una aplicaci\u00f3n con blogs, v\u00eddeos, encuestas, etc. Un usuario puede crear un comentario para cualquiera de ellos. Por tanto, un modelo Comentario<\/strong> podr\u00eda pertenecer a los modelos Blogs<\/strong>, V\u00eddeos<\/strong> y Encuestas<\/strong>.<\/p>\n
Polim\u00f3rfico Uno a Uno<\/h2>\n
Este tipo de relaci\u00f3n es similar a una relaci\u00f3n est\u00e1ndar uno a uno. La \u00fanica diferencia es que el modelo hijo puede pertenecer a m\u00e1s de un tipo de modelo con una \u00fanica asociaci\u00f3n.<\/p>\n
Tomemos, por ejemplo, un modelo de Tenant<\/strong>\u00a0<\/strong>y Landlord<\/strong>, puede compartir una relaci\u00f3n polim\u00f3rfica con un modelo de WaterBill<\/strong>.<\/p>\n
La estructura de la tabla puede ser la siguiente:<\/p>\n
tenants\n id \u2013 integer\n name \u2013 string\n\nlandlords\n id \u2013 integer\n name \u2013 string\n\nwaterbills\n id \u2013 integer\n amount \u2013 double\n waterbillable_id\n waterbillable_type<\/code><\/pre>\nUtilizamos waterbillable_id para el id del landlord\u00a0<\/strong>o tenant<\/strong>, mientras que waterbillable_type contiene el nombre de la clase del modelo padre. La columna tipo la utiliza eloquent para averiguar qu\u00e9 modelo padre debe devolver.<\/p>\n
La definici\u00f3n del modelo para una relaci\u00f3n de este tipo tendr\u00e1 el siguiente aspecto:<\/p>\n
<?php\n\nnamespace<\/span> App<\/span>\\Models;\nuse Illuminate\\Database<\/span>\\Eloquent\\Model<\/span>;\n\nclass WaterBill extends Model\n{\n public function billable()\n {\n return $this->morphTo();\n }\n}\n\nclass Tenant extends Model\n{\n public function waterBill() \n {\n return $this->morphOne(WaterBill::class, 'billable');\n }\n}\n\nclass Landlord extends Model\n{\n public function waterBill() \n {\n return $this->morphOne(WaterBill::class, 'billable');\n }\n}<\/code><\/pre>\nUna vez que tengamos todo esto en su sitio, podremos acceder a los datos tanto del modelo Propietario como del modelo Inquilino:<\/p>\n
<?php\n\n$tenant = Tenant::find(1)->waterBill;\n$landlord = Landlord::find(1)->waterBill;<\/code><\/pre>\nPolim\u00f3rfico Uno a Varios<\/h2>\n
Es similar a una relaci\u00f3n normal de uno a varios, la \u00fanica diferencia clave es que el modelo hijo puede pertenecer a m\u00e1s de un tipo de modelo, utilizando una \u00fanica asociaci\u00f3n.<\/p>\n
En una aplicaci\u00f3n como Facebook, los usuarios pueden comentar publicaciones, v\u00eddeos, encuestas, directos, etc. Con un uno a muchos polim\u00f3rfico, podemos utilizar una \u00fanica tabla de comentarios<\/strong> para almacenar los comentarios de todas las categor\u00edas que tengamos. La estructura de nuestra tabla ser\u00eda algo as\u00ed<\/p>\n
posts \n id \u2013 integer\n title \u2013 string\n body \u2013 text\n\nvideos\n id \u2013 integer\n title \u2013 string\n url \u2013 string\n\npolls\n id \u2013 integer\n title \u2013 string\n\ncomments \n id \u2013 integer\n body \u2013 text\n commentable_id \u2013 integer\n commentable_type \u2013 string<\/code><\/pre>\nEl commentable_id siendo el id del registro, y el commentable_type siendo el tipo de clase, para que eloquent sepa qu\u00e9 buscar. En cuanto a la estructura del modelo, es muy similar al polim\u00f3rfico uno a muchos:<\/p>\n
<?php\n\nnamespace<\/span> App<\/span>\\Models;\nuse Illuminate\\Database<\/span>\\Eloquent\\Model<\/span>;\n\nclass Comment extends Model \n{\n public function commentable()\n {\n return $this->morphTo();\n }\n}\n\nclass Poll extends Model\n{\n public function comments()\n {\n return $this->morphMany(Comment::class, 'commentable');\n }\n}\n\nclass Live extends Model\n{\n public function comments()\n {\n return $this->morphMany(Comments::class, 'commentable');\n }\n}<\/code><\/pre>\nAhora, para recuperar los comentarios de un Vivo, basta con llamar al m\u00e9todo encontrar con el id, y ya tenemos acceso a la clase iterable comentarios:<\/p>\n
<?php\n\nuse App<\/span>\\Models\\Live;\n\n$live = Live::find(1);\n\nforeach ($live->comments as $comment) { }\n\n\/\/ OR\n\nLive::find(1)->comments()->each(function($comment) { \/\/ });\nLive::find(1)->comments()->map(function($comment) { \/\/ });\nLive::find(1)->comments()->filter(function($comment) { \/\/ });\n\n\/\/ etc.<\/code><\/pre>\nY si tenemos el comentario y queremos averiguar a qui\u00e9n pertenece, accedemos al m\u00e9todo commentable:<\/p>\n
<?php\n\nuse App<\/span>\\Models\\Comment<\/span>;\n\n$comment = Comment::find(10);\n$commentable = $comment->commentable;\n\n\/\/ commentable \u2013 type of Post, Video, Poll, Live<\/code><\/pre>\nPolim\u00f3rfico Uno a Varios<\/h2>\n
En muchas aplicaciones que escalan, queremos una forma f\u00e1cil de interactuar con los modelos y entre ellos. Podemos querer el primer o el \u00faltimo comentario de un usuario, lo que puede hacerse con una combinaci\u00f3n de m\u00e9todos morphOne<\/strong> y ofMany<\/strong>:<\/p>\n
<?php\n\npublic function latestPost()\n{\n return $this->morphOne(Post::class, 'postable')->latestOfMany();\n}\n\npublic function oldestPost()\n{\n return $this->morphOne(Post::class, 'postable')->oldestOfMany();\n}<\/code><\/pre>\nLos m\u00e9todos latestOfMany<\/strong> y oldestOfMany <\/strong>recuperan el modelo m\u00e1s reciente o m\u00e1s antiguo bas\u00e1ndose en la clave primaria del modelo, que era la condici\u00f3n de que fuera ordenable.<\/p>\n
En algunos casos, no queremos ordenar por el ID, tal vez cambiamos la fecha de publicaci\u00f3n de algunas entradas y las queremos en ese orden, no por su id.<\/p>\n
Para ello podemos pasar 2 par\u00e1metros al m\u00e9todo ofMany<\/strong>. El primer par\u00e1metro es la clave<\/strong> por la que queremos filtrar, y el segundo es el m\u00e9todo de ordenaci\u00f3n<\/strong>:<\/p>\n
<?php\n\npublic function latestPublishedPost()\n{\n return $this->morphOne(Post::class, \"postable\")->ofMany(\"published_at\", \"max\");\n}<\/code><\/pre>\nTeniendo esto en cuenta, \u00a1es posible construir relaciones m\u00e1s avanzadas para esto! Imagina que tenemos este escenario. Se nos pide que generemos una lista de todas las entradas actuales en el orden en que han sido publicadas. El problema surge cuando tenemos 2 entradas con el mismo valor de published_at y cuando las entradas est\u00e1n programadas para publicarse en el futuro.<\/p>\n
Para ello, podemos pasar al m\u00e9todo ofMany<\/strong> el orden en el que queremos que se apliquen los filtros. De esta forma ordenamos por published_at, y si son iguales, ordenamos por id. En segundo lugar, podemos aplicar una funci\u00f3n de consulta al m\u00e9todo ofMany<\/strong> para excluir todas las entradas cuya publicaci\u00f3n est\u00e9 programada<\/p>\n
<?php\n\npublic function currentPosts()\n{\n return $this->hasOne(Post::class)->ofMany([\n 'published_at' => 'max',\n 'id' => 'max',\n ], function ($query) {\n $query->where('published_at', '<', now());\n });\n}<\/code><\/pre>\nPolim\u00f3rfico Varios a Varios<\/h2>\n
El varios-a-varios polim\u00f3rfico es ligeramente m\u00e1s complejo que el normal. Una situaci\u00f3n com\u00fan es tener etiquetas que se aplican a m\u00e1s activos en tu aplicaci\u00f3n. Por ejemplo, en TikTok, tenemos etiquetas que se pueden aplicar a V\u00eddeos, Cortos, Historias, etc.<\/p>\n
El polim\u00f3rfico varios-a-varios nos permite tener una \u00fanica tabla de etiquetas asociadas a los V\u00eddeos, Cortos e Historias.<\/p>\n
La estructura de la tabla es sencilla:<\/p>\n
videos\n id \u2013 integer\n description \u2013 string\n\nstories \n id \u2013 integer\n description \u2013 string\n\ntaggables \n tag_id \u2013 integer\n taggable_id \u2013 integer\n taggable_type \u2013 string<\/code><\/pre>\nCon las tablas listas, podemos hacer el modelo y utilizar el m\u00e9todo morphToMany<\/strong>. Este m\u00e9todo acepta el nombre de la clase del modelo y el \u00abnombre de la relaci\u00f3n\u00bb:<\/p>\n
<?php\n\nnamespace<\/span> App<\/span>\\Models;\nuse Illuminate\\Database<\/span>\\Eloquent\\Model<\/span>;\n\nclass Video extends Model\n{\n public function tags()\n {\n return $this->morphToMany(Tag::class, 'taggable');\n }\n}<\/code><\/pre>\nY con esto, podemos definir f\u00e1cilmente la relaci\u00f3n inversa. Sabemos que para cada modelo hijo queremos llamar al m\u00e9todo morphedByMany<\/strong>:<\/p>\n
<?php\n\nnamespace<\/span> App<\/span>\\Models;\nuse Illuminate\\Database<\/span>\\Eloquent\\Model<\/span>;\n\nclass Tag extends Model\n{\n public function stories()\n {\n return $this->morphedByMany(Story::class, 'taggable');\n }\n\n public function videos()\n {\n return $this->morphedByMany(Video::class, 'taggable');\n } \n}<\/code><\/pre>\nY ahora, cuando obtengamos una etiqueta, \u00a1podremos recuperar todos los v\u00eddeos e historias relacionados con esa etiqueta!<\/p>\n
<?php\nuse App<\/span>\\Model<\/span>\\Tag<\/span>;\n\n$tag = Tag::find(10);\n$posts = $tag->stories;\n$videos = $tag->stories;<\/code><\/pre>\nOptimiza la velocidad de Eloquent<\/h2>\n
Cuando trabajes con el ORM Eloquent de Laravel, es esencial que sepas c\u00f3mo optimizar las consultas a la base de datos y minimizar la cantidad de tiempo y memoria que requiere la obtenci\u00f3n de datos. Una forma de hacerlo es implementando el almacenamiento en cach\u00e9<\/a> en tu aplicaci\u00f3n.<\/p>\n
Laravel proporciona un sistema de almacenamiento en cach\u00e9 flexible que admite varios backends, como Redis<\/a>, Memcached<\/a> y almacenamiento en cach\u00e9 basado en archivos<\/a>. Al almacenar en cach\u00e9 los resultados de las consultas de Eloquent, puedes reducir el n\u00famero de consultas a la base de datos, haciendo que tu aplicaci\u00f3n sea m\u00e1s r\u00e1pida y valiosa.<\/p>\n
Adem\u00e1s, puedes utilizar el constructor de consultas<\/a> de Laravel para crear consultas complejas adicionales, optimizando a\u00fan m\u00e1s el rendimiento de tu aplicaci\u00f3n.<\/p>\n
Resumen<\/h2>\n
En conclusi\u00f3n, las relaciones Eloquent son una potente caracter\u00edstica de Laravel que permite a los desarrolladores trabajar f\u00e1cilmente con datos relacionados. Desde relaciones uno a uno hasta relaciones varios a varios, Eloquent proporciona una sintaxis sencilla e intuitiva para definir y consultar estas relaciones.<\/p>\n
Como desarrollador de Laravel, dominar las relaciones Eloquent puede mejorar enormemente tu flujo de trabajo de desarrollo y hacer que tu c\u00f3digo sea m\u00e1s eficiente y legible. Si est\u00e1s interesado en aprender m\u00e1s sobre Laravel, Kinsta tiene varios recursos disponibles, incluido un tutorial<\/a> sobre c\u00f3mo empezar con Laravel y un art\u00edculo sobre los salarios de los desarrolladores de Laravel.<\/a><\/p>\n
- varios-a-varios – Varios registros de una tabla est\u00e1n asociados a varios registros de otra tabla. Por ejemplo, los alumnos y los cursos en los que est\u00e1n matriculados.<\/li>\n<\/ul>\n
- uno a varios – Un registro est\u00e1 asociado a varios registros de otra tabla. Por ejemplo, un escritor y sus blogs.<\/li>\n<\/ul>\n