/** * {@inheritdoc} */ public function rewind() { if (!$this->iterableResult) { $this->iterableResult = $this->query->iterate(array(), Query::HYDRATE_ARRAY); } $this->iterableResult->rewind(); }
/** * {@inheritdoc} */ public function getSlice($offset, $length) { $query = clone $this->query; $query->setParameters($this->query->getParameters()); $query->setFirstResult($offset)->setMaxResults($length); return $query->getQuery()->getResult(); }
/** * 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); }
/** * Adds a hint to a query object * * @param Query $query * @param string $name * @param mixed $value * * @return bool TRUE if the hint is added; otherwise, FALSE */ public function addHint(Query $query, $name, $value) { $result = false; if ($name === Query::HINT_CUSTOM_TREE_WALKERS) { $walkers = $query->getHint(Query::HINT_CUSTOM_TREE_WALKERS); if (false === $walkers) { $walkers = [$value]; $query->setHint(Query::HINT_CUSTOM_TREE_WALKERS, $walkers); $result = true; } elseif (!in_array($value, $walkers, true)) { $walkers[] = $value; $query->setHint(Query::HINT_CUSTOM_TREE_WALKERS, $walkers); $result = true; } } elseif ($name === Query::HINT_CUSTOM_OUTPUT_WALKER) { if ($query->getHint($name) !== $value) { $query->setHint($name, $value); $result = true; } } else { $query->setHint($name, $value); $result = true; } return $result; }
/** * Apply ACL filter * * @param QueryBuilder | Query $query * @param array $permissions * @param string | UserInterface $identity * @param string $alias * @param array|Query|QueryBuilder $extraCriteria * * @return Query */ public function apply($query, array $permissions = array('VIEW'), $identity = null, $alias = null, $extraCriteria = false) { if (null === $identity) { $token = $this->securityContext->getToken(); $identity = $token->getUser(); } $query->setHint(static::HINT_ACL_EXTRA_CRITERIA, $this->getExtraCriteria($extraCriteria)); if ($query instanceof QueryBuilder) { $query = $this->cloneQuery($query->getQuery()); } elseif ($query instanceof Query) { $query = $this->cloneQuery($query); } else { throw new \Exception(); } $maskBuilder = new MaskBuilder(); foreach ($permissions as $permission) { $mask = constant(get_class($maskBuilder) . '::MASK_' . strtoupper($permission)); $maskBuilder->add($mask); } $entity = $this->getEntityFromAlias($query, $alias); $metadata = $entity['metadata']; $alias = $entity['alias']; $table = $metadata->getQuotedTableName($this->em->getConnection()->getDatabasePlatform()); $aclQuery = $this->getExtraQuery($this->getClasses($metadata), $this->getIdentifiers($identity), $maskBuilder->get()); $hintAclMetadata = false !== $query->getHint('acl.metadata') ? $query->getHint('acl.metadata') : array(); $hintAclMetadata[] = array('query' => $aclQuery, 'table' => $table, 'alias' => $alias); $query->setHint('acl.metadata', $hintAclMetadata); $query->setHint(Query::HINT_CUSTOM_OUTPUT_WALKER, $this->aclWalker); return $query; }
/** * @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); }
/** * {@inheritDoc} * * @api */ public function getItemCount() { try { return array_sum(array_map('current', $this->countQuery->getScalarResult())); } catch (NoResultException $e) { return 0; } }
/** * @param Query $query */ protected function applyTranslatorGedmoHints(Query &$query) { if (BELCEBUR_GEDMO_TRANSLATION_LOCALE !== 'BELCEBUR_GEDMO_TRANSLATION_LOCALE') { $query->setHint(Query::HINT_CUSTOM_OUTPUT_WALKER, $this->gedmoWalker); $query->setHint(TranslatableListener::HINT_TRANSLATABLE_LOCALE, BELCEBUR_GEDMO_TRANSLATION_LOCALE); $query->setHint(TranslatableListener::HINT_FALLBACK, TRUE); } }
public function __construct(DoctrineOrmPaginator $paginator) { $this->paginator = $paginator; $this->query = $paginator->getQuery(); $this->firstResult = $this->query->getFirstResult(); $this->maxResults = $this->query->getMaxResults(); $this->totalItems = count($paginator); }
/** * @param Query $query * * @return array */ protected function processMostSearchedQuery(Query $query) { $resultQuery = $query->getArrayResult(); $result = []; foreach ($resultQuery as $answerArray) { $result[] = ['title' => $answerArray['title'], 'description' => $answerArray['description'], 'uri' => $this->routerInterface->generate('aalto_api_answer_show', ['slug' => $answerArray['slug']])]; } return $result; }
/** * @param Query $query * @param string $locale * @throws \Exception */ protected function setTranslatableQueryHints(Query $query, $locale) { if (!class_exists('Gedmo\\Translatable\\TranslatableListener')) { throw new \Exception('"Translatable" extension missing. "stof/doctrine-extensions-bundle" needs to be installed'); } $query->setHint(\Doctrine\ORM\Query::HINT_CUSTOM_OUTPUT_WALKER, 'Gedmo\\Translatable\\Query\\TreeWalker\\TranslationWalker'); $query->setHint(\Gedmo\Translatable\TranslatableListener::HINT_TRANSLATABLE_LOCALE, $locale); $query->setHint(\Gedmo\Translatable\TranslatableListener::HINT_FALLBACK, 1); }
/** * Add a custom TreeWalker $walker class name to * be included in the CustomTreeWalker hint list * of the given $query * * @param Query $query * @param string $walker * @return void */ public static function addCustomTreeWalker(Query $query, $walker) { $customTreeWalkers = $query->getHint(Query::HINT_CUSTOM_TREE_WALKERS); if ($customTreeWalkers !== false && is_array($customTreeWalkers)) { $customTreeWalkers = array_merge($customTreeWalkers, array($walker)); } else { $customTreeWalkers = array($walker); } $query->setHint(Query::HINT_CUSTOM_TREE_WALKERS, $customTreeWalkers); }
/** * Clones a query * @param Query $query the query to be cloned * @return \Query the new query */ private function cloneQuery($query) { /* @var $cloneQuery Query */ $cloneQuery = clone $query; $cloneQuery->setParameters(clone $query->getParameters()); foreach ($query->getHints() as $name => $value) { $cloneQuery->setHint($name, $value); } return $cloneQuery; }
/** * @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; }
/** * @param int $maxPerPage */ public function setMaxPerPage($maxPerPage) { if ($maxPerPage > 0) { $this->maxPerPage = $maxPerPage; $this->query->setMaxResults($maxPerPage); } else { $this->maxPerPage = 0; $this->query->setMaxResults(Query::INFINITY); } $this->calculateFirstResult(); }
private function getSingleResult(Query $query) { try { $result = $query->getSingleResult(); } catch (NonUniqueResultException $e) { $result = null; } catch (NoResultException $e) { $result = null; } return $result; }
/** * @inheritdoc */ public function normalize(Query $query, QueryBuilder $queryBuilder, $hydratorClass = null) { /* * Add custom hydrator */ $emConfig = $queryBuilder->getEntityManager()->getConfiguration(); $hydrator = new \ReflectionClass($hydratorClass); $hydratorName = $hydrator->getShortName(); $emConfig->addCustomHydrationMode($hydratorName, $hydratorClass); return $query->getResult($hydratorName); }
public function close() { if ($this->clearEntitiesOnBatch) { $em = $this->query->getEntityManager(); foreach ($this->clearEntitiesOnBatch as $e) { $em->clear($e); } } $this->query = null; $this->results = null; }
/** * @param \Kdyby\Persistence\Queryable $repository * * @throws UnexpectedValueException * @return \Doctrine\ORM\Query */ protected function getQuery(Queryable $repository) { $query = $this->toQuery($this->doCreateQuery($repository)); if ($this->lastQuery && $this->lastQuery->getDQL() === $query->getDQL()) { $query = $this->lastQuery; } if ($this->lastQuery !== $query) { $this->lastResult = new ResultSet($query, $this, $repository); } return $this->lastQuery = $query; }
/** * Sets the total row count for this paginator * * Can be either an integer, or a Doctrine\ORM\Query object * which returns the count * * @param Query|integer $rowCount * @return void */ public function setRowCount($rowCount) { if ($rowCount instanceof Query) { $this->rowCount = $rowCount->getSingleScalarResult(); } else { if (is_integer($rowCount)) { $this->rowCount = $rowCount; } else { throw new \InvalidArgumentException("Invalid row count"); } } }
public function paginate($page, Query $query, $itemsPerPage = 10) { if (!is_numeric($page)) { throw new \Exception('Valor no numerico para la paginacion'); } $this->currentPage = (int) $page; $this->itemsPerPage = $itemsPerPage; $this->calLastPage(count($query->getResult())); $this->calRange(); $query->setFirstResult($this->offset())->setMaxResults($this->itemsPerPage); return $query->getResult(); }
/** * @dataProvider functionsDataProvider * @param array $functions * @param string $dql * @param string $sql * @param string $expectedResult */ public function testDqlFunction(array $functions, $dql, $sql, $expectedResult) { $configuration = $this->entityManager->getConfiguration(); foreach ($functions as $function) { $this->registerDqlFunction($function['type'], $function['name'], $function['className'], $configuration); } $query = new Query($this->entityManager); $query->setDQL($dql); $this->assertEquals($sql, $query->getSQL(), sprintf('Unexpected SQL for "%s"', $dql)); $result = $query->getArrayResult(); $this->assertNotEmpty($result); $this->assertEquals($expectedResult, array_values(array_shift($result)), sprintf('Unexpected result for "%s"', $dql)); }
/** * 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); $this->em = $query->getEntityManager(); $this->quoteStrategy = $this->em->getConfiguration()->getQuoteStrategy(); parent::__construct($query, $parserResult, $queryComponents); }
/** * @param string $dql * @param string $expectedCountQuery * @param array $sqlParameters * @param array $types * @param array $queryParameters * * @dataProvider getCountDataProvider */ public function testCalculateCount($dql, $expectedCountQuery, array $sqlParameters = [], array $types = [], array $queryParameters = []) { /** @var $entityManager EntityManager|\PHPUnit_Framework_MockObject_MockObject */ /** @var $connection Connection|\PHPUnit_Framework_MockObject_MockObject */ /** @var $statement Statement|\PHPUnit_Framework_MockObject_MockObject */ list($entityManager, $connection, $statement) = $this->prepareMocks(); $query = new Query($entityManager); $query->setDQL($dql); $query->setParameters($queryParameters); $connection->expects($this->once())->method('executeQuery')->with($expectedCountQuery, $sqlParameters, $types)->will($this->returnValue($statement)); $statement->expects($this->any())->method('fetch')->will($this->onConsecutiveCalls(['sclr_0' => self::TEST_COUNT], false)); $statement->expects($this->any())->method('fetchColumn')->will($this->returnValue(self::TEST_COUNT)); $this->assertEquals(self::TEST_COUNT, QueryCountCalculator::calculateCount($query)); }
/** * @param string $dql * @param array $sqlParameters * @param array $types * @param array $queryParameters * * @dataProvider getCountDataProvider */ public function testCalculateCount($dql, array $sqlParameters, array $types, array $queryParameters = array()) { /** @var $entityManager EntityManager|\PHPUnit_Framework_MockObject_MockObject */ /** @var $connection Connection|\PHPUnit_Framework_MockObject_MockObject */ /** @var $statement Statement|\PHPUnit_Framework_MockObject_MockObject */ list($entityManager, $connection, $statement) = $this->prepareMocks(); $query = new Query($entityManager); $query->setDQL($dql); $query->setParameters($queryParameters); $expectedSql = 'SELECT COUNT(*) FROM (' . $query->getSQL() . ') AS e'; $connection->expects($this->once())->method('executeQuery')->with($expectedSql, $sqlParameters, $types)->will($this->returnValue($statement)); $statement->expects($this->once())->method('fetchColumn')->with()->will($this->returnValue(self::TEST_COUNT)); $this->assertEquals(self::TEST_COUNT, QueryCountCalculator::calculateCount($query)); }
/** * @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]; }
/** * {@inheritdoc} */ public function apply($fromAlias, $fromIdentifier, $resourcePrefix, array $requesterIdentifiers, $mask, array $orX = []) { $this->query->setHint(Query::HINT_CUSTOM_OUTPUT_WALKER, 'AlexDpy\\Acl\\Database\\Filter\\DoctrineOrmAclWalker'); $this->query->setHint('acl_permissions_table_name', $this->getAclSchema()->getPermissionsTableName()); $this->query->setHint('acl_resource_prefix', $resourcePrefix); $this->query->setHint('acl_requester_identifiers', $requesterIdentifiers); $this->query->setHint('acl_mask', $mask); $this->query->setHint('acl_from_alias', $fromAlias); $this->query->setHint('acl_from_identifier', $fromIdentifier); $this->query->setHint('acl_or_x', $orX); return $this->query; }
/** * @param Query|QueryBuilder $query * @param int $page * @param int $limit * @param Closure $callback * * @return array */ public function getPaginatedResult($query, $page, $limit, $callback = null) { $query->setFirstResult(($page - 1) * $limit)->setMaxResults($limit); if ($query instanceof QueryBuilder) { $query = $query->getQuery(); } $items = $query->getResult(); if ($callback == null) { $callback = function ($item) { return ['id' => $item->getId(), 'text' => (string) $item]; }; } $data = array_map($callback, $items); $more = count($data) >= $limit; return ['items' => $data, 'itemsPerPage' => $limit, 'more' => $more]; }
/** * {@inheritdoc} */ public function getIterator() { $offset = $this->query->getFirstResult(); $length = $this->query->getMaxResults(); if ($this->fetchJoinCollection) { $subQuery = $this->cloneQuery($this->query); if ($this->useOutputWalker($subQuery)) { $subQuery->setHint(Query::HINT_CUSTOM_OUTPUT_WALKER, 'Doctrine\\ORM\\Tools\\Pagination\\LimitSubqueryOutputWalker'); } else { $this->appendTreeWalker($subQuery, 'Doctrine\\ORM\\Tools\\Pagination\\LimitSubqueryWalker'); } $subQuery->setFirstResult($offset)->setMaxResults($length); $ids = array_map('current', $subQuery->getScalarResult()); $whereInQuery = $this->cloneQuery($this->query); // don't do this for an empty id array if (count($ids) == 0) { return new \ArrayIterator(array()); } $this->appendTreeWalker($whereInQuery, 'Doctrine\\ORM\\Tools\\Pagination\\WhereInWalker'); $whereInQuery->setHint(WhereInWalker::HINT_PAGINATOR_ID_COUNT, count($ids)); $whereInQuery->setFirstResult(null)->setMaxResults(null); $whereInQuery->setParameter(WhereInWalker::PAGINATOR_ID_ALIAS, $ids); $whereInQuery->setCacheable($this->query->isCacheable()); $result = $whereInQuery->getResult($this->query->getHydrationMode()); } else { $result = $this->cloneQuery($this->query)->setMaxResults($length)->setFirstResult($offset)->setCacheable($this->query->isCacheable())->getResult($this->query->getHydrationMode()); } return new \ArrayIterator($result); }
/** * {@inheritdoc} */ public function rewind() { if ($this->iterator) { throw new InvalidMethodCallException('Cannot rewind a Doctrine\\ORM\\Query'); } $this->iterator = $this->query->iterate(); $this->iterator->rewind(); }