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