सिद्धांत - वास्तविक एसक्यूएल को कैसे प्रिंट किया जाए, न कि केवल तैयार कथन?

Question

हम Doctrine, PHP ORM का उपयोग कर रहे हैं। मैं इस तरह से एक प्रश्न बना रहा हूं:

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

और फिर इस फंक्शन में मैं विभिन्न प्रकार के क्लॉज़ और चीजों को जोड़ रहा हूँ, जैसे कि उपयुक्त

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

बाद में execute()उस क्वेरी ऑब्जेक्ट के पहले , मैं इसे जाँचने के लिए कच्ची एसक्यूएल का प्रिंट आउट लेना चाहता हूँ और यह करूँ:

$q->getSQLQuery();

हालाँकि यह केवल तैयार किए गए कथन को प्रिंट करता है, पूर्ण क्वेरी को नहीं। मैं यह देखना चाहता हूं कि यह MySQL को क्या भेज रहा है, लेकिन इसके बजाय यह एक तैयार स्टेटमेंट को प्रिंट कर रहा है, जिसमें शामिल है ?। क्या 'पूर्ण' क्वेरी देखने का कोई तरीका है?

Comments

: सबसे अच्छा तरीका है मैं पूरी क्वेरी को देखने के लिए मिल गया है क्या यह उत्तर में वर्णन किया गया stackoverflow.com/a/678310/229077

— मारेक

आप डॉक्ट्रिन द्वारा किए गए कार्यों का लाभ उठा सकते हैं (प्रोफाइलर एक रनवेबल क्वेरी प्रदर्शित कर रहा है)। विवरण के लिए मेरा जवाब नीचे देखें

— विंसेंट पज़ेलर

Answer 1

सिद्धांत डेटाबेस में "वास्तविक एसक्यूएल क्वेरी" नहीं भेज रहा है: यह वास्तव में तैयार बयानों का उपयोग कर रहा है, जिसका अर्थ है:

• स्टेटमेंट भेजना, इसके लिए तैयार रहना (यह वही है जो लौटा है $query->getSql())
• और, फिर, पैरामीटर भेजना (द्वारा लौटाया गया $query->getParameters())
• और तैयार किए गए कथनों को निष्पादित करना

इसका मतलब यह है कि PHP की तरफ कभी भी "वास्तविक" SQL क्वेरी नहीं है - इसलिए, Doctrine इसे प्रदर्शित नहीं कर सकता है।

Comments

पास्कल: आपको यह नहीं कहना चाहिए कि यह "वास्तविक एसक्यूएल क्वेरी" नहीं है क्योंकि तैयार स्टेटमेंट वास्तविक एसक्यूएल क्वेरी है, यह सिर्फ इतना है कि पैरामीटर अलग से भेजे गए हैं। यह शब्दांकन लोगों को भ्रमित कर सकता है (जैसे olivierpons.fr/2014/03/22/symfony-2-avantages-et-inconvenients )।

— मैथ्यू नेपोली

$query->getParameters();मापदंडों को सही क्रम में नहीं लौटाएगा, क्योंकि उन्हें तैयार क्वेरी स्टेटमेंट में दिखाई देना चाहिए

— गोंडो

मुझे लगता है कि यहां प्रश्न के लेखक ने यह ध्यान नहीं दिया कि सिद्धांत क्या भेजता है या नहीं। उपयोगकर्ता और मैं जानना चाहते थे कि क्वेरी कैसे प्राप्त करें जिसे हम पेस्ट कॉपी कर सकते हैं और मापदंडों के साथ प्रश्न चिह्न को मैन्युअल रूप से प्रतिस्थापित किए बिना चला सकते हैं। जैसे कोडिग्निटर में। मुझे लगता है कि मैंने इसे सिम्फनी डीबगर में पाया था, लेकिन मैं तब भी नहीं मिल सकता जब मैं कमांड लाइन से स्क्रिप्ट चलाता हूं।

— डेरियस .V

Answer 2

एक कार्य उदाहरण:

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

Comments

जब भी यह चर असाइनमेंट के रूप में काम करता है, तो आप इस पर विचार करना चाह सकते हैं: $ क्वेरी प्रिंट करें-> getSQL (); foreach ($ क्वेरी-> getParameters () as per param) {प्रिंट "{$ param-> getName ()} -> {$ param-> getValue ()} \ n"; } जैसा कि आपको एक अधिक पठनीय आउटपुट मिलेगा

