O que s\u00e3o relacionamentos no Eloquent?<\/h2>\n
Ao trabalhar com tabelas em um banco de dados relacional, podemos caracterizar os relacionamentos como conex\u00f5es entre tabelas. Isso ajuda voc\u00ea a organizar e estruturar os dados sem esfor\u00e7o, permitindo maior legibilidade e manuseio dos dados. Na pr\u00e1tica, existem tr\u00eas tipos de relacionamentos do banco de dados:<\/p>\n
- \n
- um-para-um – Um registro em uma tabela est\u00e1 associado a um, e somente um, em outra tabela. Por exemplo, uma pessoa e um n\u00famero de seguro social.<\/li>\n<\/ul>\n
- \n
- um-para-muitos – Um registro est\u00e1 associado a v\u00e1rios registros em outra tabela. Por exemplo, um escritor e seus blogs.<\/li>\n<\/ul>\n
- \n
- muitos-para-muitos – V\u00e1rios registros em uma tabela s\u00e3o associados a v\u00e1rios registros em outra tabela. Por exemplo, alunos e os cursos em que est\u00e3o matriculados.<\/li>\n<\/ul>\n
Com o Laravel, voc\u00ea pode interagir e gerenciar facilmente os relacionamentos do banco de dados usando a sintaxe orientada a objetos no Eloquent.<\/p>\n
Al\u00e9m dessas defini\u00e7\u00f5es, o Laravel introduz outros tipos de relacionamentos, como:<\/p>\n
- \n
- Has Many Through (Tem Muitos Atrav\u00e9s)<\/li>\n
- Polymorphic Relations (Rela\u00e7\u00f5es Polim\u00f3rficas)<\/li>\n
- Many-to-many Polymorphic (Muitos-para-muitos Polim\u00f3rficos)<\/li>\n<\/ul>\n
Por exemplo, considere uma loja cujo estoque cont\u00e9m uma variedade de artigos, cada um em sua pr\u00f3pria categoria. Portanto, dividir o banco de dados em v\u00e1rias tabelas faz sentido do ponto de vista comercial. No entanto, isso vem com seus pr\u00f3prios desafios, j\u00e1 que voc\u00ea n\u00e3o deseja consultar cada tabela individualmente.<\/p>\n
Podemos criar facilmente uma rela\u00e7\u00e3o simples de um-para-muitos no Laravel para nos ajudar, como quando precisamos consultar os produtos, podemos fazer isso usando o modelo Product.<\/p>\n
![\"Schema](\"https:\/\/kinsta.com\/wp-content\/uploads\/2023\/05\/pasted-image-0-6.png\")
Schema do banco de dados com tr\u00eas tabelas e uma tabela conjunta representando um relacionamento polim\u00f3rfico.<\/figcaption><\/figure>\n Relacionamento um-para-um<\/h2>\n
Sendo a primeira rela\u00e7\u00e3o b\u00e1sica que o Laravel oferece, ela associa duas tabelas de forma que uma linha da primeira tabela esteja correlacionada com apenas uma linha da outra tabela.<\/p>\n
Para ver isso em a\u00e7\u00e3o, temos de criar dois modelos com sua pr\u00f3pria migra\u00e7\u00e3o:<\/p>\n
php artisan make:model Tenant \nPhp artisan make:model Rent<\/code><\/pre>\nNeste ponto, temos dois modelos: um \u00e9 o Tenant (locat\u00e1rio) e o outro \u00e9 o Rent (aluguel).<\/p>\n
<?php\n\nnamespace App\\Models;\nuse Illuminate\\Database\\Eloquent\\Model;\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 o Eloquent determina o relacionamento de chave estrangeira com base no nome do modelo principal (Tenant, nesse caso), o modelo Rent pressup\u00f5e que existe uma chave estrangeira tenant_id<\/strong>.<\/p>\n
Voc\u00ea pode substitu\u00ed-la facilmente com um argumento adicional para o m\u00e9todo hasOne<\/strong>:<\/p>\n
return $this- >hasOne(Rent::class, \"custom_key\");<\/code><\/pre>\nO Eloquent tamb\u00e9m assume que existe uma correspond\u00eancia entre a chave estrangeira definida e a chave prim\u00e1ria do principal (modelo Tenant). Por padr\u00e3o, ele procurar\u00e1 fazer a correspond\u00eancia entre tenant_id<\/strong> e a chave id<\/strong> do registro Tenant. Podemos substituir isso por um terceiro argumento no m\u00e9todo hasOne<\/strong>, de modo que ele corresponda a outra chave:<\/p>\n
return $this->hasOne(Rent::class, \"custom_key\", \"other_key\"); <\/code><\/pre>\nAgora que definimos a rela\u00e7\u00e3o de um-para-um entre os modelos, podemos us\u00e1-la facilmente, assim:<\/p>\n
$rent = Tenant::find(10)->rent;<\/code><\/pre>\nCom essa linha de c\u00f3digo, obtemos o aluguel do locat\u00e1rio com o ID 10, caso ele exista.<\/p>\n
Relacionamento um-para-muitos<\/h2>\n
Assim como o relacionamento anterior, este definir\u00e1 relacionamentos entre um modelo principal \u00fanico e v\u00e1rios modelos secund\u00e1rios. \u00c9 improv\u00e1vel que nosso locat\u00e1rio tenha apenas uma conta de aluguel, pois se trata de um pagamento recorrente, portanto, ele ter\u00e1 v\u00e1rios pagamentos.<\/p>\n
Nesse caso, nosso relacionamento anterior tem falhas, e podemos corrigi-las:<\/p>\n
<?php\n\nnamespace App\\Models;\nuse Illuminate\\Database\\Eloquent\\Model;\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 chamarmos o m\u00e9todo para obter os alugu\u00e9is, \u00e9 bom saber que as rela\u00e7\u00f5es servem como construtores de consultas, portanto, podemos adicionar restri\u00e7\u00f5es (como aluguel entre datas, pagamento m\u00ednimo etc.) e encade\u00e1-las para obter o resultado desejado:<\/p>\n
$rents = Tenant::find(10)->rent()->where('payment', '>', 500)->first();<\/code><\/pre>\nE, como na rela\u00e7\u00e3o anterior, podemos substituir as chaves estrangeiras e locais passando argumentos adicionais:<\/p>\n
return $this->hasMany(Rent::class, \"foreign_key\");<\/code><\/pre>\nreturn $this->hasMany(Rent::class, \"foreign_key\", \"local_key\");<\/code><\/pre>\nAgora temos todos os alugu\u00e9is de um locat\u00e1rio, mas o que fazemos quando sabemos o valor do aluguel e queremos descobrir a quem ele pertence? Podemos usar a propriedade belongsTo<\/strong>:<\/p>\n
<?php\n\nnamespace App\\Models;\nuse Illuminate\\Database\\Eloquent\\Model;\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>\nE agora podemos obter o locat\u00e1rio facilmente:<\/p>\n
$tenant = Rent::find(1)->tenant;<\/code><\/pre>\nPara o m\u00e9todo belongsTo<\/strong>, tamb\u00e9m podemos substituir as chaves estrangeiras e locais, como fizemos anteriormente.<\/p>\n
Relacionamento Has-One-Of-Many<\/h2>\n
Como nosso modelo Tenant pode ser associado a muitos modelos Rent, queremos recuperar facilmente o modelo relacionado mais recente ou mais antigo dos relacionamentos.<\/p>\n
Uma maneira conveniente de fazer isso \u00e9 combinar os m\u00e9todos hasOne<\/strong> e 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 padr\u00e3o, estamos obtendo os dados com base na chave prim\u00e1ria, que pode ser classificada, mas podemos criar nossos pr\u00f3prios filtros para o m\u00e9todo ofMany<\/strong>:<\/p>\n
return $this->hasOne(Rent::class)->ofMany('price', 'min');<\/code><\/pre>\nRelacionamentos HasOneThrough e HasManyThrough<\/h2>\n
Os m\u00e9todos -Through <\/strong>sugerem que nossos modelos ter\u00e3o de passar por outro modelo para estabelecer um relacionamento com o modelo desejado. Por exemplo, podemos associar o Aluguel ao Locador, mas o Aluguel deve passar primeiro pelo Locat\u00e1rio para chegar ao Locador.<\/p>\n
As chaves das tabelas necess\u00e1rias para isso seriam as seguintes:<\/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>\nAp\u00f3s visualizar a apar\u00eancia de nossas tabelas, podemos criar os modelos:<\/p>\n
<?php\n\nnamespace App\\Models;\nuse Illuminate\\Database\\Eloquent\\Model;\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>\nO primeiro argumento do m\u00e9todo hasOneThrough<\/strong> \u00e9 o modelo que voc\u00ea deseja acessar, e o segundo argumento \u00e9 o modelo pelo qual voc\u00ea passar\u00e1.<\/p>\n
E, assim como antes, voc\u00ea pode substituir as chaves estrangeiras e locais. Agora que temos dois modelos, temos dois de cada para substituir nesta ordem:<\/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>\nDa mesma forma, o relacionamento “Has Many Through” no Laravel Eloquent \u00e9 \u00fatil quando voc\u00ea deseja acessar registros em uma tabela distante por meio de uma tabela intermedi\u00e1ria. Vamos considerar um exemplo com tr\u00eas tabelas:<\/p>\n
- \n
- pa\u00eds<\/li>\n
- usu\u00e1rios<\/li>\n
- jogos<\/li>\n<\/ul>\n
Cada pa\u00eds tem muitos usu\u00e1rios, e cada usu\u00e1rio tem muitos jogos. Queremos recuperar todos os jogos pertencentes a um pa\u00eds por meio da tabela User.<\/p>\n
Voc\u00ea definiria as tabelas da seguinte forma:<\/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>\nAgora voc\u00ea deve definir o modelo do Eloquent para cada uma das tabelas:<\/p>\n
<?php\n\nnamespace App\\Models;\nuse Illuminate\\Database\\Eloquent\\Model;\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 App\\Models;\nuse Illuminate\\Database\\Eloquent\\Model;\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 App\\Models;\nuse Illuminate\\Database\\Eloquent\\Model;\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>\nAgora podemos chamar o m\u00e9todo games()<\/strong> do modelo Country para obter todos os jogos porque estabelecemos o relacionamento “Has Many Through” entre Country e Game por meio do modelo User.<\/p>\n
<?php\n\n$country = Country::find(159);\n \n\/\/ Retrieve all games for the country\n$games = $country->games;<\/code><\/pre>\nRelacionamento muitos-para-muitos<\/h2>\n
O relacionamento de muitos-para-muitos \u00e9 mais complicado. Um bom exemplo \u00e9 um funcion\u00e1rio com v\u00e1rias fun\u00e7\u00f5es. Uma fun\u00e7\u00e3o tamb\u00e9m pode ser atribu\u00edda a v\u00e1rios funcion\u00e1rios. Essa \u00e9 a base do relacionamento de muitos-para-muitos.<\/p>\n
Para isso, precisamos ter as tabelas employees<\/strong>, roles<\/strong> e role_employees<\/strong>.<\/p>\n
Nossa estrutura de tabela do banco de dados ter\u00e1 a seguinte apar\u00eancia:<\/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>\nConhecendo a estrutura das tabelas de relacionamento, podemos facilmente definir nosso modelo Employee<\/strong> como belongToMany<\/strong> Role<\/strong>.<\/p>\n
<?php\n\nnamespace App\\Models;\nuse Illuminate\\Database\\Eloquent\\Model;\n\nclass Employee extends Model\n{\n public function roles() \n {\n return $this- >belongsToMany(Role::class);\n }\n}<\/code><\/pre>\nAp\u00f3s definirmos isso, podemos acessar todas as fun\u00e7\u00f5es de um funcion\u00e1rio e at\u00e9 mesmo filtr\u00e1-las:<\/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 os outros m\u00e9todos, podemos substituir as chaves estrangeiras e locais do m\u00e9todo belongsToMany<\/strong>.<\/p>\n
Para definir a rela\u00e7\u00e3o inversa do belongsToMany<\/strong>, basta usar o mesmo m\u00e9todo, mas agora no m\u00e9todo secund\u00e1rio, com o principal como argumento.<\/p>\n
<?php\n\nnamespace App\\Models;\nuse Illuminate\\Database\\Eloquent\\Model;\n\nclass Role extends Model\n{\n public function employees() \n {\n return $this->belongsToMany(Employee::class);\n }\n}<\/code><\/pre>\nUsos da tabela intermedi\u00e1ria<\/h3>\n
Como voc\u00ea deve ter notado, quando usamos o relacionamento muitos-para-muitos, sempre devemos ter uma tabela intermedi\u00e1ria. Nesse caso, estamos usando a tabela role_employees<\/strong>.<\/p>\n
Por padr\u00e3o, nossa tabela din\u00e2mica conter\u00e1 apenas o atributo id. Se quisermos outros atributos, teremos de especific\u00e1-los da seguinte forma:<\/p>\n
return $this->belongsToMany(Employee::class)->withPivot(\"active\", \"created_at\");<\/code><\/pre>\nSe quisermos inserir um shortcode na tabela din\u00e2mica para os registros de data e hora, podemos fazer isso:<\/p>\n
return $this->belongsToMany(Employee::class)->withTimestamps();<\/code><\/pre>\nUm truque que voc\u00ea deve saber \u00e9 que podemos personalizar o nome “pivot” para qualquer coisa que se adapte melhor ao nosso aplicativo:<\/p>\n
return $this->belongsToMany(Employee::class)->as('subscription')->withPivot(\"active\", \"created_by\");<\/code><\/pre>\nFiltrar os resultados de uma consulta eloquente \u00e9 um conhecimento obrigat\u00f3rio para qualquer desenvolvedor que queira aprimorar seu jogo e otimizar seus aplicativos Laravel<\/a>.<\/p>\n
Portanto, o Laravel oferece um recurso fant\u00e1stico de piv\u00f4s, que pode ser usado para filtrar os dados que voc\u00ea deseja coletar. Portanto, em vez de usar outros recursos, como transa\u00e7\u00f5es do banco de dados<\/a>, para obter nossos dados em partes, podemos filtr\u00e1-los com m\u00e9todos \u00fateis como wherePivot, wherePivotIn<\/strong>, wherePivotNotIn<\/strong>, wherePivotBetween<\/strong>, wherePivotNotBetween<\/strong>, wherePivotNull<\/strong>, wherePivotNotNull<\/strong> e podemos us\u00e1-los ao definir relacionamentos entre tabelas!<\/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>\nUm \u00faltimo recurso incr\u00edvel \u00e9 que podemos ordenar por piv\u00f4s:<\/p>\n
return $this->belongsToMany(Employee::class)\n ->where('promoted', true)\n ->orderByPivot('hired_at', 'desc');<\/code><\/pre>\nRelacionamentos Polymorphic<\/h2>\n
A palavra Polymorphic vem do grego e significa “muitas formas” Assim, um modelo em nosso aplicativo pode assumir v\u00e1rias formas, o que significa que ele pode ter mais de uma associa\u00e7\u00e3o. Imagine que estamos criando um aplicativo com blogs, v\u00eddeos, enquetes etc. Um usu\u00e1rio pode criar um coment\u00e1rio para qualquer um deles. Portanto, um modelo de coment\u00e1rio<\/strong> pode pertencer aos modelos de blogs<\/strong>, v\u00eddeos<\/strong> e enquetes<\/strong>.<\/p>\n
Polim\u00f3rfico de um-para-um<\/h2>\n
Esse tipo de relacionamento \u00e9 semelhante a um relacionamento padr\u00e3o de um-para-um. A \u00fanica diferen\u00e7a \u00e9 que o modelo secund\u00e1rio pode pertencer a mais de um tipo de modelo com uma \u00fanica associa\u00e7\u00e3o.<\/p>\n
Por exemplo, um modelo Tenant <\/strong>e Landlord<\/strong>\u00a0pode compartilhar uma rela\u00e7\u00e3o polim\u00f3rfica com um modelo WaterBill<\/strong>.<\/p>\n
A estrutura da tabela pode ser a seguinte:<\/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>\nEstamos usando waterbillable_id para a identifica\u00e7\u00e3o do landlord <\/strong>ou tenant<\/strong>, enquanto waterbillable_type cont\u00e9m o nome da classe do modelo principal. A coluna type \u00e9 usada pelo Eloquent para descobrir qual modelo principal voc\u00ea deve retornar.<\/p>\n
A defini\u00e7\u00e3o do modelo para esse relacionamento ter\u00e1 a seguinte apar\u00eancia:<\/p>\n
<?php\n\nnamespace App\\Models;\nuse Illuminate\\Database\\Eloquent\\Model;\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>\nQuando tivermos tudo isso pronto, poderemos acessar os dados dos modelos Landlord e Tenant:<\/p>\n
<?php\n\n$tenant = Tenant::find(1)->waterBill;\n$landlord = Landlord::find(1)->waterBill;<\/code><\/pre>\nPolim\u00f3rfico de um-para-muitos<\/h2>\n
Isso \u00e9 semelhante a uma rela\u00e7\u00e3o regular de um para muitos, a \u00fanica diferen\u00e7a fundamental \u00e9 que o modelo secund\u00e1rio pode pertencer a mais de um tipo de modelo, usando uma \u00fanica associa\u00e7\u00e3o.<\/p>\n
Em um aplicativo como o Facebook, os usu\u00e1rios podem comentar em publica\u00e7\u00f5es, v\u00eddeos, enquetes, live etc. Com uma associa\u00e7\u00e3o polim\u00f3rfica de um-para-muitos, podemos usar uma \u00fanica tabela de comments<\/strong>\u00a0para armazenar os coment\u00e1rios de todas as categorias que temos. A estrutura de nossas tabelas seria mais ou menos assim:<\/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>\nO commentable_id \u00e9 o ID do registro, e o commentable_type \u00e9 o tipo de classe, para que o Eloquent saiba o que procurar. Quanto \u00e0 estrutura do modelo, ela \u00e9 muito semelhante \u00e0 polim\u00f3rfica um-para-muitos:<\/p>\n
<?php\n\nnamespace App\\Models;\nuse Illuminate\\Database\\Eloquent\\Model;\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>\nAgora, para recuperar os coment\u00e1rios de uma live, podemos simplesmente chamar o m\u00e9todo find com o id, e agora temos acesso \u00e0 classe iter\u00e1vel de coment\u00e1rios:<\/p>\n
<?php\n\nuse App\\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>\nE se tivermos o coment\u00e1rio e quisermos descobrir a quem ele pertence, acessaremos o m\u00e9todo commentable:<\/p>\n
<?php\n\nuse App\\Models\\Comment;\n\n$comment = Comment::find(10);\n$commentable = $comment->commentable;\n\n\/\/ commentable \u2013 type of Post, Video, Poll, Live<\/code><\/pre>\nPolim\u00f3rfico um-de-muitos<\/h2>\n
Em muitos aplicativos em escala, queremos uma maneira f\u00e1cil de interagir com modelos e entre eles. Talvez queiramos a primeira ou a \u00faltima publica\u00e7\u00e3o de um usu\u00e1rio, o que pode ser feito com uma combina\u00e7\u00e3o dos m\u00e9todos morphOne<\/strong> e 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>\nOs m\u00e9todos latestOfMany<\/strong> e oldestOfMany <\/strong>est\u00e3o recuperando o modelo mais recente ou mais antigo com base na chave prim\u00e1ria do modelo, que era a condi\u00e7\u00e3o para que ele pudesse ser classificado.<\/p>\n
Em alguns casos, n\u00e3o queremos classificar pelo ID, talvez tenhamos alterado a data de publica\u00e7\u00e3o de algumas publica\u00e7\u00f5es e as queremos nessa ordem, n\u00e3o por seu ID.<\/p>\n
Voc\u00ea pode fazer isso passando dois par\u00e2metros para o m\u00e9todo ofMany<\/strong> para ajudar nessa tarefa. O primeiro par\u00e2metro \u00e9 a key<\/strong>\u00a0pela qual queremos filtrar, e o segundo \u00e9 o sorting method<\/strong>:<\/p>\n
<?php\n\npublic function latestPublishedPost()\n{\n return $this->morphOne(Post::class, \"postable\")->ofMany(\"published_at\", \"max\");\n}<\/code><\/pre>\nCom isso em mente, \u00e9 poss\u00edvel criar rela\u00e7\u00f5es mais avan\u00e7adas para isso! Imagine que voc\u00ea tenha este cen\u00e1rio. Pedimos que voc\u00ea crie uma lista de todas as publica\u00e7\u00f5es atuais na ordem em que foram publicadas. O problema surge quando temos duas publica\u00e7\u00f5es com o mesmo valor published_at e quando as publica\u00e7\u00f5es est\u00e3o programadas para serem publicadas no futuro.<\/p>\n
Para fazer isso, podemos passar a ordem em que queremos que os filtros sejam aplicados ao m\u00e9todo ofMany<\/strong>. Dessa forma, ordenamos por published_at e, se forem iguais, ordenamos por id. Em segundo lugar, podemos aplicar uma fun\u00e7\u00e3o de consulta ao m\u00e9todo ofMany<\/strong> para excluir todos os artigos programados para publica\u00e7\u00e3o!<\/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 de muitos-para-muitos<\/h2>\n
O m\u00e9todo polim\u00f3rfico de muitos-para-muitos \u00e9 um pouco mais complexo do que o normal. Uma situa\u00e7\u00e3o comum \u00e9 ter tags que se aplicam a mais ativos em seu aplicativo. Por exemplo, no TikTok, temos tags que podem ser aplicadas a v\u00eddeos, curtas, stories, etc.<\/p>\n
O polim\u00f3rfico muitos-para-muitos nos permite ter uma \u00fanica tabela de tags associadas a v\u00eddeos, curtas e Stories.<\/p>\n
A estrutura da tabela \u00e9 simples:<\/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>\nCom as tabelas prontas, podemos criar o modelo e usar o m\u00e9todo morphToMany<\/strong>. Esse m\u00e9todo aceita o nome da classe do modelo e o “nome da rela\u00e7\u00e3o”:<\/p>\n
<?php\n\nnamespace App\\Models;\nuse Illuminate\\Database\\Eloquent\\Model;\n\nclass Video extends Model\n{\n public function tags()\n {\n return $this->morphToMany(Tag::class, 'taggable');\n }\n}<\/code><\/pre>\nE, com isso, podemos definir facilmente a rela\u00e7\u00e3o inversa. Sabemos que, para cada modelo secund\u00e1rio, queremos chamar o m\u00e9todo morphedByMany<\/strong>:<\/p>\n
<?php\n\nnamespace App\\Models;\nuse Illuminate\\Database\\Eloquent\\Model;\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>\nE agora, quando obtivermos uma tag, poderemos recuperar todos os v\u00eddeos e Stories relacionados a essa tag!<\/p>\n
<?php\nuse App\\Model\\Tag;\n\n$tag = Tag::find(10);\n$posts = $tag->stories;\n$videos = $tag->stories;<\/code><\/pre>\nOtimize a velocidade do Eloquent<\/h2>\n
Ao trabalhar com o Eloquent ORM do Laravel, \u00e9 essencial que voc\u00ea entenda como otimizar as consultas ao banco de dados e minimizar o tempo e a mem\u00f3ria necess\u00e1rios para buscar dados. Uma maneira de fazer isso \u00e9 implementar o cache<\/a> em seu aplicativo.<\/p>\n
O Laravel oferece um sistema de cache flex\u00edvel que suporta v\u00e1rios backends, como Redis<\/a>, Memcached<\/a> e cache baseado em arquivo<\/a>. Ao armazenar em cache os resultados das consultas do Eloquent, voc\u00ea pode reduzir o n\u00famero de consultas ao banco de dados, tornando seu aplicativo mais r\u00e1pido e valioso.<\/p>\n
Al\u00e9m disso, voc\u00ea pode usar o construtor de consultas<\/a> do Laravel para criar consultas complexas adicionais, otimizando ainda mais o desempenho do seu aplicativo.<\/p>\n
Resumo<\/h2>\n
Concluindo, os relacionamentos Eloquent s\u00e3o um recurso poderoso do Laravel que permite aos desenvolvedores trabalhar facilmente com dados relacionados. De relacionamentos um-para-um a muitos-para-muitos, o Eloquent fornece uma sintaxe simples e intuitiva para voc\u00ea definir e consultar esses relacionamentos.<\/p>\n
Como desenvolvedor do Laravel, o dom\u00ednio dos relacionamentos do Eloquent pode melhorar muito seu fluxo de trabalho de desenvolvimento e tornar seu c\u00f3digo mais eficiente e leg\u00edvel. Caso voc\u00ea esteja interessado em aprender mais sobre o Laravel, a Kinsta tem v\u00e1rios recursos dispon\u00edveis, incluindo um tutorial<\/a> sobre como come\u00e7ar a usar o Laravel e um artigo sobre sal\u00e1rios de desenvolvedores do Laravel<\/a>.<\/p>\n
- muitos-para-muitos – V\u00e1rios registros em uma tabela s\u00e3o associados a v\u00e1rios registros em outra tabela. Por exemplo, alunos e os cursos em que est\u00e3o matriculados.<\/li>\n<\/ul>\n
- um-para-muitos – Um registro est\u00e1 associado a v\u00e1rios registros em outra tabela. Por exemplo, um escritor e seus blogs.<\/li>\n<\/ul>\n