Doktrin - Wie druckt man die echte SQL aus, nicht nur die vorbereitete Aussage?

Wir verwenden Doctrine, ein PHP-ORM. Ich erstelle eine Abfrage wie folgt:

$q = Doctrine_Query::create()->select('id')->from('MyTable');

und dann füge ich in der Funktion verschiedene where-Klauseln und entsprechende Dinge hinzu

$q->where('normalisedname = ? OR name = ?', array($string, $originalString));

Später, bevor execute()ich dieses Abfrageobjekt erhalte, möchte ich das unformatierte SQL ausdrucken, um es zu untersuchen, und dies tun:

$q->getSQLQuery();

Dies druckt jedoch nur die vorbereitete Anweisung aus, nicht die vollständige Abfrage. Ich möchte sehen, was es an MySQL sendet, aber stattdessen druckt es eine vorbereitete Anweisung aus, einschließlich ?'s. Gibt es eine Möglichkeit, die 'vollständige' Abfrage anzuzeigen?

Doctrine sendet keine "echte SQL-Abfrage" an den Datenbankserver: Es werden tatsächlich vorbereitete Anweisungen verwendet, was bedeutet:

• Senden der Erklärung, damit sie vorbereitet wird (dies wird von zurückgegeben $query->getSql())
• Und dann Senden der Parameter (zurückgegeben von $query->getParameters())
• und Ausführen der vorbereiteten Anweisungen

Dies bedeutet, dass es auf der PHP-Seite niemals eine "echte" SQL-Abfrage gibt - Doctrine kann sie daher nicht anzeigen.

Ein Arbeitsbeispiel:

$qb = $this->createQueryBuilder('a');
$query=$qb->getQuery();
// SHOW SQL: 
echo $query->getSQL(); 
// Show Parameters: 
echo $query->getParameters();

Sie können die von Ihrer App ausgeführte Abfrage überprüfen, wenn Sie alle Abfragen in MySQL protokollieren:

http://dev.mysql.com/doc/refman/5.1/en/query-log.html

Es wird mehr Abfragen geben, nicht nur die, die Sie suchen, sondern Sie können danach suchen.

->getSql();funktioniert aber normalerweise

Bearbeiten:

um alle von mir verwendeten MySQL-Abfragen anzuzeigen

sudo vim /etc/mysql/my.cnf 

und fügen Sie diese 2 Zeilen hinzu:

general_log = on
general_log_file = /tmp/mysql.log

und starte mysql neu

Ich habe einen Doctrine2-Logger erstellt, der genau dies tut. Es "hydratisiert" die parametrisierte SQL-Abfrage mit den Werten unter Verwendung von Doctrine 2-eigenen Datentypkonvertern.

<?php


namespace Drsm\Doctrine\DBAL\Logging;
use Doctrine\DBAL\Logging\SQLLogger,
    Doctrine\DBAL\Types\Type,
    Doctrine\DBAL\Platforms\AbstractPlatform;
/**
 * A SQL logger that logs to the standard output and
 * subtitutes params to get a ready to execute SQL sentence

 * @author  dsamblas@gmail.com
 */
class EchoWriteSQLWithoutParamsLogger implements SQLLogger

{
    const QUERY_TYPE_SELECT="SELECT";
    const QUERY_TYPE_UPDATE="UPDATE";
    const QUERY_TYPE_INSERT="INSERT";
    const QUERY_TYPE_DELETE="DELETE";
    const QUERY_TYPE_CREATE="CREATE";
    const QUERY_TYPE_ALTER="ALTER";

    private $dbPlatform;
    private $loggedQueryTypes;
    public function __construct(AbstractPlatform $dbPlatform, array $loggedQueryTypes=array()){
        $this->dbPlatform=$dbPlatform;
        $this->loggedQueryTypes=$loggedQueryTypes;
    }
    /**
     * {@inheritdoc}
     */
    public function startQuery($sql, array $params = null, array $types = null)

    {
        if($this->isLoggable($sql)){
            if(!empty($params)){
                foreach ($params as $key=>$param) {
                    $type=Type::getType($types[$key]);
                    $value=$type->convertToDatabaseValue($param,$this->dbPlatform);
                    $sql = join(var_export($value, true), explode('?', $sql, 2));
                }

            }
            echo $sql . " ;".PHP_EOL;
        }
    }