— जस्टिन फ़िंकेलस्टीन

यह लिटेल को लाभ देता है। जब मैं sql की प्रतिलिपि बनाता हूं, तो मेरे पास अभी भी खोज पैरामीटर है जहां मैन्युअल रूप से सम्मिलित करना है, इसमें टन का समय लगता है। हम सम्मिलित पैरामीटर्स के साथ एक क्वेरी चाहते हैं, हम इसे इतने लंबे समय तक क्यों नहीं पा सकते हैं? यहां तक ​​कि कोडिग्नेटर फ्रेमवर्क में जहां तक ​​मुझे याद है, प्रोफाइलर में आप क्वेरी को कॉपी कर सकते हैं और मैन्युअल रूप से बिना तुरंत चला सकते हैं। हमें सिम्फनी पर भी ऐसा ही चाहिए।

— डेरियस .V

Answer 3

यदि आप mysql में सभी प्रश्नों को लॉग करते हैं, तो आप अपने ऐप द्वारा निष्पादित क्वेरी की जांच कर सकते हैं:

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

न केवल आपके द्वारा खोजा जा रहा है, बल्कि इसके लिए और अधिक प्रश्न हो सकते हैं।

लेकिन आमतौर पर ->getSql();काम करता है

संपादित करें:

मेरे द्वारा उपयोग किए जाने वाले सभी mysql प्रश्नों को देखने के लिए

sudo vim /etc/mysql/my.cnf 

और उन 2 लाइनों को जोड़ें:

general_log = on
general_log_file = /tmp/mysql.log

और mysql को पुनरारंभ करें

Answer 4

मैंने एक Doctrine2 लकड़हारा बनाया है जो ठीक यही करता है। यह डॉक्ट्रिन 2 स्वयं के डेटा प्रकार वार्तालापों का उपयोग करके मानों के साथ पैराट्राइज्ड एसक्यूएल क्वेरी को "हाइड्रेट" करता है।

<?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  [e-mail]
 */
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;
    }
}

उपयोग उदाहरण:; कोड की निम्नलिखित शांति मानक उत्पादन पर किसी भी INSERT, UPDATE, DELETE SQL वाक्य $ emityity, के साथ उत्पन्न होगी।

