Dado o seguinte código:
DB::table('users')->get();
Desejo obter a string de consulta SQL bruta que o construtor de consulta ao banco de dados acima irá gerar. Neste exemplo, seria SELECT * FROM users
.
Como eu faço isso?
Dado o seguinte código:
DB::table('users')->get();
Desejo obter a string de consulta SQL bruta que o construtor de consulta ao banco de dados acima irá gerar. Neste exemplo, seria SELECT * FROM users
.
Como eu faço isso?
Respostas:
Para exibir na tela as últimas consultas executadas, você pode usar isto:
DB::enableQueryLog(); // Enable query log
// Your Eloquent query executed by using get()
dd(DB::getQueryLog()); // Show results of log
Acredito que as consultas mais recentes estarão na parte inferior da matriz.
Você terá algo assim:
array(1) {
[0]=>
array(3) {
["query"]=>
string(21) "select * from "users""
["bindings"]=>
array(0) {
}
["time"]=>
string(4) "0.92"
}
}
(Obrigado ao comentário de Josué abaixo.)
Log
classe: Log::debug(DB::getQueryLog())
DB::enableQueryLog();
DB::enableQueryLog(); dd(DB::getQueryLog());
Mas ele retorna apenas []
....
DB::connection('database')->getQueryLog()
Use o toSql()
método em uma QueryBuilder
instância.
DB::table('users')->toSql()
retornaria:
selecione * em `usuários`
Isso é mais fácil do que conectar um ouvinte de evento e também permite verificar como a consulta realmente se parecerá a qualquer momento enquanto você a estiver construindo.
getBindings
método Isso retornará as ligações para que elas sejam vinculadas à instrução SQL.
$query = \DB::table('users')->where('id', 10); $sql = str_replace_array('?', $query->getBindings(), $query->toSql()); dd($sql);
DB::QueryLog()
só funciona depois de executar a consulta $builder->get()
. Se você deseja obter a consulta antes de executá-la, pode usar o $builder->toSql()
método Este é o exemplo de como obter o sql e vinculá-lo:
$query = str_replace(array('?'), array('\'%s\''), $builder->toSql());
$query = vsprintf($query, $builder->getBindings());
dump($query);
$result = $builder->get();
OU apenas cometa um erro de consulta como chamar tabela ou coluna inexistente, você verá a consulta gerada na exceção XD
$query = vsprintf(str_replace(array('?'), array('\'%s\''), $builder->toSql()), $builder->getBindings());
LIKE
consulta ou ao formatar datas. Você precisará escapar dos primeiros com sinais de porcentagem duplos.
$builder->getBindings()
?
Você pode ouvir o evento 'illuminate.query'. Antes da consulta, adicione o seguinte ouvinte de evento:
Event::listen('illuminate.query', function($query, $params, $time, $conn)
{
dd(array($query, $params, $time, $conn));
});
DB::table('users')->get();
Isso imprimirá algo como:
array(4) {
[0]=>
string(21) "select * from "users""
[1]=>
array(0) {
}
[2]=>
string(4) "0.94"
[3]=>
string(6) "sqlite"
}
use Illuminate\Support\Facades\Event;
use Illuminate\Support\Facades\Event;
você pode simplesmente fazer use Event;
uma vez que é uma fachada .
Se você está tentando obter o log usando o Illuminate sem o Laravel, use:
\Illuminate\Database\Capsule\Manager::getQueryLog();
Você também pode criar uma função rápida como:
function logger() {
$queries = \Illuminate\Database\Capsule\Manager::getQueryLog();
$formattedQueries = [];
foreach( $queries as $query ) :
$prep = $query['query'];
foreach( $query['bindings'] as $binding ) :
$prep = preg_replace("#\?#", is_numeric($binding) ? $binding : "'" . $binding . "'", $prep, 1);
endforeach;
$formattedQueries[] = $prep;
endforeach;
return $formattedQueries;
}
EDITAR
as versões atualizadas parecem ter o log de consultas desativado por padrão (o exemplo acima retorna uma matriz vazia). Para ativar novamente, ao inicializar o Capsule Manager, pegue uma instância da conexão e chame o enableQueryLog
método
$capsule::connection()->enableQueryLog();
EDITAR NOVAMENTE
Levando em consideração a pergunta real, você pode realmente fazer o seguinte para converter a consulta única atual em vez de todas as consultas anteriores:
$sql = $query->toSql();
$bindings = $query->getBindings();
'US/Eastern'
.
quick function
. Eu acredito que o código subjacente usará os métodos prepare ( php.net/manual/en/mysqli.prepare.php ), e é por isso que apenas isso ?
é necessário. Você pode php.net/manual/en/function.is-numeric.php para determinar se deve ou não encapsular a entrada entre aspas simples.
is_numeric
ideia) e ela funciona! Eu amo isto. Obrigado.
Existe um método eloquente para obter a string de consulta.
toSql ()
no nosso caso,
DB::table('users')->toSql();
Retorna
select * from users
é a solução exata que retorna a string de consulta SQL ... Espero que seja útil ...
->where('foo', '=', 'bar')
bar costuma aparecer no sql
$data = User::toSql();
echo $data; //this will retrun select * from users. //here User is model
->toSql()
como faria se houver mais argumentos após o modelo. por exemploUser::where('id', 1)->toSql()
Se você usa o laravel 5.1 e o MySQL, pode usar esta função feita por mim:
/*
* returns SQL with values in it
*/
function getSql($model)
{
$replace = function ($sql, $bindings)
{
$needle = '?';
foreach ($bindings as $replace){
$pos = strpos($sql, $needle);
if ($pos !== false) {
if (gettype($replace) === "string") {
$replace = ' "'.addslashes($replace).'" ';
}
$sql = substr_replace($sql, $replace, $pos, strlen($needle));
}
}
return $sql;
};
$sql = $replace($model->toSql(), $model->getBindings());
return $sql;
}
Como parâmetro de entrada, você pode usar um destes
Iluminar \ Banco de Dados \ Eloquent \ Builder
Iluminar \ Banco de Dados \ Eloquente \ Relações \ HasMany
Iluminar \ Banco de Dados \ Consulta \ Construtor
Primeiro, você precisará ativar o log de consulta chamando:
DB::enableQueryLog();
após consultas usando a fachada do banco de dados, você pode escrever:
dd(DB::getQueryLog());
a saída será como abaixo:
array:1 [▼
0 => array:3 [▼
"query" => "select * from `users` left join `website_user` on `users`.`id` = `website_user`.`user_id` left join `region_user` on `users`.`id` = `region_user`.`user_id` left ▶"
"bindings" => array:5 [▶]
"time" => 3.79
]
]
Esta é a melhor solução que posso sugerir a qualquer um para depurar a última consulta eloquente ou a consulta final, embora isso tenha sido discutido também:
// query builder
$query = DB::table('table_name')->where('id', 1);
// binding replaced
$sql = str_replace_array('?', $query->getBindings(), $query->toSql());
// for laravel 5.8^
$sql = Str::replaceArray('?', $query->getBindings(), $query->toSql());
// print
dd($sql);
Simplesmente você pode fazer as seguintes coisas usando o toSql()
método
$query = DB::table('users')->get();
echo $query->toSql();
Se não estiver funcionando, você pode configurar a coisa na documentação do laravel .
Outra maneira de fazer isso é
DB::getQueryLog()
mas se ele retornar uma matriz vazia, por padrão está desativado, visite este ,
apenas ative com DB::enableQueryLog()
e ele vai funcionar :)
para mais informações, visite o Github Issue para saber mais.
Espero que ajude :)
Uma substituição 'macroable' para obter a consulta SQL com as ligações.
Adicione a função macro abaixo no métodoAppServiceProvider
boot()
\Illuminate\Database\Query\Builder::macro('toRawSql', function(){
return array_reduce($this->getBindings(), function($sql, $binding){
return preg_replace('/\?/', is_numeric($binding) ? $binding : "'".$binding."'" , $sql, 1);
}, $this->toSql());
});
Adicione um alias para o Eloquent Builder. ( Laravel 5.4+ )
\Illuminate\Database\Eloquent\Builder::macro('toRawSql', function(){
return ($this->getQuery()->toRawSql());
});
Em seguida, depure como de costume. ( Laravel 5.4+ )
Por exemplo, Query Builder
\Log::debug(\DB::table('users')->limit(1)->toRawSql())
Por exemplo, Eloquent Builder
\Log::debug(\App\User::limit(1)->toRawSql());
Nota: do Laravel 5.1 a 5.3, Como o Eloquent Builder não faz uso da
Macroable
característica, não é possível adicionartoRawSql
um alias ao Eloquent Builder em tempo real. Siga o exemplo abaixo para obter o mesmo.
Por exemplo, Eloquent Builder ( Laravel 5.1 - 5.3 )
\Log::debug(\App\User::limit(1)->getQuery()->toRawSql());
De laravel 5.2
e em diante. você pode usar DB::listen
para obter consultas executadas.
DB::listen(function ($query) {
// $query->sql
// $query->bindings
// $query->time
});
Ou se você deseja depurar uma única Builder
instância, pode usar o toSql
método
DB::table('posts')->toSql();
A maneira mais fácil é cometer um erro deliberado . Por exemplo, quero ver a consulta SQL completa da seguinte relação:
public function jobs()
{
return $this->belongsToMany(Job::class, 'eqtype_jobs')
->withPivot(['created_at','updated_at','id'])
->orderBy('pivot_created_at','desc');
}
Eu apenas para fazer uma coluna não ser encontrada, aqui eu escolho created_at
e mudei para created_ats
adicionando s
à direita o seguinte :
public function jobs()
{
return $this->belongsToMany(Job::class, 'eqtype_jobs')
->withPivot(['created_ats','updated_at','id'])
->orderBy('pivot_created_at','desc');
}
Portanto, o depurador retornará o seguinte erro:
(4/4) ErrorException SQLSTATE [42S22]: Coluna não encontrado: 1054 não informada coluna 'eqtype_jobs.created_ats' em 'lista de campo' (SQL: select
jobs
. *,eqtype_jobs
.set_id
, Comopivot_set_id
,eqtype_jobs
.job_id
Comopivot_job_id
,eqtype_jobs
.created_ats
Comopivot_created_ats
,eqtype_jobs
.updated_at
Comopivot_updated_at
,eqtype_jobs
.id
Comopivot_id
dejobs
junção internaeqtype_jobs
emjobs
.id
=eqtype_jobs
.job_id
ondeeqtype_jobs
.set_id
= 56 ordem pelopivot_created_at
limite de desc 20 deslocamento 0) (Exibir: /home/said/www/factory/resources/views/set/show.blade.php)
A mensagem de erro acima retorna a consulta SQL completa com o erro
SQL: select jobs.*, eqtype_jobs.set_id as pivot_set_id, eqtype_jobs.job_id as pivot_job_id, eqtype_jobs.created_ats as pivot_created_ats, eqtype_jobs.updated_at as pivot_updated_at, eqtype_jobs.id as pivot_id from jobs inner join eqtype_jobs on jobs.id = eqtype_jobs.job_id where eqtype_jobs.set_id = 56 order by pivot_created_at desc limit 20 offset 0
Agora, basta remover o extra s
de created_at e testar esse SQL como desejar em qualquer editor de SQL, como o editor de phpMyAdmin SQL!
Aviso prévio:
A solução foi testada com o Laravel 5.4 .
:id
DB::enableQueryLog();
$queries = DB::getQueryLog();
A partir de Laravel 5.8.15 o construtor de consulta tem agora dd
e dump
métodos para que você pode fazer
DB::table('data')->where('a', 1)->dump();
Essa é a função que eu coloquei na minha classe de modelo base. Simplesmente passe o objeto do construtor de consultas para ele e a string SQL será retornada.
function getSQL($builder) {
$sql = $builder->toSql();
foreach ( $builder->getBindings() as $binding ) {
$value = is_numeric($binding) ? $binding : "'".$binding."'";
$sql = preg_replace('/\?/', $value, $sql, 1);
}
return $sql;
}
Na minha opinião, esta será a melhor abordagem para iniciantes:
echo "<pre>";
print_r($query->toSql());
print_r($query->getBindings());
Isso também é descrito aqui. https://stackoverflow.com/a/59207557/9573341
Para o laravel 5.5.X
Se você deseja receber cada consulta SQL executada pelo seu aplicativo, você pode usar o método listen. Este método é útil para registrar consultas ou depuração. Você pode registrar seu ouvinte de consulta em um provedor de serviços:
<?php
namespace App\Providers;
use Illuminate\Support\Facades\DB;
use Illuminate\Support\ServiceProvider;
class AppServiceProvider extends ServiceProvider
{
/**
* Bootstrap any application services.
*
* @return void
*/
public function boot()
{
DB::listen(function ($query) {
// $query->sql
// $query->bindings
// $query->time
});
}
/**
* Register the service provider.
*
* @return void
*/
public function register()
{
//
}
}
Adicione esta função ao seu aplicativo e simplesmente chame.
function getQuery($sql){
$query = str_replace(array('?'), array('\'%s\''), $sql->toSql());
$query = vsprintf($query, $sql->getBindings());
return $query;
}
Saída : "selecione * de user
onde lang
= ordem 'en' e status
= '1' pelo updated_at
limite de desc 25 deslocamento 0"
Você pode usar este pacote para obter todas as consultas que estão sendo executadas quando você carrega sua página
https://github.com/barryvdh/laravel-debugbar
Imprimir última consulta
DB::enableQueryLog();
$query = DB::getQueryLog();
$lastQuery = end($query);
print_r($lastQuery);
Se você não estiver usando o Laravel, mas usando o pacote Eloquent, então:
use \Illuminate\Database\Capsule\Manager as Capsule;
use \Illuminate\Events\Dispatcher;
use \Illuminate\Container\Container;
$capsule = new Capsule;
$capsule->addConnection([
// connection details
]);
// Set the event dispatcher used by Eloquent models... (optional)
$capsule->setEventDispatcher(new Dispatcher(new Container));
// Make this Capsule instance available globally via static methods... (optional)
$capsule->setAsGlobal();
// Setup the Eloquent ORM...(optional unless you've used setEventDispatcher())
$capsule->bootEloquent();
// Listen for Query Events for Debug
$events = new Dispatcher;
$events->listen('illuminate.query', function($query, $bindings, $time, $name)
{
// Format binding data for sql insertion
foreach ($bindings as $i => $binding) {
if ($binding instanceof \DateTime) {
$bindings[$i] = $binding->format('\'Y-m-d H:i:s\'');
} else if (is_string($binding)) {
$bindings[$i] = "'$binding'";`enter code here`
}
}
// Insert bindings into query
$query = str_replace(array('%', '?'), array('%%', '%s'), $query);
$query = vsprintf($query, $bindings);
// Debug SQL queries
echo 'SQL: [' . $query . ']';
});
$capsule->setEventDispatcher($events);
você pode usar um relógio
Clockwork é uma extensão do Chrome para desenvolvimento PHP, estendendo as Ferramentas do desenvolvedor com um novo painel que fornece todos os tipos de informações úteis para depurar e criar um perfil de seus aplicativos PHP, incluindo informações sobre solicitação, cabeçalhos, obter e publicar dados, cookies, dados de sessão, consultas de banco de dados, rotas, visualização do tempo de execução do aplicativo e muito mais.
mas funciona também no firefox
Eu criei algumas funções simples para obter o SQL e as ligações de algumas consultas.
/**
* getSql
*
* Usage:
* getSql( DB::table("users") )
*
* Get the current SQL and bindings
*
* @param mixed $query Relation / Eloquent Builder / Query Builder
* @return array Array with sql and bindings or else false
*/
function getSql($query)
{
if( $query instanceof Illuminate\Database\Eloquent\Relations\Relation )
{
$query = $query->getBaseQuery();
}
if( $query instanceof Illuminate\Database\Eloquent\Builder )
{
$query = $query->getQuery();
}
if( $query instanceof Illuminate\Database\Query\Builder )
{
return [ 'query' => $query->toSql(), 'bindings' => $query->getBindings() ];
}
return false;
}
/**
* logQuery
*
* Get the SQL from a query in a closure
*
* Usage:
* logQueries(function() {
* return User::first()->applications;
* });
*
* @param closure $callback function to call some queries in
* @return Illuminate\Support\Collection Collection of queries
*/
function logQueries(closure $callback)
{
// check if query logging is enabled
$logging = DB::logging();
// Get number of queries
$numberOfQueries = count(DB::getQueryLog());
// if logging not enabled, temporarily enable it
if( !$logging ) DB::enableQueryLog();
$query = $callback();
$lastQuery = getSql($query);
// Get querylog
$queries = new Illuminate\Support\Collection( DB::getQueryLog() );
// calculate the number of queries done in callback
$queryCount = $queries->count() - $numberOfQueries;
// Get last queries
$lastQueries = $queries->take(-$queryCount);
// disable query logging
if( !$logging ) DB::disableQueryLog();
// if callback returns a builder object, return the sql and bindings of it
if( $lastQuery )
{
$lastQueries->push($lastQuery);
}
return $lastQueries;
}
Uso:
getSql( DB::table('users') );
// returns
// [
// "sql" => "select * from `users`",
// "bindings" => [],
// ]
getSql( $project->rooms() );
// returns
// [
// "sql" => "select * from `rooms` where `rooms`.`project_id` = ? and `rooms`.`project_id` is not null",
// "bindings" => [ 7 ],
// ]
Por mais que eu ame essa estrutura, odeio quando ela age como lixo.
DB::enableQueryLog()
é totalmente inútil. DB::listen
é igualmente inútil. Ele mostrou parte da consulta quando eu disse $query->count()
, mas se eu fizer$query->get()
, não tem nada a dizer.
A única solução que parece funcionar consistentemente é colocar intencionalmente alguma sintaxe ou outro erro nos parâmetros ORM, como um nome de coluna / tabela inexistente, executar seu código na linha de comando enquanto estiver no modo de depuração, e isso expelirá o erro SQL com a consulta completa, finalmente. Caso contrário, espero que o erro apareça no arquivo de log, se executado a partir do servidor web.
Se você estiver usando o funileiro e quiser registrar a consulta SQL formada, poderá fazer
$ php artisan tinker
Psy Shell v0.9.9 (PHP 7.3.5 — cli) by Justin Hileman
>>> DB::listen(function ($query) { dump($query->sql); dump($query->bindings); dump($query->time); });
=> null
>>> App\User::find(1)
"select * from `users` where `users`.`id` = ? limit 1"
array:1 [
0 => 1
]
6.99
=> App\User {#3131
id: 1,
name: "admin",
email: "admin@example.com",
created_at: "2019-01-11 19:06:23",
updated_at: "2019-01-11 19:06:23",
}
>>>
Tente o seguinte:
$results = DB::table('users')->toSql();
dd($results);
Nota: get () foi substituído por toSql () para exibir a consulta SQL bruta.
Minha maneira de fazer isso, com base na exibição de log, só precisa modificar o arquivo app/Providers/AppServiceProvider.php
:
app/Providers/AppServiceProvider.php
/**
* Bootstrap any application services.
*
* @return void
*/
public function boot()
{
//
DB::listen(function ($query) {
$querySql = str_replace(['?'], ['\'%s\''], $query->sql);
$queryRawSql = vsprintf($querySql, $query->bindings);
Log::debug('[SQL EXEC]', [
"raw sql" => $queryRawSql,
"time" => $query->time,
]
);
});
}
$users = DB::table('users')
->select(DB::raw('count(*) as user_count, username '))
->where('uid', '>=', 10)
->limit(100)
->groupBy('username')
->get()
;
dd($users);
storage/logs/laravel-2019-10-27.log
:[2019-10-27 17:39:17] local.DEBUG: [SQL EXEC] {"raw sql":"select count(*) as user_count, username from `users` where `uid` >= '10' group by `username` limit 100","time":304.21}
echo User::where('status', 1)->toSql();