Uso do Banco de Dados (Baseado no Componente de Banco de Dados do Laravel)
Obter todas as linhas
<?php
namespace app\controller;
use support\Request;
use support\Db;
class UserController
{
public function all(Request $request)
{
$users = Db::table('users')->get();
return view('user/all', ['users' => $users]);
}
}
Obter colunas específicas
$users = Db::table('user')->select('name', 'email as user_email')->get();
Obter uma linha
$user = Db::table('users')->where('name', 'John')->first();
Obter uma coluna
$titles = Db::table('roles')->pluck('title');
Usar o valor do campo id como índice
$roles = Db::table('roles')->pluck('title', 'id');
foreach ($roles as $id => $title) {
echo $title;
}
Obter um único valor (campo)
$email = Db::table('users')->where('name', 'John')->value('email');
Remover duplicatas
$email = Db::table('user')->select('nickname')->distinct()->get();
Resultado em pedaços
Se você precisar processar milhares de registros do banco de dados, ler esses dados de uma só vez pode ser muito demorado e pode causar estouro de memória. Neste caso, você pode considerar usar o método chunkById. Esse método obtém um pequeno pedaço do conjunto de resultados de cada vez e o passa para uma função de fechamento para processamento. Por exemplo, podemos dividir todos os dados da tabela users em pequenos pedaços de 100 registros para processamento de uma só vez:
Db::table('users')->orderBy('id')->chunkById(100, function ($users) {
foreach ($users as $user) {
//
}
});
Você pode interromper a obtenção de resultados em pedaços retornando false dentro da função de fechamento.
Db::table('users')->orderBy('id')->chunkById(100, function ($users) {
// Processar os registros...
return false;
});
Nota: Não exclua dados dentro do retorno, pois isso pode fazer com que alguns registros não sejam incluídos no conjunto de resultados.
Agregação
O construtor de consultas também oferece vários métodos de agregação, como count, max, min, avg e sum.
$users = Db::table('users')->count();
$price = Db::table('orders')->max('price');
$price = Db::table('orders')->where('finalized', 1)->avg('price');
Verificar se o registro existe
return Db::table('orders')->where('finalized', 1)->exists();
return Db::table('orders')->where('finalized', 1)->doesntExist();
Expressões Nativas
Prototype
selectRaw($expression, $bindings = [])
Às vezes, você pode precisar usar expressões nativas em suas consultas. Você pode usar selectRaw()
para criar uma expressão nativa:
$orders = Db::table('orders')
->selectRaw('price * ? as price_with_tax', [1.0825])
->get();
Da mesma forma, também são fornecidos métodos de expressões nativas como whereRaw()
, orWhereRaw()
, havingRaw()
, orHavingRaw()
, orderByRaw()
, groupByRaw()
.
Db::raw($value)
também é usado para criar uma expressão nativa, mas não possui funcionalidade de parâmetros vinculados, portanto, deve ser usado com cuidado em relação a injeção SQL.
$orders = Db::table('orders')
->select('department', Db::raw('SUM(price) as total_sales'))
->groupBy('department')
->havingRaw('SUM(price) > ?', [2500])
->get();
Instruções Join
// join
$users = Db::table('users')
->join('contacts', 'users.id', '=', 'contacts.user_id')
->join('orders', 'users.id', '=', 'orders.user_id')
->select('users.*', 'contacts.phone', 'orders.price')
->get();
// leftJoin
$users = Db::table('users')
->leftJoin('posts', 'users.id', '=', 'posts.user_id')
->get();
// rightJoin
$users = Db::table('users')
->rightJoin('posts', 'users.id', '=', 'posts.user_id')
->get();
// crossJoin
$users = Db::table('sizes')
->crossJoin('colors')
->get();
Instruções Union
$first = Db::table('users')
->whereNull('first_name');
$users = Db::table('users')
->whereNull('last_name')
->union($first)
->get();
Instruções Where
Prototype
where($column, $operator = null, $value = null)
O primeiro parâmetro é o nome da coluna, o segundo parâmetro é qualquer operador suportado pelo sistema de banco de dados, o terceiro é o valor com o qual a coluna deve ser comparada.
$users = Db::table('users')->where('votes', '=', 100)->get();
// Quando o operador for igual, pode ser omitido, então esta expressão é equivalente à anterior
$users = Db::table('users')->where('votes', 100)->get();
$users = Db::table('users')
->where('votes', '>=', 100)
->get();
$users = Db::table('users')
->where('votes', '<>', 100)
->get();
$users = Db::table('users')
->where('name', 'like', 'T%')
->get();
Você também pode passar um array de condições para a função where:
$users = Db::table('users')->where([
['status', '=', '1'],
['subscribed', '<>', '1'],
])->get();
O método orWhere recebe os mesmos parâmetros que o método where:
$users = Db::table('users')
->where('votes', '>', 100)
->orWhere('name', 'John')
->get();
Você pode passar uma função de fechamento para o método orWhere como primeiro parâmetro:
// SQL: select * from users where votes > 100 or (name = 'Abigail' and votes > 50)
$users = Db::table('users')
->where('votes', '>', 100)
->orWhere(function($query) {
$query->where('name', 'Abigail')
->where('votes', '>', 50);
})
->get();
whereBetween / orWhereBetween métodos verificam se o valor do campo está entre dois valores fornecidos:
$users = Db::table('users')
->whereBetween('votes', [1, 100])
->get();
whereNotBetween / orWhereNotBetween métodos verificam se o valor do campo está fora de dois valores fornecidos:
$users = Db::table('users')
->whereNotBetween('votes', [1, 100])
->get();
whereIn / whereNotIn / orWhereIn / orWhereNotIn métodos verificam se o valor do campo deve existir em um array especificado:
$users = Db::table('users')
->whereIn('id', [1, 2, 3])
->get();
whereNull / whereNotNull / orWhereNull / orWhereNotNull métodos verificam se o campo especificado deve ser NULL:
$users = Db::table('users')
->whereNull('updated_at')
->get();
whereNotNull métodos verificam se o campo especificado não deve ser NULL:
$users = Db::table('users')
->whereNotNull('updated_at')
->get();
whereDate / whereMonth / whereDay / whereYear / whereTime métodos são usados para comparar os valores do campo com a data fornecida:
$users = Db::table('users')
->whereDate('created_at', '2016-12-31')
->get();
whereColumn / orWhereColumn métodos são usados para comparar se os valores de dois campos são iguais:
$users = Db::table('users')
->whereColumn('first_name', 'last_name')
->get();
// Você também pode passar um operador de comparação
$users = Db::table('users')
->whereColumn('updated_at', '>', 'created_at')
->get();
// whereColumn também pode receber um array
$users = Db::table('users')
->whereColumn([
['first_name', '=', 'last_name'],
['updated_at', '>', 'created_at'],
])->get();
Agrupamento de parâmetros
// select * from users where name = 'John' and (votes > 100 or title = 'Admin')
$users = Db::table('users')
->where('name', '=', 'John')
->where(function ($query) {
$query->where('votes', '>', 100)
->orWhere('title', '=', 'Admin');
})
->get();
whereExists
// select * from users where exists ( select 1 from orders where orders.user_id = users.id )
$users = Db::table('users')
->whereExists(function ($query) {
$query->select(Db::raw(1))
->from('orders')
->whereRaw('orders.user_id = users.id');
})
->get();
orderBy
$users = Db::table('users')
->orderBy('name', 'desc')
->get();
Ordenação Aleatória
$randomUser = Db::table('users')
->inRandomOrder()
->first();
A ordenação aleatória pode ter um grande impacto no desempenho do servidor e não é recomendada.
groupBy / having
$users = Db::table('users')
->groupBy('account_id')
->having('account_id', '>', 100)
->get();
// Você pode passar vários parâmetros para o método groupBy
$users = Db::table('users')
->groupBy('first_name', 'status')
->having('account_id', '>', 100)
->get();
offset / limit
$users = Db::table('users')
->offset(10)
->limit(5)
->get();
Inserir
Inserir uma única linha
Db::table('users')->insert(
['email' => 'john@example.com', 'votes' => 0]
);
Inserir várias linhas
Db::table('users')->insert([
['email' => 'taylor@example.com', 'votes' => 0],
['email' => 'dayle@example.com', 'votes' => 0]
]);
ID Auto-Incremento
$id = Db::table('users')->insertGetId(
['email' => 'john@example.com', 'votes' => 0]
);
Nota: Ao usar o PostgreSQL, o método insertGetId irá, por padrão, usar id como o nome do campo auto-incrementado. Se você deseja obter um ID de uma "sequência" diferente, pode passar o nome do campo como segundo parâmetro para o método insertGetId.
Atualizar
$affected = Db::table('users')
->where('id', 1)
->update(['votes' => 1]);
Atualizar ou Inserir
Às vezes, você pode querer atualizar um registro existente no banco de dados ou criar um se não houver registro correspondente:
Db::table('users')
->updateOrInsert(
['email' => 'john@example.com', 'name' => 'John'],
['votes' => '2']
);
O método updateOrInsert tentará primeiro encontrar um registro correspondente no banco de dados usando os pares de chave e valor do primeiro parâmetro. Se o registro existir, ele será atualizado com o valor do segundo parâmetro. Se nenhum registro for encontrado, um novo registro será inserido, contendo as informações de ambos os arrays.
Incrementar & Decrementar
Esses dois métodos recebem pelo menos um parâmetro: a coluna a ser modificada. O segundo parâmetro é opcional e define o montante a ser incrementado ou decrementado:
Db::table('users')->increment('votes');
Db::table('users')->increment('votes', 5);
Db::table('users')->decrement('votes');
Db::table('users')->decrement('votes', 5);
Você também pode especificar os campos a serem atualizados durante a operação:
Db::table('users')->increment('votes', 1, ['name' => 'John']);
Excluir
Db::table('users')->delete();
Db::table('users')->where('votes', '>', 100)->delete();
Se você precisar limpar uma tabela, pode usar o método truncate, que removerá todas as linhas e redefinirá o ID auto-incremento para zero:
Db::table('users')->truncate();
Transações
Consulte Transações de Banco de Dados.
Bloqueio Pessimista
O construtor de consultas também inclui algumas funções que ajudam você a implementar o "bloqueio pessimista" na sintaxe select. Para implementar um "bloqueio compartilhado" em sua consulta, você pode usar o método sharedLock. O bloqueio compartilhado impede que as colunas de dados selecionadas sejam modificadas até que a transação seja confirmada:
Db::table('users')->where('votes', '>', 100)->sharedLock()->get();
Ou você pode usar o método lockForUpdate. O bloqueio "update" evita que as linhas sejam modificadas ou selecionadas por outros bloqueios compartilhados:
Db::table('users')->where('votes', '>', 100)->lockForUpdate()->get();
Depuração
Você pode usar os métodos dd ou dump para exibir o resultado da consulta ou a instrução SQL. O método dd exibe informações de depuração e para a execução da solicitação. O método dump também exibe informações de depuração, mas não interrompe a execução da solicitação:
Db::table('users')->where('votes', '>', 100)->dd();
Db::table('users')->where('votes', '>', 100)->dump();
Nota
Para depuração, você precisará instalarsymfony/var-dumper
com o comandocomposer require symfony/var-dumper
.