Posted on: July 04, 2021 02:54 PM
Posted by: Renato
Views: 421
Aprenda eloquente
Criar e atualizar
QueryBuilder para inserir um novo registro no banco de dados, por meio do uso da fachada DB:
```php
DB::table('dogs')->insert(['name' => 'Old Yeller', 'age' => 12]); // result "true"
```
Como mencionamos acima, isso nada mais faz do que executar uma instrução sql para persistir os dados que enviamos na tabela correspondente, recebendo uma resposta booleana que nos diz se sua execução foi bem-sucedida ou não, e pronto, esta instrução irá não adicione timestamps nem faça mais nada por nós, se precisarmos continuar trabalhando com esses dados que enviamos, já que teríamos que fazer uma consulta e trazer o registro, ou trabalhar com as informações brutas conforme o enviamos. Vamos agora tentar com o Eloquent para ver como funciona e se pode nos ajudar nesta tarefa:
```php
$dog = Dog(); // result "App\Models\Dog"
$dog->name = 'Just-right Yeller'; // result "Just-right Yeller"
$dog->age = 6; // result 6
$dog->save(); // result "true"
```
Neste exemplo, estamos utilizando o método save()fornecido pela eloquent, para isso devemos atribuir os valores a cada propriedade do nosso modelo e executar o método, este atuará da mesma forma que o insertanterior, persistindo o nosso dados, mas com a vantagem de ter uma instância do nosso modelo, o que nos permitirá trabalhar com esse cadastro de uma forma mais confortável, podendo fazer quase tudo com ele. Porém, podemos ver que aqui trabalhamos com uma abordagem meio híbrida, criamos uma instância do modelo, depois estabelecemos os atributos, para finalmente salvá-lo, em linhas gerais poderíamos dizer que foram três etapas executadas, vamos veja uma terceira maneira de salvar nossas informações com menos instruções:
```php
Dog::create(['name' => 'Young Yeller', 'age' => 3]);
```
Este apareceu em nossos rostos exception: "Illuminate \ Database \ Eloquent \ MassAssignmentException com a mensagem 'name'" - MassAssignmentException, do que se trata?
Pois bem, é aqui que entram os nossos amigos $fillablee $guardjogadores. A Eloquent, na sua grande missão de facilitar a gestão da informação desde e para a base de dados, não só nos fornece métodos e propriedades para este particular, também, não dá suporte em termos de protecção na execução destas tarefas, garantindo que apenas os campos que deseja preencher sejam inseridos ou atualizados e nada mais, para isso, em primeiro lugar temos a propriedade $fillable, que é uma espécie de lista branca, na qual indicamos quais são os campos da nossa base de dados que você pode salvar via alocação em massa. Segundo, nós temos$guard que é o oposto, nele indicamos aqueles que queremos proteger e que só podem ser atribuídos diretamente (como no segundo exemplo usando save ()).
Vamos consertar isso e começar. Vamos para o modelo Dog e adicionamos a seguinte linha:
```php
protected $fillable = ['name'];
```
Agora, a partir do tinker, vamos criar um novo recorde:
```php
Dog::create(['name' => 'Young Yeller', 'age' => 3]);
```
Com esta instrução, fizemos o mesmo que no exemplo anterior, exceto por uma exceção, cometemos um erro e não o percebemos. Se verificarmos a nossa base de dados, descobriremos que de facto o nosso amigo Young Yeller está registado, no entanto, embora tenhamos indicado a sua idade no momento do registo, estes dados não persistem, e porquê? Bem, tão simples como isso não contar$fillableo que poderia permitir o mapeamento deste campo. Este é um erro muito comum e que muitas vezes levamos a perceber porque na realidade não existe nenhum sinal de erro que não os indique, por isso poderíamos passar horas quebrando a cabeça procurando o motivo pelo qual nossos dados não persistem, muitos podem acho que isso é uma desvantagem e alguns até tentariam evitar o uso deste método, porém, devemos levar em consideração que este é o caso por um motivo, a 'injeção de SQL', desta forma, embora Qualquer atacante tente e consegue adicionar campos não definidos por nós, estes não afetarão a nossa aplicação uma vez que serão ignorados pelo Eloquent.
A injeção de sql é um tipo de ataque muito comum na web, se você quiser saber um pouco mais sobre isso, pode fazer no link: injeção de SQL
Agora, embora até agora tenhamos visto três maneiras diferentes de salvar nossos dados, ainda existem alguns outros métodos que nos ajudam nesta mesma tarefa, e embora possa parecer opressor ter que aprender tantas opções e como fazer uma coisa, a verdade é que cada um tem um propósito ou ajuda de uma forma diferente, resolvendo diferentes tipos de situações.
Portanto, vemos uma nova maneira de fazer o acima:
```php
$dog = new Dog (['name' => 'Young Yeller', 'age' => 3]); // result App\Models\Dog {#690 name: "Young Yell
```
Como podemos ver, a instrução anterior nada mais faz do que criar uma instância do modelo Dog, mas não persiste nem cria nenhum registro, se quisermos que isso aconteça devemos invocar o método save()de nossa instância.
findOrNew, firstOrNew / firstOrCreate:
Essas três funções são incrivelmente úteis, mas muitos desenvolvedores do Laravel se esquivam delas como algo desconhecido. Não há necessidade de fazer isso; na verdade, agora devemos ter alguma compreensão do que eles fazem.
Nos exemplos anteriores, vimos como, ao fazer uso de, newcriamos apenas uma instância do modelo, nada diferente de uma simples criação de uma instância de php puro $dog = new Dog($data). Por sua vez, Createtambém cria uma instância do modelo com a distinção de que as informações contidas na instância também persistem na base de dados, ou o que se poderia traduzir $dog= (new Dog($data))->save(), neste sentido, podemos dizer que:
o que findOrNew faz é “Encontrar um registro com a chave primária; se o encontrar, ele o retorna e, se não, cria uma instância nova e vazia do modelo.
```php
>>> $dog = Dog::findOrNew(100)
=> App\Models\Dog {#4061}
```
o que firstOrNew faz é “Encontre o primeiro registro que atenda à condição. Se não conseguir encontrar um, ele cria uma nova instância de modelo preenchida com as informações fornecidas sem persistir "
```php
>>> $dog = Dog::firstOrNew(['name' => 'Jock'])
=> App\Models\Dog {#4284
id: 2,
name: "Jock",
gender: "male",
age: 7,
created_at: "2021-06-07 02:05:46",
updated_at: "2021-06-07 02:05:46",
deleted_at: null,
}
>>> $dog = Dog::firstOrNew(['name' => 'Champ'])
=> App\Models\Dog {#3333
name: "Champ",
}
```
o que firstOrCreate faz é “Encontre o primeiro registro que atenda à condição. Se não conseguir encontrar um, ele cria uma nova instância de modelo preenchida com as informações fornecidas e salva no banco de dados "
```php
>>> $dog = Dog::firstOrCreate(['name' => 'Champ'])
=> App\Models\Dog {#4282
name: "Champ",
updated_at: "2021-06-27 15:26:41",
created_at: "2021-06-27 15:26:41",
id: 6,
}
```
```php
>>> Dog::find(6)
=> App\Models\Dog {#4287
id: 6,
name: "Champ",
gender: null,
age: null,
created_at: "2021-06-27 15:26:41",
updated_at: "2021-06-27 15:26:41",
deleted_at: null,
}
```
```
Já os entendemos, no entanto, talvez surja a pergunta: Por que desejaríamos fazer instâncias vazias? Existem alguns motivos, mas um é que quando procuramos por um registro, sempre teremos uma instância de modelo como classe de resultado, mesmo se aquela que queremos não for encontrada, isso significa que podemos escrever nosso código de forma mais consistente e de forma limpa, porque não precisamos mais do que bagunçar muitas condicionais por todo o lugar.
updateOrCreate:
Antes de terminarmos por hoje, vamos dar uma olhada em um último recurso a ser considerado updateOrCreate(). Esta função permite concluir uma busca multiparte com uma instrução de inserção ou atualização dependendo do resultado. Por exemplo:
```php
Dog::updateOrCreate(['id' => 1, 'name' => 'Joe'], ['age' => 15]);
```
Nesse caso, à semelhança dos anteriores, irá procurar um cão cujo id seja igual a 1 e o seu nome seja Joe , ambas as condições são inclusivas, ao encontrar uma correspondência, irá alterar a sua idade para o valor de 15 , no outra mão:
```php
Dog::updateOrCreate(['id' => 2, 'name' => 'Joe'], ['age' => 15]);
```
Como não há correspondência que satisfaça as condições, esta função procederá para criar um novo registro com as informações fornecidas, atribuindo o nome Joe e a idade de 15 anos ao id correspondente ao novo registro. Como podemos ver, isso é útil para coisas como um perfil de usuário, onde não podemos pedir ao usuário para preencher muitas informações ao se inscrever, mas em vez disso, mostramos uma tela de perfil onde eles podem terminar a atualização mais tarde.
Donate to Site
Renato
Developer