    /**
     * {@inheritdoc}
     */
    public function stopQuery()
    {

    }
    private function isLoggable($sql){
        if (empty($this->loggedQueryTypes)) return true;
        foreach($this->loggedQueryTypes as $validType){
            if (strpos($sql, $validType) === 0) return true;
        }
        return false;
    }
}

Anwendungsbeispiel:; Der folgende Code-Frieden gibt bei der Standardausgabe alle mit $ em Entity Manager generierten SQL-Sätze INSERT, UPDATE und DELETE wieder.

/**@var  \Doctrine\ORM\EntityManager $em */
$em->getConnection()
                ->getConfiguration()
                ->setSQLLogger(
                    new EchoWriteSQLWithoutParamsLogger(
                        $em->getConnection()->getDatabasePlatform(),
                        array(
                            EchoWriteSQLWithoutParamsLogger::QUERY_TYPE_UPDATE,
                            EchoWriteSQLWithoutParamsLogger::QUERY_TYPE_INSERT,
                            EchoWriteSQLWithoutParamsLogger::QUERY_TYPE_DELETE
                        )
                    )
                );

getSqlQuery() Zeigt technisch den gesamten SQL-Befehl an, ist jedoch viel nützlicher, wenn Sie auch die Parameter sehen können.

echo $q->getSqlQuery();
foreach ($q->getFlattenedParams() as $index => $param)
  echo "$index => $param";

Um dieses Muster wiederverwendbarer zu machen, gibt es einen netten Ansatz, der in den Kommentaren unter Raw SQL von Doctrine Query Object beschrieben wird .

Es gibt keine andere echte Abfrage. So funktionieren vorbereitete Anweisungen. Die Werte werden auf dem Datenbankserver und nicht in der Anwendungsschicht gebunden.

Siehe meine Antwort auf diese Frage: Wie überprüfe ich in PHP mit PDO die endgültige parametrisierte SQL-Abfrage?

(Zur Vereinfachung hier wiederholt :)

Die Verwendung vorbereiteter Anweisungen mit parametrisierten Werten ist nicht einfach eine andere Möglichkeit, eine SQL-Zeichenfolge dynamisch zu erstellen. Sie erstellen eine vorbereitete Anweisung in der Datenbank und senden dann nur die Parameterwerte.

Was also wahrscheinlich an die Datenbank gesendet wird, ist ein PREPARE ..., dann SET ...und schließlichEXECUTE ....

Sie können keine SQL-Zeichenfolge wie erhalten SELECT * FROM ..., selbst wenn dies zu gleichwertigen Ergebnissen führen würde, da keine solche Abfrage jemals tatsächlich an die Datenbank gesendet wurde.

Meine Lösung:

 /**
 * Get SQL from query
 * 
 * @author Yosef Kaminskyi 
 * @param QueryBilderDql $query
 * @return int
 */
public function getFullSQL($query)
{
    $sql = $query->getSql();
    $paramsList = $this->getListParamsByDql($query->getDql());
    $paramsArr =$this->getParamsArray($query->getParameters());
    $fullSql='';
    for($i=0;$i<strlen($sql);$i++){
        if($sql[$i]=='?'){
            $nameParam=array_shift($paramsList);

            if(is_string ($paramsArr[$nameParam])){
                $fullSql.= '"'.addslashes($paramsArr[$nameParam]).'"';
             }
            elseif(is_array($paramsArr[$nameParam])){
                $sqlArr='';
                foreach ($paramsArr[$nameParam] as $var){
                    if(!empty($sqlArr))
                        $sqlArr.=',';

                    if(is_string($var)){
                        $sqlArr.='"'.addslashes($var).'"';
                    }else
                        $sqlArr.=$var;
                }
                $fullSql.=$sqlArr;
            }elseif(is_object($paramsArr[$nameParam])){
                switch(get_class($paramsArr[$nameParam])){
                    case 'DateTime':
                             $fullSql.= "'".$paramsArr[$nameParam]->format('Y-m-d H:i:s')."'";
                          break;
                    default:
                        $fullSql.= $paramsArr[$nameParam]->getId();
                }

            }
            else                     
                $fullSql.= $paramsArr[$nameParam];

        }  else {
            $fullSql.=$sql[$i];
        }
    }
    return $fullSql;
}

 /**
 * Get query params list
 * 
 * @author Yosef Kaminskyi <yosefk@spotoption.com>
 * @param  Doctrine\ORM\Query\Parameter $paramObj
 * @return int
 */
