PHP QueryBuilder::getDQLPart方法代码示例

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