PHP Criteria::orderBy方法代碼示例

 /**
  * @param DataStructure\Sort $sorting
  *
  * @return void
  */
 public function sort(DataStructure\Sort $sorting)
 {
     $sortings = [];
     foreach ($sorting as $sortingEntity) {
         if ($this->isExcludedProperty($sortingEntity->getProperty())) {
             continue;
         }
         $sortings[$sortingEntity->getProperty()] = $sortingEntity instanceof DataStructure\Sort\Asc ? 'asc' : 'desc';
     }
     $this->criteria->orderBy($sortings);
 }

 public function searchByContains(array $criteria, array $orderBy = null, $page = 0, $pageSize = PHP_INT_MAX)
 {
     if ($page < 0 || $pageSize < 1) {
         throw new \Exception("Invalid page or pageSize: page must be >= 0 and pageSize must be > 0");
     } else {
         $criteriaObj = new Criteria();
         $i = 0;
         foreach ($criteria as $field => $value) {
             if ($value == null) {
                 continue;
             } else {
                 if ($i++ == 0) {
                     $criteriaObj->where($criteriaObj->expr()->contains($field, $value));
                 } else {
                     $criteriaObj->orWhere($criteriaObj->expr()->contains($field, $value));
                 }
             }
         }
         if ($orderBy != null) {
             $criteriaObj->orderBy($orderBy);
         }
         $total = $this->repository->matching($criteriaObj)->count();
         $query = $this->repository->createQueryBuilder("q")->addCriteria($criteriaObj);
         $items = $query->setFirstResult($page * $pageSize)->setMaxResults($pageSize)->getQuery()->getResult();
         return ResponseUtils::createSearchResponse($total, $items, $page, $pageSize);
     }
 }

 /**
  * @param Request         $request
  * @param FilterInterface $filter
  * @param Criteria        $criteria
  * @param ClassMetadata   $embedClassMeta
  *
  * @return null
  */
 protected function applyFilter(Request $request, FilterInterface $filter, Criteria $criteria, ClassMetadata $embedClassMeta)
 {
     $properties = $filter->getRequestProperties($request);
     if ($filter instanceof OrderFilter && !empty($properties)) {
         $criteria->orderBy($properties);
         return null;
     }
     if ($filter instanceof SearchFilter) {
         foreach ($properties as $name => $propertie) {
             if (in_array($name, $embedClassMeta->getIdentifier())) {
                 continue;
             }
             $expCriterial = Criteria::expr();
             if ($embedClassMeta->hasAssociation($name)) {
                 $associationTargetClass = $embedClassMeta->getAssociationTargetClass($name);
                 $propertyResource = $this->resourceResolver->getResourceForEntity($associationTargetClass);
                 $propertyObj = $this->dataProviderChain->getItem($propertyResource, (int) $propertie['value'], true);
                 if ($propertyObj && $propertyResource instanceof ResourceInterface) {
                     $whereCriteria = $expCriterial->in($name, [$propertyObj]);
                     $criteria->where($whereCriteria);
                 }
             } else {
                 if ($embedClassMeta->hasField($name)) {
                     $fieldMapping = $embedClassMeta->getFieldMapping($name);
                     $type = isset($fieldMapping['type']) ? $fieldMapping['type'] : null;
                     $value = isset($this->mappingFilterVar[$type]) ? filter_var($propertie['value'], $this->mappingFilterVar[$type]) : $propertie['value'];
                     $whereCriteria = isset($propertie['precision']) && $propertie['precision'] === 'exact' ? $expCriterial->eq($name, $value) : $expCriterial->contains($name, $propertie['value']);
                     $criteria->where($whereCriteria);
                 }
             }
         }
     }
 }

 private function createCriteria()
 {
     $criteria = new Criteria();
     $criteria->orderBy(array('username' => 'ASC'));
     $criteria->setFirstResult(2);
     $criteria->setMaxResults(3);
     return $criteria;
 }

 protected function generateMenu()
 {
     $criteria = new Criteria();
     $criteria->orderBy(['hierarchy' => 'asc']);
     $collection = $this->adminMenuRepository->matching($criteria);
     $elements = $this->filterElements($collection, null);
     $tree = $this->generateTree($collection, $elements);
     return $tree;
 }

 /**
  * {@inheritdoc}
  */
 public function apply(Criteria $criteria, FilterValue $value = null)
 {
     $val = null !== $value ? $value->getValue() : $this->getDefaultValue();
     if (!empty($val)) {
         $criteria->orderBy($val);
     }
 }

 /**
  * Gets emails by ids
  *
  * @param int[] $ids
  *
  * @return Email[]
  */
 public function findEmailsByIds($ids)
 {
     $queryBuilder = $this->createQueryBuilder('e');
     $criteria = new Criteria();
     $criteria->where(Criteria::expr()->in('id', $ids));
     $criteria->orderBy(['sentAt' => Criteria::DESC]);
     $queryBuilder->addCriteria($criteria);
     $result = $queryBuilder->getQuery()->getResult();
     return $result;
 }

 public function getMenu()
 {
     $criteria = new Criteria();
     $criteria->orderBy(['hierarchy' => 'asc']);
     $criteria->andWhere($criteria->expr()->eq('parent', null));
     return $this->adminMenuRepository->matching($criteria);
 }

 /**
  * Sort data
  * @param Sorting $sorting
  * @return static
  */
 public function sort(Sorting $sorting)
 {
     if (is_callable($sorting->getSortCallback())) {
         call_user_func($sorting->getSortCallback(), $this->criteria, $sorting->getSort());
         return $this;
     }
     if ($sort = $sorting->getSort()) {
         $this->criteria->orderBy($sort);
         return $this;
     }
     $this->criteria->orderBy([$this->primary_key => 'ASC']);
     return $this;
 }

 /**
  * {@inheritdoc}
  */
 public function load(ObjectManager $manager)
 {
     $criteria = new Criteria();
     $criteria->where($criteria->expr()->neq('xThreadId', null));
     /** @var QueryBuilder $threadQueryBuilder */
     $threadQueryBuilder = $manager->getRepository('OroEmailBundle:Email')->createQueryBuilder('entity');
     $threadQueryBuilder->distinct()->select('entity.xThreadId');
     $threadQueryBuilder->addCriteria($criteria);
     $iterator = new BufferedQueryResultIterator($threadQueryBuilder);
     $iterator->setBufferSize(self::BATCH_SIZE);
     $itemsCount = 0;
     $entities = [];
     foreach ($iterator as $threadResult) {
         $threadId = $threadResult['xThreadId'];
         /** @var QueryBuilder $queryBuilder */
         $queryBuilder = $manager->getRepository('OroEmailBundle:Email')->createQueryBuilder('entity');
         $criteria = new Criteria();
         $criteria->where($criteria->expr()->eq('xThreadId', $threadId));
         $criteria->orderBy(['created' => 'ASC']);
         $queryBuilder->addCriteria($criteria);
         $queryBuilder->setFirstResult(0);
         $emails = $queryBuilder->getQuery()->execute();
         if (count($emails) > 1) {
             $itemsCount++;
             $newThread = new EmailThread();
             $manager->persist($newThread);
             foreach ($emails as $key => $email) {
                 /** @var Email $email */
                 if ($key == 0) {
                     $email->setHead(true);
                 } else {
                     $email->setHead(false);
                 }
                 $email->setThread($newThread);
                 $entities[] = $email;
             }
         } elseif (count($emails) == 1) {
             $email = $emails[0];
             $email->setHead(true);
             $itemsCount++;
             $entities[] = $email;
         }
         if (0 == $itemsCount % self::BATCH_SIZE) {
             $this->saveEntities($manager, $entities);
             $entities = [];
         }
     }
     if ($itemsCount % self::BATCH_SIZE > 0) {
         $this->saveEntities($manager, $entities);
     }
 }

 public function __invoke(Criteria $criteria)
 {
     if (!$this->getController() instanceof AbstractController) {
         throw new \LogicException('Cannot locate the controller');
     }
     $sort = $this->getController()->params()->fromQuery('sorting');
     if ($sort) {
         $fields = explode(',', $sort);
         $orderBy = [];
         foreach ($fields as $field) {
             $parts = explode(':', $field);
             // Ignore it
             if (count($parts) != 2) {
                 continue;
             }
             $orderBy[$parts[0]] = $parts[1];
         }
         $criteria->orderBy($orderBy);
     }
 }

 public function testOrderings()
 {
     $criteria = new Criteria();
     $criteria->orderBy(array("foo" => "ASC"));
     $this->assertEquals(array("foo" => "ASC"), $criteria->getOrderings());
 }

 /**
  * Returns the collection of producers for given identifiers
  *
  * @param array $identifiers
  *
  * @return \Doctrine\Common\Collections\Collection
  */
 protected function getProducerCollection(array $identifiers = [])
 {
     $criteria = new Criteria();
     $criteria->orderBy(['id' => 'asc']);
     $criteria->where($criteria->expr()->in('id', $identifiers));
     return $this->producerRepository->matching($criteria);
 }

 /**
  * Process order
  * 
  * @param Criteria         $criteria
  * @param RequestInterface $request
  */
 protected function processOrder(Criteria $criteria, RequestInterface $request)
 {
     $criteria->orderBy($request->getOrder());
 }

 /**
  * {@inheritdoc}
  */
 public function getShippingMethods() : Collection
 {
     $criteria = new Criteria();
     $criteria->where($criteria->expr()->eq('enabled', true));
     $criteria->orderBy(['hierarchy' => 'asc']);
     $methods = $this->matching($criteria)->filter(function (ShippingMethodInterface $shippingMethod) {
         $paymentMethodsCount = $shippingMethod->getPaymentMethods()->count();
         $shippingMethodCostCount = $shippingMethod->getCosts()->count();
         return $paymentMethodsCount > 0 && $shippingMethodCostCount > 0;
     });
     return $methods;
 }