protected function getParamsArray($paramObj)
{
    $parameters=array();
    foreach ($paramObj as $val){
        /* @var $val Doctrine\ORM\Query\Parameter */
        $parameters[$val->getName()]=$val->getValue();
    }

    return $parameters;
}
 public function getListParamsByDql($dql)
{
    $parsedDql = preg_split("/:/", $dql);
    $length = count($parsedDql);
    $parmeters = array();
    for($i=1;$i<$length;$i++){
        if(ctype_alpha($parsedDql[$i][0])){
            $param = (preg_split("/[' ' )]/", $parsedDql[$i]));
            $parmeters[] = $param[0];
        }
    }

    return $parmeters;}

Anwendungsbeispiel:

$query = $this->_entityRepository->createQueryBuilder('item');
$query->leftJoin('item.receptionUser','users');
$query->where('item.customerid = :customer')->setParameter('customer',$customer)
->andWhere('item.paymentmethod = :paymethod')->setParameter('paymethod',"Bonus");
echo $this->getFullSQL($query->getQuery());

Mit dem folgenden Ansatz können Sie problemlos auf die SQL-Parameter zugreifen.

   $result = $qb->getQuery()->getSQL();

   $param_values = '';  
   $col_names = '';   

   foreach ($result->getParameters() as $index => $param){              
            $param_values .= $param->getValue().',';
            $col_names .= $param->getName().',';
   } 

   //echo rtrim($param_values,',');
   //echo rtrim($col_names,',');    

Also, wenn Sie das $param_valuesund ausgedruckt haben$col_names , können Sie die Parameterwerte über die SQL- und die jeweiligen Spaltennamen abrufen.

Hinweis: Wenn $paramein Array zurückgegeben wird, müssen Sie es als Parameter wiederholenIN (:?) normalerweise als verschachteltes Array vorliegen.

Wenn Sie in der Zwischenzeit einen anderen Ansatz gefunden haben, teilen Sie uns dies bitte mit :)

Danke dir!

Klarere Lösung:

 /**
 * Get string query 
 * 
 * @param Doctrine_Query $query
 * @return string
 */
public function getDqlWithParams(Doctrine_Query $query){
    $vals = $query->getFlattenedParams();
    $sql = $query->getDql();
    $sql = str_replace('?', '%s', $sql);
    return vsprintf($sql, $vals);
}

Solution:1
====================================================================================

function showQuery($query)
{
    return sprintf(str_replace('?', '%s', $query->getSql()), $query->getParams());
}

// call function  
echo showQuery($doctrineQuery);

Solution:2
====================================================================================

function showQuery($query)
{
    // define vars              
    $output    = NULL;
    $out_query = $query->getSql();
    $out_param = $query->getParams();

    // replace params
   for($i=0; $i<strlen($out_query); $i++) {
       $output .= ( strpos($out_query[$i], '?') !== FALSE ) ? "'" .str_replace('?', array_shift($out_param), $out_query[$i]). "'" : $out_query[$i];
   }

   // output
   return sprintf("%s", $output);
}

// call function  
echo showQuery($doctrineQueryObject);

Sie können verwenden:

$query->getSQL();

Wenn Sie MySQL verwenden, können Sie Workbench verwenden, um laufende SQL-Anweisungen anzuzeigen. Sie können die laufende Abfrage auch über MySQL anzeigen, indem Sie Folgendes verwenden:

 SHOW FULL PROCESSLIST \G

Vielleicht kann es für jemanden nützlich sein:

// Printing the SQL with real values
$vals = $query->getFlattenedParams();
foreach(explode('?', $query->getSqlQuery()) as $i => $part) {
    $sql = (isset($sql) ? $sql : null) . $part;
    if (isset($vals[$i])) $sql .= $vals[$i];
}

