PHP Query::getParameters方法代碼示例

 /**
  * {@inheritdoc}
  */
 public function getSlice($offset, $length)
 {
     $query = clone $this->query;
     $query->setParameters($this->query->getParameters());
     $query->setFirstResult($offset)->setMaxResults($length);
     return $query->getQuery()->getResult();
 }

 /**
  * @param int $offset
  * @return \Porpaginas\Page
  */
 public function take($offset, $limit)
 {
     if ($this->result !== null) {
         return new ArrayPage(array_slice($this->result, $offset, $limit), $offset, $limit, count($this->result));
     }
     $query = clone $this->query;
     $query->setParameters($this->query->getParameters());
     foreach ($this->query->getHints() as $name => $value) {
         $query->setHint($name, $value);
     }
     $query->setFirstResult($offset)->setMaxResults($limit);
     return new ORMQueryPage(new Paginator($query, $this->fetchCollection));
 }

 /**
  * @SuppressWarnings(PHPMD.CyclomaticComplexity)
  * @SuppressWarnings(PHPMD.NPathComplexity)
  *
  * Copy of Doctrine\ORM\Query::processParameterMappings
  *
  * @param Query $query
  * @return array
  * @throws QueryException
  */
 public function processParameterMappings(Query $query)
 {
     $parser = new Parser($query);
     $parseResult = $parser->parse();
     $paramMappings = $parseResult->getParameterMappings();
     $resultSetMapping = $parseResult->getResultSetMapping();
     $paramCount = count($query->getParameters());
     $mappingCount = count($paramMappings);
     if ($paramCount > $mappingCount) {
         throw QueryException::tooManyParameters($mappingCount, $paramCount);
     } elseif ($paramCount < $mappingCount) {
         throw QueryException::tooFewParameters($mappingCount, $paramCount);
     }
     $sqlParams = [];
     $types = [];
     foreach ($query->getParameters() as $parameter) {
         $key = $parameter->getName();
         $value = $parameter->getValue();
         $rsm = $resultSetMapping;
         if (!isset($paramMappings[$key])) {
             throw QueryException::unknownParameter($key);
         }
         if (isset($rsm->metadataParameterMapping[$key]) && $value instanceof ClassMetadata) {
             $value = $value->getMetadataValue($rsm->metadataParameterMapping[$key]);
         }
         $value = $query->processParameterValue($value);
         $type = $parameter->getValue() === $value ? $parameter->getType() : Query\ParameterTypeInferer::inferType($value);
         foreach ($paramMappings[$key] as $position) {
             $types[$position] = $type;
         }
         $sqlPositions = $paramMappings[$key];
         // optimized multi value sql positions away for now,
         // they are not allowed in DQL anyways.
         $value = [$value];
         $countValue = count($value);
         for ($i = 0, $l = count($sqlPositions); $i < $l; $i++) {
             $sqlParams[$sqlPositions[$i]] = $value[$i % $countValue];
         }
     }
     if (count($sqlParams) !== count($types)) {
         throw QueryException::parameterTypeMismatch();
     }
     if ($sqlParams) {
         ksort($sqlParams);
         $sqlParams = array_values($sqlParams);
         ksort($types);
         $types = array_values($types);
     }
     return [$sqlParams, $types];
 }

 /**
  * @param Query                              $query
  * @param array                              $paramMappings
  * @return array
  * @throws \Doctrine\ORM\Query\QueryException
  */
 protected function processParameterMappings(Query $query, $paramMappings)
 {
     $sqlParams = array();
     $types = array();
     /** @var Parameter $parameter */
     foreach ($query->getParameters() as $parameter) {
         $key = $parameter->getName();
         if (!isset($paramMappings[$key])) {
             throw QueryException::unknownParameter($key);
         }
         $value = $query->processParameterValue($parameter->getValue());
         $type = $parameter->getValue() === $value ? $parameter->getType() : Query\ParameterTypeInferer::inferType($value);
         foreach ($paramMappings[$key] as $position) {
             $types[$position] = $type;
         }
         $sqlPositions = $paramMappings[$key];
         $value = array($value);
         $countValue = count($value);
         for ($i = 0, $l = count($sqlPositions); $i < $l; $i++) {
             $sqlParams[$sqlPositions[$i]] = $value[$i % $countValue];
         }
     }
     if (count($sqlParams) != count($types)) {
         throw QueryException::parameterTypeMissmatch();
     }
     if ($sqlParams) {
         ksort($sqlParams);
         $sqlParams = array_values($sqlParams);
         ksort($types);
         $types = array_values($types);
     }
     return array($sqlParams, $types);
 }

 /**
  * @param  Query $query
  * @return Query
  */
 protected static function cloneQuery(Query $query)
 {
     /* @var $countQuery Query */
     $countQuery = clone $query;
     $params = $query->getParameters();
     $countQuery->setParameters($params);
     return $countQuery;
 }

 /**
  * @param Query $query
  * @return Query
  */
 protected static function cloneQuery(Query $query)
 {
     /* @var $countQuery Query */
     $countQuery = clone $query;
     $params = $query->getParameters();
     foreach ($params as $key => $param) {
         $countQuery->setParameter($key, $param);
     }
     return $countQuery;
 }

 /**
  * Clones a query.
  *
  * @param Query $query The query.
  *
  * @return Query The cloned query.
  */
 private function cloneQuery(Query $query)
 {
     /* @var $cloneQuery Query */
     $cloneQuery = clone $query;
     $cloneQuery->setParameters(clone $query->getParameters());
     foreach ($query->getHints() as $name => $value) {
         $cloneQuery->setHint($name, $value);
     }
     return $cloneQuery;
 }

 /**
  * Clone specified query with parameters.
  *
  * @param Query $query
  *
  * @return Query
  */
 protected function cloneQuery(Query $query)
 {
     $aclAppliedQuery = clone $query;
     $params = $query->getParameters();
     /* @var $param Parameter */
     foreach ($params as $param) {
         $aclAppliedQuery->setParameter($param->getName(), $param->getValue(), $param->getType());
     }
     return $aclAppliedQuery;
 }

 /**
  * Clones the given $query and copies all used
  * parameters and hints
  *
  * @param Query $query
  * @return Query
  */
 public static function cloneQuery(Query $query)
 {
     $clonedQuery = clone $query;
     $clonedQuery->setParameters($query->getParameters());
     // attach hints
     foreach ($query->getHints() as $name => $hint) {
         $clonedQuery->setHint($name, $hint);
     }
     return $clonedQuery;
 }

 /**
  * @param \Doctrine\ORM\Query $query          The Doctrine Query
  * @param array               $fields         Fields to export
  * @param string              $dateTimeFormat
  */
 public function __construct(Query $query, array $fields, $dateTimeFormat = 'r')
 {
     $this->query = clone $query;
     $this->query->setParameters($query->getParameters());
     foreach ($query->getHints() as $name => $value) {
         $this->query->setHint($name, $value);
     }
     $this->propertyAccessor = PropertyAccess::createPropertyAccessor();
     $this->propertyPaths = array();
     foreach ($fields as $name => $field) {
         if (is_string($name) && is_string($field)) {
             $this->propertyPaths[$name] = new PropertyPath($field);
         } else {
             $this->propertyPaths[$field] = new PropertyPath($field);
         }
     }
     $this->dateTimeFormat = $dateTimeFormat;
 }

 /**
  * @param Query $query
  * @param array $ids
  * @param string $namespace
  * @return Query
  */
 public static function createWhereInQuery(Query $query, array $ids, $namespace = 'pgid')
 {
     // don't do this for an empty id array
     if (count($ids) > 0) {
         $whereInQuery = clone $query;
         $whereInQuery->setParameters($query->getParameters());
         $whereInQuery->setHint(Query::HINT_CUSTOM_TREE_WALKERS, array('DoctrineExtensions\\Paginate\\WhereInWalker'));
         $whereInQuery->setHint('id.count', count($ids));
         $whereInQuery->setHint('pg.ns', $namespace);
         $whereInQuery->setFirstResult(null)->setMaxResults(null);
         foreach ($ids as $i => $id) {
             $i = $i + 1;
             $whereInQuery->setParameter("{$namespace}_{$i}", $id);
         }
         return $whereInQuery;
     } else {
         return $query;
     }
 }

 /**
  * @param \Doctrine\ORM\Query $query          The Doctrine Query
  * @param array               $fields         Fields to export
  * @param string              $dateTimeFormat
  */
 public function __construct(Query $query, array $fields, $dateTimeFormat = 'r')
 {
     $this->query = clone $query;
     $this->query->setParameters($query->getParameters());
     foreach ($query->getHints() as $name => $value) {
         $this->query->setHint($name, $value);
     }
     // Note : will be deprecated in Symfony 3.0, conserved for 2.2 compatibility
     // Use createPropertyAccessor() for 3.0
     // @see Symfony\Component\PropertyAccess\PropertyAccess
     $this->propertyAccessor = PropertyAccess::getPropertyAccessor();
     $this->propertyPaths = array();
     foreach ($fields as $name => $field) {
         if (is_string($name) && is_string($field)) {
             $this->propertyPaths[$name] = new PropertyPath($field);
         } else {
             $this->propertyPaths[$field] = new PropertyPath($field);
         }
     }
     $this->dateTimeFormat = $dateTimeFormat;
 }

 /**
  * Clones a query.
  *
  * @param Query $query The query.
  *
  * @return Query The cloned query.
  */
 private function cloneQuery(Query $query)
 {
     /* @var $cloneQuery Query */
     $cloneQuery = clone $query;
     $cloneQuery->setParameters($query->getParameters());
     return $cloneQuery;
 }

 protected function getHash(Query $query) : string
 {
     $sql = $query->getSQL();
     $params = $query->getParameters();
     return sha1($sql . serialize($params));
 }

 /**
  * Makes full clone of the given query, including its parameters and hints
  *
  * @param Query $query
  * @return Query
  */
 protected function cloneQuery(Query $query)
 {
     $result = clone $query;
     // clone parameters
     $result->setParameters(clone $query->getParameters());
     // clone hints
     foreach ($query->getHints() as $name => $value) {
         $result->setHint($name, $value);
     }
     return $result;
 }