/**
  * Constructor.
  *
  * Stores various parameters that are otherwise unavailable
  * because Doctrine\ORM\Query\SqlWalker keeps everything private without
  * accessors.
  *
  * @param \Doctrine\ORM\Query              $query
  * @param \Doctrine\ORM\Query\ParserResult $parserResult
  * @param array                            $queryComponents
  */
 public function __construct($query, $parserResult, array $queryComponents)
 {
     $this->platform = $query->getEntityManager()->getConnection()->getDatabasePlatform();
     $this->rsm = $parserResult->getResultSetMapping();
     $this->queryComponents = $queryComponents;
     parent::__construct($query, $parserResult, $queryComponents);
 }

 /**
  * Initializes a new SqlWalker instance with the given Query and ParserResult.
  *
  * @param Query $query The parsed Query.
  * @param ParserResult $parserResult The result of the parsing process.
  */
 public function __construct($query, $parserResult, array $queryComponents)
 {
     $this->_resultSetMapping = $parserResult->getResultSetMapping();
     $this->_query = $query;
     $this->_em = $query->getEntityManager();
     $this->_parserResult = $parserResult;
     $this->_queryComponents = $queryComponents;
 }

 /** Helper method */
 protected function _createParserResult($resultSetMapping, $isMixedQuery = false)
 {
     $parserResult = new ParserResult();
     $parserResult->setResultSetMapping($resultSetMapping);
     //$parserResult->setDefaultQueryComponentAlias(key($queryComponents));
     //$parserResult->setTableAliasMap($tableToClassAliasMap);
     $parserResult->setMixedQuery($isMixedQuery);
     return $parserResult;
 }

 /**
  * Constructor.
  *
  * Stores various parameters that are otherwise unavailable
  * because Doctrine\ORM\Query\SqlWalker keeps everything private without
  * accessors.
  *
  * @param \Doctrine\ORM\Query              $query
  * @param \Doctrine\ORM\Query\ParserResult $parserResult
  * @param array                            $queryComponents
  */
 public function __construct($query, $parserResult, array $queryComponents)
 {
     $this->platform = $query->getEntityManager()->getConnection()->getDatabasePlatform();
     $this->rsm = $parserResult->getResultSetMapping();
     $this->queryComponents = $queryComponents;
     // Reset limit and offset
     $this->firstResult = $query->getFirstResult();
     $this->maxResults = $query->getMaxResults();
     $query->setFirstResult(null)->setMaxResults(null);
     parent::__construct($query, $parserResult, $queryComponents);
 }

 /**
  * Parses a query string.
  *
  * @return ParserResult
  */
 public function parse()
 {
     $AST = $this->getAST();
     if (($customWalkers = $this->_query->getHint(Query::HINT_CUSTOM_TREE_WALKERS)) !== false) {
         $this->_customTreeWalkers = $customWalkers;
     }
     if (($customOutputWalker = $this->_query->getHint(Query::HINT_CUSTOM_OUTPUT_WALKER)) !== false) {
         $this->_customOutputWalker = $customOutputWalker;
     }
     // Run any custom tree walkers over the AST
     if ($this->_customTreeWalkers) {
         $treeWalkerChain = new TreeWalkerChain($this->_query, $this->_parserResult, $this->_queryComponents);
         foreach ($this->_customTreeWalkers as $walker) {
             $treeWalkerChain->addTreeWalker($walker);
         }
         switch (true) {
             case $AST instanceof AST\UpdateStatement:
                 $treeWalkerChain->walkUpdateStatement($AST);
                 break;
             case $AST instanceof AST\DeleteStatement:
                 $treeWalkerChain->walkDeleteStatement($AST);
                 break;
             case $AST instanceof AST\SelectStatement:
             default:
                 $treeWalkerChain->walkSelectStatement($AST);
         }
     }
     $outputWalkerClass = $this->_customOutputWalker ?: __NAMESPACE__ . '\\SqlWalker';
     $outputWalker = new $outputWalkerClass($this->_query, $this->_parserResult, $this->_queryComponents);
     // Assign an SQL executor to the parser result
     $this->_parserResult->setSqlExecutor($outputWalker->getExecutor($AST));
     return $this->_parserResult;
 }

 /**
  * Parses a query string.
  *
  * @return ParserResult
  */
 public function parse()
 {
     $AST = $this->getAST();
     $this->fixIdentificationVariableOrder($AST);
     $this->assertSelectEntityRootAliasRequirement();
     if (($customWalkers = $this->_query->getHint(Query::HINT_CUSTOM_TREE_WALKERS)) !== false) {
         $this->_customTreeWalkers = $customWalkers;
     }
     if (($customOutputWalker = $this->_query->getHint(Query::HINT_CUSTOM_OUTPUT_WALKER)) !== false) {
         $this->_customOutputWalker = $customOutputWalker;
     }
     // Run any custom tree walkers over the AST
     if ($this->_customTreeWalkers) {
         $treeWalkerChain = new TreeWalkerChain($this->_query, $this->_parserResult, $this->_queryComponents);
         foreach ($this->_customTreeWalkers as $walker) {
             $treeWalkerChain->addTreeWalker($walker);
         }
         if ($AST instanceof AST\SelectStatement) {
             $treeWalkerChain->walkSelectStatement($AST);
         } else {
             if ($AST instanceof AST\UpdateStatement) {
                 $treeWalkerChain->walkUpdateStatement($AST);
             } else {
                 $treeWalkerChain->walkDeleteStatement($AST);
             }
         }
     }
     if ($this->_customOutputWalker) {
         $outputWalker = new $this->_customOutputWalker($this->_query, $this->_parserResult, $this->_queryComponents);
     } else {
         $outputWalker = new SqlWalker($this->_query, $this->_parserResult, $this->_queryComponents);
     }
     // Assign an SQL executor to the parser result
     $this->_parserResult->setSqlExecutor($outputWalker->getExecutor($AST));
     return $this->_parserResult;
 }

 /**
  * {@inheritdoc}
  */
 public function walkInputParameter($inputParam)
 {
     $this->parserResult->addParameterMapping($inputParam->name, $this->sqlParamIndex++);
     $parameter = $this->query->getParameter($inputParam->name);
     if ($parameter && Type::hasType($type = $parameter->getType())) {
         return Type::getType($type)->convertToDatabaseValueSQL('?', $this->platform);
     }
     return '?';
 }

 /**
  * {@inheritdoc}
  */
 protected function _doExecute()
 {
     $executor = $this->_parse()->getSqlExecutor();
     if ($this->_queryCacheProfile) {
         $executor->setQueryCacheProfile($this->_queryCacheProfile);
     }
     if ($this->_resultSetMapping === null) {
         $this->_resultSetMapping = $this->_parserResult->getResultSetMapping();
     }
     // Prepare parameters
     $paramMappings = $this->_parserResult->getParameterMappings();
     if (count($paramMappings) != count($this->parameters)) {
         throw QueryException::invalidParameterNumber();
     }
     list($sqlParams, $types) = $this->processParameterMappings($paramMappings);
     return $executor->execute($this->_em->getConnection(), $sqlParams, $types);
 }

 /**
  * {@inheritdoc}
  */
 public function walkInputParameter($inputParam)
 {
     $this->parserResult->addParameterMapping($inputParam->name, $this->sqlParamIndex++);
     return '?';
 }

 /**
  * {@inheritdoc}
  */
 protected function _doExecute()
 {
     $executor = $this->_parse()->getSqlExecutor();
     if ($this->_queryCacheProfile) {
         $executor->setQueryCacheProfile($this->_queryCacheProfile);
     }
     if ($this->_resultSetMapping === null) {
         $this->_resultSetMapping = $this->_parserResult->getResultSetMapping();
     }
     // Prepare parameters
     $paramMappings = $this->_parserResult->getParameterMappings();
     if (count($paramMappings) != count($this->parameters)) {
         throw QueryException::invalidParameterNumber();
     }
     // evict all cache for the entity region
     if ($this->hasCache && isset($this->_hints[self::HINT_CACHE_EVICT]) && $this->_hints[self::HINT_CACHE_EVICT]) {
         $this->evictEntityCacheRegion();
     }
     list($sqlParams, $types) = $this->processParameterMappings($paramMappings);
     return $executor->execute($this->_em->getConnection(), $sqlParams, $types);
 }