addSortings example

$criteria->getPostFilters()
        ));

        $this->addFilter($definition, $filter, $query, $context);

        $this->addQueries($definition, $criteria, $query, $context);

        if ($criteria->getLimit() === 1) {
            $query->removeState(EntityDefinitionQueryHelper::HAS_TO_MANY_JOIN);
        }

        $this->addSortings($definition, $criteria, $criteria->getSorting(), $query, $context);

        return $query;
    }

    public function addFilter(EntityDefinition $definition, ?Filter $filter, QueryBuilder $query, Context $context): void
    {
        if (!$filter) {
            return;
        }

        $parsed = $this->parser->parse($filter, $definition, $context);

        

return new TermsResult($aggregation->getName(), $buckets);
    }

    private function addSorting(
        FieldSorting $sorting,
        EntityDefinition $definition,
        QueryBuilder $query,
        Context $context
    ): void {
        if ($sorting->getField() !== '_count') {
            $this->criteriaQueryBuilder->addSortings($definition, new Criteria(), [$sorting], $query, $context);

            return;
        }

        $countAccessor = $this->queryHelper->getFieldAccessor('id', $definition, $definition->getEntityName(), $context);
        $countAccessor = sprintf('COUNT(%s)', $countAccessor);

        $direction = $sorting->getDirection() === FieldSorting::ASCENDING ? FieldSorting::ASCENDING : FieldSorting::DESCENDING;

        $query->addOrderBy($countAccessor, $direction);
    }

    

/** * @throws Exception * * @return ListingResultStruct */
    public function getListing(ListingRequest $context)
    {
        $query = $this->getQuery()
            ->andWhere("plugin.name != 'PluginManager'")
            ->andWhere('plugin.capability_enable = 1');

        $this->addSortings($context, $query);

        $data = $query->setFirstResult($context->getOffset())
            ->setMaxResults($context->getLimit())
            ->execute()
            ->fetchAll(PDO::FETCH_ASSOC);

        $plugins = $this->iteratePlugins($data, $context);

        return new ListingResultStruct($plugins, \count($plugins));
    }

    

return $result;
    }

    private function createSearch(Criteria $criteria, EntityDefinition $definition, Context $context): Search
    {
        $search = new Search();

        $this->helper->handleIds($definition, $criteria, $search, $context);
        $this->helper->addFilters($definition, $criteria, $search, $context);
        $this->helper->addPostFilters($definition, $criteria, $search, $context);
        $this->helper->addQueries($definition, $criteria, $search, $context);
        $this->helper->addSortings($definition, $criteria, $search, $context);
        $this->helper->addTerm($criteria, $search, $context, $definition);

        $search->setSize(self::MAX_LIMIT);
        $limit = $criteria->getLimit();
        if ($limit !== null) {
            $search->setSize($limit);
        }
        $search->setFrom((int) $criteria->getOffset());

        return $search;
    }

    

$search->setSize($criteria->limit);
        }

        if ($criteria->term) {
            $search->addQuery($this->buildSearchQuery($criteria));
        }

        if (!empty($criteria->conditions)) {
            $this->addFilters($search, $criteria);
        }
        if (!empty($criteria->sortings)) {
            $this->addSortings($criteria, $search);
        }

        return $search;
    }

    protected function fetch(Search $search)
    {
        $arguments = [
            'index' => $this->indexFactory->createIndexConfiguration($this->domainName)->getAlias(),
            'type' => $this->domainName,
            'body' => $search->toArray(),