/**
* Determines whether the query builder has ORDER BY on entity joined through
* to-many association.
*
* @param QueryBuilder $queryBuilder
* @param ManagerRegistry $managerRegistry
*
* @return bool
*/
public static function hasOrderByOnToManyJoin(QueryBuilder $queryBuilder, ManagerRegistry $managerRegistry)
{
if (empty($orderByParts = $queryBuilder->getDQLPart('orderBy')) || empty($joinParts = $queryBuilder->getDQLPart('join'))) {
return false;
}
$orderByAliases = [];
foreach ($orderByParts as $orderBy) {
$parts = QueryNameGenerator::getOrderByParts($orderBy);
foreach ($parts as $part) {
if (false !== ($pos = strpos($part, '.'))) {
$alias = substr($part, 0, $pos);
$orderByAliases[$alias] = true;
}
}
}
if (!empty($orderByAliases)) {
foreach ($joinParts as $rootAlias => $joins) {
foreach ($joins as $join) {
$alias = QueryNameGenerator::getJoinAlias($join);
if (isset($orderByAliases[$alias])) {
$relationship = QueryNameGenerator::getJoinRelationship($join);
$relationshipParts = explode('.', $relationship);
$parentAlias = $relationshipParts[0];
$association = $relationshipParts[1];
$parentMetadata = QueryNameGenerator::getClassMetadataFromJoinAlias($parentAlias, $queryBuilder, $managerRegistry);
if ($parentMetadata->isCollectionValuedAssociation($association)) {
return true;
}
}
}
}
}
return false;
}
/**
* Get the query result
*
* @param integer $limit
*
* @return ArrayCollection
*/
public function getQueryResults($limit = null)
{
if (isset($limit)) {
$this->queryBuilder->setMaxResults($limit);
}
if (!$this->queryBuilder->getDQLPart('orderBy')) {
$this->queryBuilder->orderBy('a.createdAt', 'ASC');
}
return $this->queryBuilder->getQuery()->getResult();
}
public function testCreateDataSet_conflictingFilters()
{
$request = $this->getBaseRequest();
$this->qb->andWhere('p.id = ?0')->setParameter(0, 'Test');
$request->columnFilters[0] = 'test';
$dataSet = $this->dataSource->createDataSet($request);
$where = $this->qb->getDQLPart('where')->getParts();
$this->assertCount(2, $where);
$this->assertCount(2, $this->qb->getParameters());
}
/**
* {@inheritDoc}
*/
public function hasJoinAlias($joinAlias)
{
$joinParts = $this->queryBuilder->getDQLPart('join');
/* @var \Doctrine\ORM\Query\Expr\Join $join */
foreach ($joinParts as $rootAlias => $joins) {
foreach ($joins as $join) {
if ($join->getAlias() === $joinAlias) {
return true;
}
}
}
return false;
}
/**
* @param QueryBuilder $qb
* @param array $value
*/
protected function addJoin(QueryBuilder $qb, $value)
{
/** @var Expr\From[] $from */
$from = $qb->getDQLPart('from');
if ($from) {
$usedAliases = [$from[0]->getAlias()];
} else {
$usedAliases = ['t1'];
}
$knownAliases = [$usedAliases[0]];
if (isset($value['join']['inner'])) {
foreach ($value['join']['inner'] as $join) {
$knownAliases[] = $join['alias'];
}
}
if (isset($value['join']['left'])) {
foreach ($value['join']['left'] as $join) {
$knownAliases[] = $join['alias'];
}
}
$knownAliases = array_unique($knownAliases);
$qbTools = new QueryBuilderTools();
// Add joins ordered by used tables
$tries = 0;
do {
$this->addJoinByDefinition($qb, $qbTools, $value, 'inner', $usedAliases, $knownAliases);
$this->addJoinByDefinition($qb, $qbTools, $value, 'left', $usedAliases, $knownAliases);
if ($tries > self::MAX_ITERATIONS) {
throw new \RuntimeException('Could not reorder joins correctly. Number of tries has exceeded maximum allowed.');
}
$tries++;
} while (count($usedAliases) != count($knownAliases));
}
/**
* {@inheritdoc}
*/
public function entityJoin(array $associationMappings)
{
$alias = $this->queryBuilder->getRootAlias();
$newAlias = 's';
$joinedEntities = $this->queryBuilder->getDQLPart('join');
foreach ($associationMappings as $associationMapping) {
// Do not add left join to already joined entities with custom query
foreach ($joinedEntities as $joinExprList) {
foreach ($joinExprList as $joinExpr) {
$newAliasTmp = $joinExpr->getAlias();
if (sprintf('%s.%s', $alias, $associationMapping['fieldName']) === $joinExpr->getJoin()) {
$this->entityJoinAliases[] = $newAliasTmp;
$alias = $newAliasTmp;
continue 3;
}
}
}
$newAlias .= '_' . $associationMapping['fieldName'];
if (!in_array($newAlias, $this->entityJoinAliases)) {
$this->entityJoinAliases[] = $newAlias;
$this->queryBuilder->leftJoin(sprintf('%s.%s', $alias, $associationMapping['fieldName']), $newAlias);
}
$alias = $newAlias;
}
return $alias;
}
/**
* Apply the ACL constraints to the specified query builder, using the permission definition
*
* @param QueryBuilder $queryBuilder The query builder
* @param PermissionDefinition $permissionDef The permission definition
*
* @return Query
*/
public function apply(QueryBuilder $queryBuilder, PermissionDefinition $permissionDef)
{
$whereQueryParts = $queryBuilder->getDQLPart('where');
if (empty($whereQueryParts)) {
$queryBuilder->where('1 = 1');
// this will help in cases where no where query is specified
}
$query = $this->cloneQuery($queryBuilder->getQuery());
$builder = new MaskBuilder();
foreach ($permissionDef->getPermissions() as $permission) {
$mask = constant(get_class($builder) . '::MASK_' . strtoupper($permission));
$builder->add($mask);
}
$query->setHint('acl.mask', $builder->get());
$query->setHint(Query::HINT_CUSTOM_OUTPUT_WALKER, 'Kunstmaan\\AdminBundle\\Helper\\Security\\Acl\\AclWalker');
$rootEntity = $permissionDef->getEntity();
$rootAlias = $permissionDef->getAlias();
// If either alias or entity was not specified - use default from QueryBuilder
if (empty($rootEntity) || empty($rootAlias)) {
$rootEntities = $queryBuilder->getRootEntities();
$rootAliases = $queryBuilder->getRootAliases();
$rootEntity = $rootEntities[0];
$rootAlias = $rootAliases[0];
}
$query->setHint('acl.root.entity', $rootEntity);
$query->setHint('acl.extra.query', $this->getPermittedAclIdsSQLForUser($query));
$classMeta = $this->em->getClassMetadata($rootEntity);
$entityRootTableName = $this->quoteStrategy->getTableName($classMeta, $this->em->getConnection()->getDatabasePlatform());
$query->setHint('acl.entityRootTableName', $entityRootTableName);
$query->setHint('acl.entityRootTableDqlAlias', $rootAlias);
return $query;
}
/**
* @param QueryBuilder $qb
* @return string
*/
protected function getRootTableAlias(QueryBuilder $qb)
{
$fromParts = $qb->getDQLPart('from');
/** @var From $from */
$from = reset($fromParts);
return $from->getAlias();
}
/**
* Returns the sql expression to determinate the distincts numbers of lines
*
* @return string
*/
protected function getDistinct()
{
if (isset($this->conf->group)) {
return $this->conf->group;
}
return implode(', ', $this->queryBuilder->getDQLPart('select'));
}
public function createPropertyPathMapping(QueryBuilder $qb, array $fieldMapping, array $existingMapping = [])
{
if (count($qb->getRootAliases()) > 1) {
throw new \UnexpectedValueException("Expected 1 root alias");
}
$rootAlias = $qb->getRootAliases()[0];
$aliasMapping = [$rootAlias => ''];
foreach ($qb->getDQLPart('join') as $joinFrom => $joins) {
foreach ($joins as $join) {
$joinParts = explode(".", $join->getJoin());
$aliasMapping[$join->getAlias()] = trim($aliasMapping[$joinParts[0]] . '.' . $joinParts[1], '.');
}
}
$mapping = [];
foreach ($fieldMapping as $key => $field) {
if (array_key_exists($key, $existingMapping)) {
$mapping[$key] = $existingMapping[$key];
continue;
}
$fieldParts = explode('.', $field);
if (isset($fieldParts[1])) {
$alias = $fieldParts[0];
$mapping[$key] = trim($aliasMapping[$fieldParts[0]] . '.' . $fieldParts[1], '.');
} else {
$mapping[$key] = trim($fieldParts[0]);
}
}
return $mapping;
}
/**
* Get root entities config data
*
* @param QueryBuilder $query
* @return array with root entities config
*/
protected function getRootIds(QueryBuilder $query)
{
$groupParts = $this->getGroupParts();
$rootIds = [];
if (empty($groupParts)) {
$rootIdentifiers = $query->getEntityManager()->getClassMetadata($query->getRootEntities()[0])->getIdentifier();
$rootAlias = $query->getRootAliases()[0];
foreach ($rootIdentifiers as $field) {
$rootIds[] = ['fieldAlias' => $field, 'alias' => $field, 'entityAlias' => $rootAlias];
}
} else {
foreach ($groupParts as $groupPart) {
if (strpos($groupPart, '.')) {
list($rootAlias, $rootIdentifierPart) = explode('.', $groupPart);
$rootIds[] = ['fieldAlias' => $rootIdentifierPart, 'entityAlias' => $rootAlias, 'alias' => $rootIdentifierPart];
} else {
$selectParts = $this->masterQB->getDQLPart('select');
/** @var Select $selectPart */
foreach ($selectParts as $selectPart) {
foreach ($selectPart->getParts() as $part) {
if (preg_match('/^(.*)\\sas\\s(.*)$/i', $part, $matches)) {
if (count($matches) == 3 && $groupPart == $matches[2]) {
$rootIds[] = ['fieldAlias' => $matches[1], 'alias' => $matches[2]];
}
} else {
$rootIds[] = ['fieldAlias' => $groupPart, 'alias' => $groupPart];
}
}
}
}
}
}
return $rootIds;
}
private function getAlias(QueryBuilder $builder)
{
$dql_part = $builder->getDQLPart('from');
if (!is_array($dql_part) || count($dql_part) !== 1 || !$dql_part[0] instanceof \Doctrine\ORM\Query\Expr\From) {
throw new \DomainException('The from should be an instance of from');
}
return $dql_part[0]->getAlias();
}
/**
* {@inheritdoc}
*/
public function addAttributeSorter(AbstractAttribute $attribute, $direction)
{
$aliasPrefix = 'sorter';
$joinAlias = $aliasPrefix . 'V' . $attribute->getCode() . $this->aliasCounter++;
$backendType = $attribute->getBackendType();
// join to value and sort on
$condition = $this->prepareAttributeJoinCondition($attribute, $joinAlias);
// Remove current join in order to put the orderBy related join
// at first place in the join queue for performances reasons
$joinsSet = $this->qb->getDQLPart('join');
$this->qb->resetDQLPart('join');
$this->qb->leftJoin($this->qb->getRootAlias() . '.values', $joinAlias, 'WITH', $condition);
$this->qb->addOrderBy($joinAlias . '.' . $backendType, $direction);
// Reapply previous join after the orderBy related join
$this->applyJoins($joinsSet);
return $this;
}
/**
* Initialize the column id of the targeted class.
*
* @return string
*/
protected function initIdFieldName()
{
/** @var $from \Doctrine\ORM\Query\Expr\From */
$from = current($this->originalQb->getDQLPart('from'));
$class = $from->getFrom();
$idNames = $this->originalQb->getEntityManager()->getMetadataFactory()->getMetadataFor($class)->getIdentifierFieldNames();
$this->idFieldName = current($idNames);
}
/**
*
* @param QueryBuilder $qb
* @param number $part
* @return \Doctrine\ORM\Query\Expr\Comparison[]
*/
private function getWhereParts(QueryBuilder $qb, $part = 0)
{
/* @var $where \Doctrine\ORM\Query\Expr\Andx */
$where = $qb->getDQLPart('where');
$whereParts = $where->getParts();
$this->assertInstanceOf('Doctrine\\ORM\\Query\\Expr\\Orx', $whereParts[$part]);
return $whereParts[$part]->getParts();
}
/**
* Will do JOIN only if there is no such join already.
* For any other more advanced join strategies please use unique aliases.
* Remember: for performance reasons you should keep number of joins as low as possible
* Example usage: $this->join($qb, 'p.house', 'h', Join::LEFT_JOIN).
*
* @param QueryBuilder $queryBuilder
* @param string $join
* @param string $alias
* @param string $joinType
*
* @return QueryBuilder
*/
protected function join(QueryBuilder $queryBuilder, $join, $alias, $joinType)
{
list($entity) = explode('.', $join);
$joinParts = $queryBuilder->getDQLPart('join');
if (!array_key_exists($entity, $joinParts)) {
return $queryBuilder->join($join, $alias);
}
return $this->filterExistingJoins($queryBuilder, $joinParts[$entity], $alias, $join, $joinType);
}
/**
* Determines if an include has already been processed
*
* @param QueryBuilder $qb
* @param string $include
* @return bool
*/
protected function includeExists(QueryBuilder $qb, $include)
{
foreach ($qb->getDQLPart('join') as $joins) {
foreach ($joins as $join) {
if ($join->getAlias() === $include) {
return true;
}
}
}
return false;
}
/**
* Builds an associative array of already joined tables and their alias.
*
* @return array
*/
private function analizeJoinedTables()
{
$joinMap = [];
$joins = $this->qb->getDQLPart('join');
foreach (array_keys($joins) as $fromTable) {
foreach ($joins[$fromTable] as $join) {
$joinMap[$join->getJoin()] = $join->getAlias();
}
}
return $joinMap;
}
/**
* @throws LogicException
*
* @return CursorableRepositoryInterface
*/
protected function getRepository()
{
if (null === $this->repository) {
$entityClass = current($this->queryBuilder->getDQLPart('from'))->getFrom();
$this->repository = $this->entityManager->getRepository($entityClass);
if (!$this->repository instanceof CursorableRepositoryInterface) {
throw new LogicException(sprintf('"%s" repository must implement ' . '"Akeneo\\Bundle\\StorageUtilsBundle\\Doctrine\\ORM\\Repository\\CursorableRepositoryInterface"', $entityClass));
}
}
return $this->repository;
}
/**
* {@inheritdoc}
*/
public function addAttributeSorter(AttributeInterface $attribute, $direction, $locale = null, $scope = null)
{
$aliasPrefix = 'sorter';
$joinAlias = $aliasPrefix . 'V' . $attribute->getCode();
$backendType = $attribute->getBackendType();
// join to value and sort on
$condition = $this->prepareAttributeJoinCondition($attribute, $joinAlias, $locale, $scope);
// Remove current join in order to put the orderBy related join
// at first place in the join queue for performances reasons
$joinsSet = $this->qb->getDQLPart('join');
$this->qb->resetDQLPart('join');
$this->qb->leftJoin($this->qb->getRootAlias() . '.values', $joinAlias, 'WITH', $condition);
$this->qb->addOrderBy($joinAlias . '.' . $backendType, $direction);
$idField = $this->qb->getRootAlias() . '.id';
$this->qb->addOrderBy($idField);
// Reapply previous join after the orderBy related join
// TODO : move this part in re-usable class
$this->applyJoins($joinsSet);
return $this;
}
/**
* Applies mass action parameters on the query builder
*
* @param QueryBuilder $qb
* @param bool $inset
* @param array $values
*/
public function applyMassActionParameters($qb, $inset, $values)
{
if (!empty($values)) {
$valueWhereCondition = $inset ? $qb->expr()->in($this->getAlias(), $values) : $qb->expr()->notIn($this->getAlias(), $values);
$qb->andWhere($valueWhereCondition);
}
if (null !== $qb->getDQLPart('where')) {
$whereParts = $qb->getDQLPart('where')->getParts();
$qb->resetDQLPart('where');
foreach ($whereParts as $part) {
if (!is_string($part) || !strpos($part, 'entityIds')) {
$qb->andWhere($part);
}
}
}
$qb->setParameters($qb->getParameters()->filter(function ($parameter) {
return $parameter->getName() !== 'entityIds';
}));
// remove limit of the query
$qb->setMaxResults(null);
}
public static function doesJoinAliasExistOnQueryBuilder(\Doctrine\ORM\QueryBuilder $qb, $alias)
{
$joinDqlParts = $qb->getDQLPart('join');
foreach ($joinDqlParts as $joins) {
foreach ($joins as $join) {
if ($join->getAlias() === $alias) {
return true;
}
}
}
return false;
}
/**
* Add a orderBy clause to the main query
*
* @param $column
* @param $order
* @return $this
*/
public function orderBy($column, $order)
{
$column = str_replace(".", "", $column);
$selects = $this->queryBuilder->getDQLPart('select');
foreach ($selects as $select) {
$selectSegments = explode(" ", $select);
if ($selectSegments[count($selectSegments) - 1] == $column) {
$this->queryBuilder->orderBy($selectSegments[0], $order);
}
}
return $this;
}
/**
* Get query builder joins
*
* @param QueryBuilder $qb
*
* @return array
*/
protected function getQbJoins(QueryBuilder $qb)
{
$qbJoin = [];
$joins = $qb->getDQLPart('join');
$rootAlias = current($qb->getRootAliases());
if (isset($joins[$rootAlias])) {
foreach ($joins[$rootAlias] as $join) {
$qbJoin[] = $join->getAlias();
}
}
return $qbJoin;
}
function it_creates_a_cursor(QueryBuilder $queryBuilder, AbstractQuery $query, From $from)
{
$queryBuilder->getRootAliases()->willReturn(['a']);
$queryBuilder->getDQLPart('from')->willReturn([$from]);
$queryBuilder->select('a.id')->willReturn($queryBuilder);
$queryBuilder->resetDQLPart('from')->willReturn($queryBuilder);
$queryBuilder->from(Argument::any(), Argument::any(), 'a.id')->willReturn($queryBuilder);
$queryBuilder->groupBy('a.id')->willReturn($queryBuilder);
$queryBuilder->getQuery()->willReturn($query);
$query->getArrayResult()->willReturn([]);
$cursor = $this->createCursor($queryBuilder);
$cursor->shouldBeAnInstanceOf('Akeneo\\Component\\StorageUtils\\Cursor\\CursorInterface');
}
/**
* Load the collection
*
*/
protected function initialize()
{
if ($this->initialized) {
return;
}
// Handle search
if (isset($this->searchExpression)) {
$queryBuilderExpression = $this->buildQueryBuilderExpression($this->searchExpression);
$this->queryBuilder->andWhere($queryBuilderExpression);
}
// Handle filters
if (isset($this->filterExpression)) {
$queryBuilderExpression = $this->buildQueryBuilderExpression($this->filterExpression);
$this->queryBuilder->andWhere($queryBuilderExpression);
}
// Handle sort
if (null !== $this->sortField && null !== $this->sortDirection) {
$oldOrderBys = $this->queryBuilder->getDQLPart('orderBy');
$this->queryBuilder->resetDQLPart('orderBy');
$this->queryBuilder->orderBy($this->sortField, $this->sortDirection);
foreach ($oldOrderBys as $oldOrderBy) {
$this->queryBuilder->add('orderBy', $oldOrderBy, true);
}
}
// Handle pagination
if (isset($this->limitPerPage)) {
$paginator = new DoctrineORMPaginator($this->queryBuilder->getQuery());
$paginator->setLimitPerPage($this->limitPerPage)->setRangeLimit($this->rangeLimit)->setPage($this->page);
$this->iterator = $paginator->getIterator();
$this->paginator = $paginator;
} else {
$items = $this->queryBuilder->getQuery()->getResult();
$this->iterator = new \ArrayIterator($items);
$this->paginator = null;
}
$this->initialized = true;
}
function let(QueryBuilder $queryBuilder, EntityManager $entityManager, AbstractQuery $query, From $from)
{
$rootIdExpr = 'o.id';
$from->getFrom()->willReturn('Pim\\Bundle\\CatalogBundle\\Model\\Product');
$from->getAlias()->willReturn('o');
$queryBuilder->getRootAliases()->willReturn(['o']);
$queryBuilder->getDQLPart('from')->willReturn([$from]);
$queryBuilder->select($rootIdExpr)->willReturn($queryBuilder);
$queryBuilder->resetDQLPart('from')->willReturn($queryBuilder);
$queryBuilder->from(Argument::any(), Argument::any(), $rootIdExpr)->willReturn($queryBuilder);
$queryBuilder->groupBy($rootIdExpr)->willReturn($queryBuilder);
$queryBuilder->getQuery()->willReturn($query);
$query->getArrayResult()->willReturn([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13]);
$this->beConstructedWith($queryBuilder, $entityManager, self::PAGE_SIZE);
}
/**
* Returns an expression in SELECT clause by its alias
*
* @param QueryBuilder $qb
* @param string $alias An alias of an expression in SELECT clause
*
* @return string|null
*/
public static function getSelectExprByAlias(QueryBuilder $qb, $alias)
{
/** @var \Doctrine\ORM\Query\Expr\Select $selectPart */
foreach ($qb->getDQLPart('select') as $selectPart) {
foreach ($selectPart->getParts() as $part) {
if (preg_match_all('#(\\,\\s*)*(?P<expr>.+?)\\s+AS\\s+(?P<alias>\\w+)#i', $part, $matches)) {
foreach ($matches['alias'] as $key => $val) {
if ($val === $alias) {
return $matches['expr'][$key];
}
}
}
}
}
return null;
}
function it_adds_a_sorter_in_the_query(QueryBuilder $queryBuilder, AbstractAttribute $sku)
{
$sku->getId()->willReturn(42);
$sku->getCode()->willReturn('sku');
$sku->getBackendType()->willReturn('varchar');
$sku->isLocalizable()->willReturn(false);
$sku->isScopable()->willReturn(false);
$queryBuilder->expr()->willReturn(new Expr());
$queryBuilder->getRootAlias()->willReturn('p');
$queryBuilder->getDQLPart('join')->willReturn([]);
$queryBuilder->resetDQLPart('join')->shouldBeCalled();
$condition = "sorterVsku1.attribute = 42";
$queryBuilder->leftJoin('p.values', 'sorterVsku1', 'WITH', $condition)->shouldBeCalled();
$queryBuilder->addOrderBy('sorterVsku1.varchar', 'DESC')->shouldBeCalled();
$this->addAttributeSorter($sku, 'DESC');
}
/**
* Will do JOIN only if there is no such join already.
*
* @param QueryBuilder $queryBuilder
* @param string $join
* @param string $alias
*
* @return QueryBuilder
*/
protected function join(QueryBuilder $queryBuilder, $join, $alias)
{
list($entity) = explode('.', $join);
$joinParts = $queryBuilder->getDQLPart('join');
if (!array_key_exists($entity, $joinParts)) {
return $queryBuilder->join($join, $alias);
}
$joinParts = $joinParts[$entity];
$existingJoin = array_filter($joinParts, function (Join $joinObj) use($alias, $join) {
return $joinObj->getAlias() == $alias && $joinObj->getJoin() == $join;
});
if ([] != $existingJoin) {
return $queryBuilder;
}
return $queryBuilder->join($join, $alias);
}
