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?

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.)

Use o toSql()método em uma QueryBuilderinstâ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.

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

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"
}

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 enableQueryLogmé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();

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 ...

$data = User::toSql();
echo $data; //this will retrun select * from users. //here User is model

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);

Primeira maneira:

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 .

Segunda maneira:

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.

1. 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());
   });

2. Adicione um alias para o Eloquent Builder. ( Laravel 5.4+ )

   \Illuminate\Database\Eloquent\Builder::macro('toRawSql', function(){
       return ($this->getQuery()->toRawSql());
   });

3. 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 Macroablecaracterística, não é possível adicionar toRawSqlum 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());

use pacote debugbar

composer require "barryvdh/laravel-debugbar": "2.3.*"

De laravel 5.2e em diante. você pode usar DB::listenpara obter consultas executadas.

DB::listen(function ($query) {
    // $query->sql
    // $query->bindings
    // $query->time
});

Ou se você deseja depurar uma única Builderinstância, pode usar o toSqlmé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_ate mudei para created_atsadicionando 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, Como pivot_set_id, eqtype_jobs.job_id Como pivot_job_id, eqtype_jobs. created_ats Como pivot_created_ats, eqtype_jobs. updated_atComo pivot_updated_at, eqtype_jobs. idComo pivot_idde jobsjunção interna eqtype_jobsem jobs. id= eqtype_jobs. job_idonde eqtype_jobs. set_id= 56 ordem pelo pivot_created_atlimite 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 sde 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 .

Para ver a consulta executada pelo Laravel, use o log de consultas laravel

DB::enableQueryLog();

$queries = DB::getQueryLog();

A partir de Laravel 5.8.15 o construtor de consulta tem agora dd e dumpmé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()
    {
        //
    }
}

Fonte

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 useronde lang= ordem 'en' e status= '1' pelo updated_atlimite 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: "[email protected]",
     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:

1. Adicione este código em 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,
            ]
        );
    });
}

2. Meu código de identificador sql:

$users = DB::table('users')
    ->select(DB::raw('count(*) as user_count, username '))
    ->where('uid', '>=', 10)
    ->limit(100)
    ->groupBy('username')
    ->get()
;
dd($users);

3. Veja o log 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}