echo $sql;

TL; DR

$qb = ... // your query builder
$query = $qb->getQuery();
// temporarily enable logging for your query (will also work in prod env)
$conf = $query->getEntityManager()->getConnection()->getConfiguration();
$backupLogger = $conf->getSQLLogger();
$logger = new \Doctrine\DBAL\Logging\DebugStack();
$conf->setSQLLogger($logger);
// execute query
$res = $query->getResult();
$conf->setSQLLogger($backupLogger); //restore logger for other queries
$params = [
  'query' => array_pop($logger->queries) //extract query log details
  //your other twig params here...
]
return $params; //send this to your twig template...

Verwenden Sie in Ihren Zweigdateien die Zweighilfefilter von Doctrine:

// show raw query:
{{ (query.sql ~ ';')|doctrine_replace_query_parameters(query.params)
// highlighted
{{ (query.sql ~ ';')|doctrine_replace_query_parameters(query.params)|doctrine_pretty_query(highlight_only = true) }}
// highlighted and formatted (i.e. with tabs and newlines)
{{ (query.sql ~ ';')|doctrine_replace_query_parameters(query.params)|doctrine_pretty_query }}

Erläuterung:

Die anderen Antworten, in denen erwähnt wird, dass vorbereitete Anweisungen tatsächlich "echte Abfragen" sind, sind richtig, aber sie beantworten nicht die offensichtlichen Erwartungen des Fragestellers ... Jeder Entwickler möchte eine "ausführbare Abfrage" zum Debuggen anzeigen (oder sie dem Benutzer anzeigen). .

Also habe ich in der Quelle des Symfony-Profilers nachgesehen, wie sie das machen. Der Doctrine-Teil liegt in der Verantwortung von Doctrine, daher haben sie ein Doctrine-Bündel zur Integration in Symfony erstellt. Einen Blick auf diedoctrine-bundle/Resources/views/Collector/db.html.twig Datei , werden Sie herausfinden, wie sie dies tun (dies kann sich je nach Version ändern). Interessanterweise haben sie Zweigfilter erstellt, die wir wiederverwenden können (siehe oben).

Damit alles funktioniert, müssen wir die Protokollierung für unsere Abfrage aktivieren. Es gibt mehrere Möglichkeiten, dies zu tun, und hier verwende ich DebugStack, mit dem Abfragen protokolliert werden können, ohne sie tatsächlich zu drucken. Dies stellt auch sicher, dass dies im Produktionsmodus funktioniert, wenn Sie dies benötigen ...

Wenn Sie weitere Formatierungen benötigen, werden Sie feststellen, dass sie CSS in einem Style-Tag enthalten. Stehlen Sie es also einfach ^^:

.highlight pre { margin: 0; white-space: pre-wrap; }
.highlight .keyword   { color: #8959A8; font-weight: bold; }
.highlight .word      { color: #222222; }
.highlight .variable  { color: #916319; }
.highlight .symbol    { color: #222222; }
.highlight .comment   { color: #999999; }
.highlight .backtick  { color: #718C00; }
.highlight .string    { color: #718C00; }
.highlight .number    { color: #F5871F; font-weight: bold; }
.highlight .error     { color: #C82829; }

Hoffe das wird helfen ;-)

Ich habe einen einfachen Logger geschrieben, der Abfragen mit eingefügten Parametern protokollieren kann. Installation:

composer require cmyker/doctrine-sql-logger:dev-master

Verwendung:

$connection = $this->getEntityManager()->getConnection(); 
$logger = new \Cmyker\DoctrineSqlLogger\Logger($connection);
$connection->getConfiguration()->setSQLLogger($logger);
//some query here
echo $logger->lastQuery;

$sql = $query->getSQL();

$parameters = [];
    foreach ($query->getParameters() as $parameter) {
        $parameters[] = $parameter->getValue();
    }

$result = $connection->executeQuery($sql, $parameters)
        ->fetchAll();

Die Funktion @dsamblas wurde so geändert, dass sie funktioniert, wenn Parameter Datumszeichenfolgen wie diese '2019-01-01' sind und wenn ein Array mit IN like übergeben wird

$qb->expr()->in('ps.code', ':activeCodes'),

. Machen Sie also alles, was dsamblas geschrieben hat, aber ersetzen Sie startQuery durch dieses oder sehen Sie sich die Unterschiede an und fügen Sie meinen Code hinzu. (falls er etwas in seiner Funktion geändert hat und meine Version keine Änderungen hat).

public function startQuery($sql, array $params = null, array $types = null)

{
    if($this->isLoggable($sql)){
        if(!empty($params)){
            foreach ($params as $key=>$param) {

                try {
                    $type=Type::getType($types[$key]);
                    $value=$type->convertToDatabaseValue($param,$this->dbPlatform);
                } catch (Exception $e) {
                    if (is_array($param)) {
                        // connect arrays like ("A", "R", "C") for SQL IN
                        $value = '"' . implode('","', $param) . '"';
                    } else {
                        $value = $param; // case when there are date strings
                    }
                }

                $sql = join(var_export($value, true), explode('?', $sql, 2));
            }

        }
        echo $sql . " ;".PHP_EOL;
    }
}

Hat nicht viel getestet.

Ich habe einige Nachforschungen zu diesem Thema angestellt, weil ich eine generierte SQL-Abfrage debuggen und im SQL-Editor ausführen wollte. Wie aus allen Antworten hervorgeht, handelt es sich um ein hochtechnisches Thema.

Wenn ich davon ausgehe, dass die erste Frage auf dev-env basiert, fehlt im Moment eine sehr einfache Antwort. Sie können einfach den Build in Symfony Profiler verwenden. Klicken Sie einfach auf die Registerkarte "Doktrin" und blättern Sie zu der Abfrage, die Sie überprüfen möchten. Klicken Sie dann auf "Ausführbare Abfrage anzeigen" und Sie können Ihre Abfrage direkt in Ihren SQL-Editor einfügen

Mehr UI-Basisansatz, aber sehr schnell und ohne Debugging-Code-Overhead.

$sql = $query->getSQL();
$obj->mapDQLParametersNamesToSQL($query->getDQL(), $sql);
echo $sql;//to see parameters names in sql
$obj->mapDQLParametersValuesToSQL($query->getParameters(), $sql);
echo $sql;//to see parameters values in sql

public function mapDQLParametersNamesToSQL($dql, &$sql)
{
    $matches = [];
    $parameterNamePattern = '/:\w+/';
    /** Found parameter names in DQL */
    preg_match_all($parameterNamePattern, $dql, $matches);
    if (empty($matches[0])) {
        return;
    }
    $needle = '?';
    foreach ($matches[0] as $match) {
        $strPos = strpos($sql, $needle);
        if ($strPos !== false) {
            /** Paste parameter names in SQL */
            $sql = substr_replace($sql, $match, $strPos, strlen($needle));
        }
    }
}

public function mapDQLParametersValuesToSQL($parameters, &$sql)
{
    $matches = [];
    $parameterNamePattern = '/:\w+/';
    /** Found parameter names in SQL */
    preg_match_all($parameterNamePattern, $sql, $matches);
    if (empty($matches[0])) {
        return;
    }
    foreach ($matches[0] as $parameterName) {
        $strPos = strpos($sql, $parameterName);
        if ($strPos !== false) {
            foreach ($parameters as $parameter) {
                /** @var \Doctrine\ORM\Query\Parameter $parameter */
                if ($parameterName !== ':' . $parameter->getName()) {
                    continue;
                }
                $parameterValue = $parameter->getValue();
                if (is_string($parameterValue)) {
                    $parameterValue = "'$parameterValue'";
                }
                if (is_array($parameterValue)) {
                    foreach ($parameterValue as $key => $value) {
                        if (is_string($value)) {
                            $parameterValue[$key] = "'$value'";
                        }
                    }
                    $parameterValue = implode(', ', $parameterValue);
                }
                /** Paste parameter values in SQL */
                $sql = substr_replace($sql, $parameterValue, $strPos, strlen($parameterName));
            }
        }
    }
}

Verwenden Sie Folgendes, um eine SQL-Abfrage in Doctrine auszudrucken:

$query->getResult()->getSql();