/**@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
                        )
                    )
                );

Comments

जब पैरामीटर '2019-01-01' की तरह तार-तार होते हैं तो काम नहीं करता है

— Darius.V

Answer 5

getSqlQuery() तकनीकी रूप से पूरे SQL कमांड को दिखाता है, लेकिन जब आप मापदंडों को देख सकते हैं तो यह बहुत अधिक उपयोगी होता है।

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

इस पैटर्न को अधिक पुन: प्रयोज्य बनाने के लिए, डॉक्ट्रीन क्वेरी ऑब्जेक्ट से रॉ एसक्यूएल में टिप्पणियों में वर्णित एक अच्छा तरीका है ।

Comments

मुझे पता है कि यह एक पुरानी पोस्ट है, लेकिन आपके दोनों लिंक 404 पेज तक ले जाते हैं। क्या आप अपना जवाब अपडेट कर सकते हैं? मैं पूछ रहा हूं, क्योंकि मुझे यकीन नहीं है कि आपका क्या मतलब है $q। यह प्रश्न और न ही क्वेरी बिल्डर प्रतीत नहीं होता है।

— k00ni

मुझे डर है कि मुझे अधिक पुन: प्रयोज्य कोड नहीं मिल सकता है। $qइस मामले में एक सिद्धांत 1 प्रश्न है। आप डॉक्ट्रिन 2 का उपयोग कर रहे होंगे, जिस स्थिति में आप $qb = $this->createQueryBuilder('a'); $q = $qb->getQuery(); $sql = $q->getSQL(); $params = $q->getParameters(); उम्मीद की तरह कुछ चाहते हैं जो मदद करता है!

— ladenedge

Answer 6

कोई अन्य वास्तविक क्वेरी नहीं है, यह इस तरह से तैयार किया गया कथन है। मान डेटाबेस सर्वर में बाध्य होते हैं, एप्लिकेशन परत में नहीं।

इस सवाल का मेरा जवाब देखें: पीडीओ के साथ PHP में, अंतिम SQL पैराट्राइज्ड क्वेरी की जांच कैसे करें?

(सुविधा के लिए यहां दोहराया :)

पैरामीटराइज़्ड मानों के साथ तैयार स्टेटमेंट का उपयोग करना एसक्यूएल का एक स्ट्रिंग गतिशील रूप से बनाने का एक और तरीका नहीं है। आप डेटाबेस में एक तैयार स्टेटमेंट बनाते हैं, और उसके बाद अकेले पैरामीटर मान भेजते हैं।

तो क्या डेटाबेस के लिए भेजा जाता है एक होगा PREPARE ..., फिर SET ...और अंत मेंEXECUTE ....

आप कुछ SQL स्ट्रिंग प्राप्त करने में सक्षम नहीं होंगे SELECT * FROM ... , भले ही यह समकक्ष परिणाम उत्पन्न करेगा, क्योंकि ऐसी कोई क्वेरी वास्तव में डेटाबेस में कभी नहीं भेजी गई थी।

Answer 7

मेरा समाधान:

 /**
 * 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 <[e-mail]>
 * @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;}

उपयोग का उदाहरण:

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

Comments

इसके लिए आपको धन्यवाद: D

— Saad Achemlal

बहुत अच्छा। सामान्य प्रश्नों के साथ काम करता है, लेकिन मुझे regexp के साथ एक क्वेरी मिली है और ऐसा लगता है कि $ qb = $ इस का समर्थन नहीं करता है-> createQueryBuilder ('r') -> innerJoin ('r.profile', 'p')>> addSelect (') p ') -> कहाँ (' REGEXP (: fileNamePattern, r.fileNamePattern) = 1 ') -> और कहाँ (' p.incomingLocation =: आने वाली लीला ') -> setararameters ([' fileNamePattern '=> $ fileName,' आने वाली ' => $ स्थान]) -> getQuery ();

— फहीम

सभी प्रश्नों के साथ काम नहीं करता है। जब मैं इस किया था -> setParameters (सरणी ( 'insuranceCarrier' => $ insuranceCarrier, 'dateFrom' => $ dateFrom-> प्रारूप ( 'YM-प'), 'dateTo' => $ dateTo-> प्रारूप ( 'Ym- d '),)) उन लोगों को छोड़ दिया गया था? एसक्यूएल में निशान।

— डेरियस

Answer 8

आप निम्न दृष्टिकोण का उपयोग करके आसानी से SQL मापदंडों तक पहुंच सकते हैं।

   $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,',');    

तो अगर आप बाहर मुद्रित $param_valuesऔर $col_names, आप एसक्यूएल और संबंधित स्तंभ नाम के माध्यम से गुजर पैरामीटर मान प्राप्त कर सकते हैं।

नोट: यदि $paramकोई सरणी देता है, तो आपको पुन: पुनरावृति करने की आवश्यकता है, क्योंकि IN (:?)आमतौर पर अंदर आने वाले पैरामीटर एक नेस्टेड सरणी के रूप में है।

इस बीच यदि आप एक और दृष्टिकोण मिला, कृपया हमारे साथ साझा करने के लिए पर्याप्त हो :)

धन्यवाद!

Answer 9

अधिक स्पष्ट समाधान:

 /**
 * 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);
}

Comments

$ query-> getFlattenedParams (); मौजूद नहीं है

— डेवलपर

Answer 10

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

Answer 11

आप उपयोग कर सकते हैं :

$query->getSQL();

यदि आप MySQL का उपयोग कर रहे हैं, तो आप SQL स्टेटमेंट को देखने के लिए वर्कबेंच का उपयोग कर सकते हैं। आप निम्नलिखित का उपयोग करके mysql से चल रहे क्वेरी को देखने का उपयोग कर सकते हैं:

 SHOW FULL PROCESSLIST \G

Answer 12

शायद यह किसी के लिए उपयोगी हो सकता है:

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

Answer 13

टी एल; डॉ

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

अपनी टहनी फ़ाइलों में, 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 }}

स्पष्टीकरण:

अन्य उत्तर जो उल्लेख करते हैं कि तैयार कथन वास्तव में "वास्तविक प्रश्न" सही हैं, लेकिन वे स्पष्ट प्रश्नकर्ता की अपेक्षा का जवाब नहीं देते हैं ... प्रत्येक डेवलपर डिबगिंग के लिए "रन करने योग्य क्वेरी" प्रदर्शित करना चाहता है (या इसे उपयोगकर्ता को प्रदर्शित करना चाहता है) ।

इसलिए, मैंने सिम्फनी प्रोफाइलर के स्रोत में देखा कि वे इसे कैसे करते हैं। डॉक्ट्रिन भाग डॉक्ट्रिन की जिम्मेदारी है इसलिए उन्होंने सिम्फनी के साथ एकीकरण करने के लिए एक सिद्धांत-बंडल बनाया। doctrine-bundle/Resources/views/Collector/db.html.twigफ़ाइल को देखने के बाद , आपको पता चलेगा कि वे इसे कैसे करते हैं (यह संस्करणों में बदल सकता है)। दिलचस्प बात यह है कि उन्होंने ट्विग फिल्टर्स बनाए हैं जिनका हम पुनः उपयोग कर सकते हैं (ऊपर देखें)।

सब कुछ काम करने के लिए हमें अपनी क्वेरी के लिए लॉगिंग सक्षम करने की आवश्यकता है। ऐसा करने के कई तरीके हैं और यहां मैं डिबगस्टैक का उपयोग करता हूं जो प्रश्नों को वास्तव में प्रिंट किए बिना लॉग इन करने की अनुमति देता है। यह भी सुनिश्चित करता है कि यह उत्पादन मोड में काम करेगा यदि आपको यही चाहिए ...

यदि आपको आगे प्रारूपण की आवश्यकता है, तो आप देखेंगे कि वे एक स्टाइल टैग में कुछ सीएसएस शामिल करते हैं, इसलिए बस इसे "चोरी" करें ^ ^:

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

आशा है, यह मदद मिलेगी ;-)

Answer 14

मैंने एक साधारण लकड़हारा लिखा, जो सम्मिलित मापदंडों के साथ क्वेरी लॉग कर सकता है। स्थापना:

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

उपयोग:

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

Answer 15

$sql = $query->getSQL();

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

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

Comments

आपको अपने उत्तर में कुछ पाठ जोड़ना चाहिए जो यह बताता हो कि कोड क्या करता है।

— DarkMukke

Answer 16

जब पैरामीटर इस '2019-01-01' जैसे तारीख के तार हैं और जब वहाँ सरणी का उपयोग कर पारित किया जाता है तो संशोधित @dsamblas काम करता है

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

। इसलिए dsamblas ने जो कुछ भी लिखा है, वह सब करें, लेकिन startQuery को इस एक के साथ बदलें या अंतर देखें और मेरा कोड जोड़ें। (यदि वह अपने कार्य में कुछ संशोधित करता है और मेरे संस्करण में संशोधन नहीं है)।

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

ज्यादा टेस्ट नहीं किया।

Answer 17

मैंने इस विषय के लिए कुछ शोध किया, क्योंकि मैं एक उत्पन्न SQL क्वेरी को डीबग करना चाहता था और इसे sql संपादक में निष्पादित करना चाहता था। जैसा कि सभी उत्तरों में देखा गया है, यह एक उच्च तकनीकी विषय है।

जब मुझे लगता है कि प्रारंभिक प्रश्न देव-एनवी पर आधारित है, तो इस समय एक बहुत ही सरल उत्तर गायब है। आप सिम्फनी प्रोफाइलर में बिल्ड का उपयोग कर सकते हैं। बस डॉक्ट्रिन टैब पर क्लिक करें, उस क्वेरी पर स्क्रॉल करें जिसे आप निरीक्षण करना चाहते हैं। फिर "रन करने योग्य क्वेरी देखें" पर क्लिक करें और आप अपने क्वेरी को सीधे अपने SQL संपादक में पेस्ट कर सकते हैं

अधिक यूआई आधार दृष्टिकोण लेकिन बहुत जल्दी और बिना डीबगिंग कोड ओवरहेड।

Answer 18

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

Answer 19

Doctrine में SQL क्वेरी प्रिंट करने के लिए, उपयोग करें:

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

Comments

अपने उत्तर के साथ विवरण जोड़ना न भूलें? विवरण के बिना सिर्फ एक लाइनर, स्वीकार्य नहीं।

— हैवनडिसप्लेनेम

Doctrine में sql क्वेरी प्रिंट करने के लिए $ क्वेरी का उपयोग करें-> getResult () -> getSql (); धन्यवाद

— जयदीप पटेल

कॉमनेट जोड़ने के बजाय, अपना उत्तर संपादित करें

— HaveNoDisplayName