/**
* {@inheritDoc}
*/
public function sortQuery(QueryBuilder $qb, array $query)
{
if (is_string($query['sort_by'])) {
if ('item_count' == $query['sort_by']) {
$entityAlias = $this->getEntityClass();
$valuesAlias = $this->createAlias();
$resourceAlias = $this->createAlias();
$countAlias = $this->createAlias();
$qb->addSelect("COUNT({$valuesAlias}.id) HIDDEN {$countAlias}")->leftJoin("{$entityAlias}.values", $valuesAlias)->leftJoin("{$valuesAlias}.resource", $resourceAlias, 'WITH', "{$resourceAlias} INSTANCE OF Omeka\\Entity\\Item")->addGroupBy("{$entityAlias}.id")->addOrderBy($countAlias, $query['sort_order']);
} else {
parent::sortQuery($qb, $query);
}
}
}
/**
* {@inheritdoc}
*/
public function addFieldSorter($field, $direction)
{
$alias = 'inGroupSorter';
$inGroupExpr = 'CASE WHEN :currentGroup MEMBER OF p.groups THEN true ELSE false END';
$this->qb->addSelect(sprintf('%s AS %s', $inGroupExpr, $alias))->addOrderBy($alias, $direction);
return $this;
}
/**
* {@inheritdoc}
*/
public function addFieldSorter($field, $direction, $locale = null, $scope = null)
{
$alias = 'inGroupSorter';
$inGroupExpr = 'CASE WHEN :currentGroup MEMBER OF p.groups THEN true ELSE false END';
$this->qb->addSelect(sprintf('%s AS %s', $inGroupExpr, $alias))->addOrderBy($alias, $direction);
$idField = $this->qb->getRootAlias() . '.id';
$this->qb->addOrderBy($idField);
return $this;
}
/**
* {@inheritdoc}
*/
public function addFieldSorter($field, $direction)
{
$rootAlias = $this->qb->getRootAlias();
$prefix = 'sorter';
$field = $prefix . 'familyLabel';
$family = $prefix . 'family';
$trans = $prefix . 'familyTranslations';
$this->qb->leftJoin($rootAlias . '.family', $family)->leftJoin($family . '.translations', $trans, 'WITH', $trans . '.locale = :dataLocale');
$this->qb->addSelect('COALESCE(' . $trans . '.label, CONCAT(\'[\', ' . $family . '.code, \']\')) as ' . $field);
$this->qb->addOrderBy($field, $direction);
return $this;
}
/**
* {@inheritdoc}
*/
protected function addSelectColumn($entityClassName, $tableAlias, $fieldName, $columnExpr, $columnAlias, $columnLabel, $functionExpr, $functionReturnType, $isDistinct = false)
{
if ($isDistinct) {
$columnExpr = 'DISTINCT ' . $columnExpr;
}
if ($functionExpr !== null) {
$functionExpr = $this->prepareFunctionExpression($functionExpr, $tableAlias, $fieldName, $columnExpr, $columnAlias);
}
// @TODO find solution for aliases before generalizing this converter
// column aliases are not used here, because of parser error
$select = $functionExpr !== null ? $functionExpr : $columnExpr;
$this->qb->addSelect($select);
}
protected function join(QueryBuilder $qb, $add = false)
{
$qb->leftjoin('contact.phones', 'phones');
$qb->leftjoin('contact.account', 'account');
$qb->leftjoin('contact.agencies', 'agencies');
$qb->leftjoin('contact.city', 'city');
if ($add) {
$qb->addSelect('phones');
$qb->addSelect('account');
$qb->addSelect('agencies');
$qb->addSelect('city');
}
return $qb;
}
protected function join(QueryBuilder $qb, $add = false)
{
$qb->leftjoin('activity.account', 'account');
$qb->leftjoin('activity.user', 'user');
$qb->leftjoin('activity.replanned', 'replanned');
$qb->leftjoin('activity.replannedBy', 'replannedBy');
$qb->leftjoin('activity.type', 'type');
if ($add) {
$qb->addSelect('account');
$qb->addSelect('user');
$qb->addSelect('replanned');
$qb->addSelect('replannedBy');
$qb->addSelect('type');
}
return $qb;
}
/**
* {@inheritdoc}
*/
public function execute()
{
// emit listbuilder.create event
$event = new ListBuilderCreateEvent($this);
$this->eventDispatcher->dispatch(ListBuilderEvents::LISTBUILDER_CREATE, $event);
$this->expressionFields = $this->getUniqueExpressionFieldDescriptors($this->expressions);
// first create simplified id query
// select ids with all necessary filter data
$ids = $this->findIdsByGivenCriteria();
// if no results are found - return
if (count($ids) < 1) {
return [];
}
// now select all data
$this->queryBuilder = $this->em->createQueryBuilder()->from($this->entityName, $this->entityName);
$this->assignJoins($this->queryBuilder);
// Add all select fields
foreach ($this->selectFields as $field) {
$this->queryBuilder->addSelect($field->getSelect() . ' AS ' . $field->getName());
}
// group by
$this->assignGroupBy($this->queryBuilder);
// assign sort-fields
$this->assignSortFields($this->queryBuilder);
// use ids previously selected ids for query
$this->queryBuilder->where($this->entityName . '.id IN (:ids)')->setParameter('ids', $ids);
return $this->queryBuilder->getQuery()->getArrayResult();
}
/**
* Build and returns Query for select rows
* @param \Doctrine\ORM\QueryBuilder $queryBuilder
* @param \EMC\TableBundle\Provider\QueryConfigInterface $queryConfig
* @param array $mapping
* @return \Doctrine\ORM\Query
*/
private function getQueryRows(QueryBuilder $queryBuilder, QueryConfigInterface $queryConfig, array &$mapping)
{
$queryBuilder->resetDQLPart('select');
$limit = $queryConfig->getLimit();
$page = $queryConfig->getPage();
$select = $queryConfig->getSelect();
$orderBy = $queryConfig->getOrderBy();
if ($limit > 0) {
$queryBuilder->setMaxResults($limit)->setFirstResult(($page - 1) * $limit);
}
$mapping = array_map(function ($i) {
return 'col' . $i;
}, array_flip($select));
foreach ($mapping as $column => $name) {
$queryBuilder->addSelect($column . ' AS ' . $name);
}
if (count($orderBy) === 0) {
$queryBuilder->orderBy($queryBuilder->getRootAlias() . '.id', 'ASC');
} else {
foreach ($orderBy as $column => $isAsc) {
$queryBuilder->orderBy($column, $isAsc ? 'ASC' : 'DESC');
}
}
return $queryBuilder->getQuery();
}
protected function join(QueryBuilder $qb, $add = false)
{
$qb->leftjoin('agency.accounts', 'accounts');
$qb->leftjoin('agency.users', 'users');
$qb->leftjoin('users.end', 'users_end');
$qb->leftjoin('agency.contacts', 'contacts');
$qb->leftjoin('agency.city', 'city');
if ($add) {
$qb->addSelect('accounts');
$qb->addSelect('users');
$qb->addSelect('users_end');
$qb->addSelect('contacts');
$qb->addSelect('city');
}
return $qb;
}
protected function join(QueryBuilder $qb, $add = false)
{
$qb->leftjoin('agency_account.turnovers', 'turnovers');
if ($add) {
$qb->addSelect('turnovers');
}
return $qb;
}
/**
* @param QueryBuilder $qb Source query builder
* @param string $emailFromTableAlias EmailAddress table alias of joined Email#fromEmailAddress association
*/
public function prepareQuery(QueryBuilder $qb, $emailFromTableAlias = 'a')
{
$qb->addSelect($this->getFromEmailExpression($emailFromTableAlias));
foreach ($this->emailOwnerProviderStorage->getProviders() as $provider) {
$fieldName = $this->emailOwnerProviderStorage->getEmailOwnerFieldName($provider);
$qb->leftJoin(sprintf('%s.%s', $emailFromTableAlias, $fieldName), $fieldName);
}
}
/**
* Set select from.
*
* @return $this
*/
private function setSelectFrom()
{
foreach ($this->selectColumns as $key => $value) {
$this->qb->addSelect('partial ' . $key . '.{' . implode(',', $this->selectColumns[$key]) . '}');
}
$this->qb->from($this->entity, $this->tableName);
return $this;
}
/**
* {@inheritdoc}
*/
protected function prepareQuery(QueryBuilder $query, $rootAlias, $alias, $itemsType)
{
$entityId = $this->requestParams->get(self::ENTITY_PARAM, 0);
$query->where($rootAlias . '.mode <> :mode');
$query->setParameter('mode', ConfigModelManager::MODE_HIDDEN);
$query->innerJoin($rootAlias . '.entity', 'ce', 'WITH', 'ce.id=' . $entityId);
$query->addSelect('ce.id as entity_id');
return parent::prepareQuery($query, $rootAlias, $alias, $itemsType);
}
/**
* @param $columns \Sorien\DataGridBundle\Grid\Column\Column[]
* @param $page int Page Number
* @param $limit int Rows Per Page
* @return \Sorien\DataGridBundle\Grid\Rows
*/
public function execute($columns, $page = 0, $limit = 0)
{
$this->query = $this->manager->createQueryBuilder($this->class);
$this->query->from($this->class, self::TABLE_ALIAS);
$where = $this->query->expr()->andx();
$sorted = false;
foreach ($columns as $column) {
$this->query->addSelect($this->getFieldName($column));
if ($column->isSorted() && !$column->isDefaultSort()) {
$this->query->orderBy($this->getFieldName($column, false), $column->getOrder());
$sorted = true;
} elseif (!$sorted && $column->isSorted() && $column->isDefaultSort()) {
$this->query->orderBy($this->getFieldName($column, false), $column->getOrder());
}
if ($column->isFiltered()) {
if ($column->getFiltersConnection() == column::DATA_CONJUNCTION) {
foreach ($column->getFilters() as $filter) {
$operator = $this->normalizeOperator($filter->getOperator());
$where->add($this->query->expr()->{$operator}($this->getFieldName($column, false), $this->normalizeValue($filter->getOperator(), $filter->getValue())));
}
} elseif ($column->getFiltersConnection() == column::DATA_DISJUNCTION) {
$sub = $this->query->expr()->orx();
foreach ($column->getFilters() as $filter) {
$operator = $this->normalizeOperator($filter->getOperator());
$sub->add($this->query->expr()->{$operator}($this->getFieldName($column, false), $this->normalizeValue($filter->getOperator(), $filter->getValue())));
}
$where->add($sub);
}
$this->query->where($where);
}
}
foreach ($this->joins as $alias => $field) {
$this->query->leftJoin($field, $alias);
}
if ($page > 0) {
$this->query->setFirstResult($page * $limit);
}
if ($limit > 0) {
$this->query->setMaxResults($limit);
}
//call overridden prepareQuery or associated closure
$query = $this->prepareQuery(clone $this->query);
$items = $query->getQuery()->getResult();
// hydrate result
$result = new Rows();
foreach ($items as $item) {
$row = new Row();
foreach ($item as $key => $value) {
$row->setField($key, $value);
}
//call overridden prepareRow or associated closure
if (($modifiedRow = $this->prepareRow($row)) != null) {
$result->addRow($modifiedRow);
}
}
return $result;
}
/**
* Left joins relations to eager load.
*
* @param ResourceInterface $resource
* @param QueryBuilder $queryBuilder
*/
private function joinRelations(ResourceInterface $resource, QueryBuilder $queryBuilder)
{
$classMetaData = $queryBuilder->getEntityManager()->getClassMetadata($resource->getEntityClass());
foreach ($classMetaData->getAssociationNames() as $i => $association) {
$mapping = $classMetaData->associationMappings[$association];
if (ClassMetadataInfo::FETCH_EAGER === $mapping['fetch']) {
$queryBuilder->leftJoin('o.' . $association, 'a' . $i);
$queryBuilder->addSelect('a' . $i);
}
}
}
/**
* Evaluates inner joins
*
* @param QueryBuilder $queryBuilder Query builder
* @param AnnotationPaginator $annotation Annotation
*
* @return PaginatorEvaluatorInterface self Object
*/
public function evaluate(QueryBuilder $queryBuilder, AnnotationPaginator $annotation)
{
if (is_array($annotation->getInnerJoins())) {
foreach ($annotation->getInnerJoins() as $innerJoin) {
$queryBuilder->innerJoin(trim($innerJoin[0]) . '.' . trim($innerJoin[1]), trim($innerJoin[2]));
if (isset($innerJoin[3]) && $innerJoin[3]) {
$queryBuilder->addSelect(trim($innerJoin[2]));
}
}
}
return $this;
}
protected function processOrderByForList(QueryBuilder $qb, $orderBy)
{
$fieldName = is_array($orderBy) ? key($orderBy) : $orderBy;
$order = is_array($orderBy) ? $orderBy[$fieldName] : 'ASC';
if (in_array($fieldName, ['visits', 'visitsCount', 'visitCount'])) {
$qb->addSelect('COUNT(v) AS totalVisits')->leftJoin('s.visits', 'v')->groupBy('s')->orderBy('totalVisits', $order);
return array_column($qb->getQuery()->getResult(), 0);
} elseif (in_array($fieldName, ['originalUrl', 'shortCode', 'dateCreated'])) {
$qb->orderBy('s.' . $fieldName, $order);
}
return $qb->getQuery()->getResult();
}
public function hydrateQueryBuilder(QueryBuilder $queryBuilder)
{
$queryBuilder->addSelect('s, t')->leftJoin('k.phrases', 's', Expr\Join::WITH, 's.locale = :source')->leftJoin('k.phrases', 't', Expr\Join::WITH, 't.locale = :target')->andWhere('k.resource = :resource')->orderBy('k.identifier', 'ASC')->setParameters(array('resource' => $this->resource, 'source' => (string) $this->source, 'target' => (string) $this->target));
if ($text = $this->text) {
$queryBuilder->andWhere($queryBuilder->expr()->orX($queryBuilder->expr()->like('k.identifier', ':text'), $queryBuilder->expr()->like('s.text', ':text'), $queryBuilder->expr()->like('t.text', ':text')))->setParameter('text', '%' . $text . '%');
}
if (null !== ($translated = $this->translated)) {
$queryBuilder->andWhere($translated ? $queryBuilder->expr()->isNotNull('t.text') : $queryBuilder->expr()->isNull('t.text'));
}
if (null !== ($approved = $this->approved)) {
$queryBuilder->andWhere($queryBuilder->expr()->eq('t.isApproved', ':isApproved'))->setParameter('isApproved', $approved);
}
}
public function implement(DoctrineQueryBuilder $queryBuilder)
{
if ($this->payload->get('count')->getValue() === true) {
return $queryBuilder;
}
foreach ($this->getValue() as $i => $field) {
if ($i === 0) {
$queryBuilder->select($field);
} else {
$queryBuilder->addSelect($field);
}
}
}
/**
* Builds the selectquery for the database, based on the available entity properties
*
* @param array $columns
* @return $this
* @throws \Exception
*/
public function select(array $columns)
{
$this->reset();
// Always assure the Identifier field is also in the select statement, this field is needed to join subqueries
$entityMetaData = $this->entityMetadataHelper->getEntityMetadata($this->sourceEntityName);
$identifierField = $entityMetaData->getSingleIdentifierFieldName();
if (!in_array($identifierField, $columns)) {
$this->additionalWhereColumns[] = $identifierField;
$columns[] = $identifierField;
return $this->select($columns);
}
$joinedProperties = array();
$fieldsMetaData = $this->entityMetadataHelper->parseMetaDataToFieldArray($entityMetaData);
$entityShortName = $this->getEntityShortName($this->sourceEntityName);
foreach ($columns as $fieldName) {
// filter in availableTableColumns instead of $fieldMetaData due to the prohibitedColumns
if (!array_key_exists($fieldName, $this->availableTableColumns)) {
continue;
}
$fieldNameSegments = explode(".", $fieldName);
$fullFieldName = $fieldName;
$fieldName = reset($fieldNameSegments);
$fieldMetaData = $fieldsMetaData[$fieldName];
// Treat non association fields normally
if ($fieldMetaData['type'] !== 'association') {
$this->queryBuilder->addSelect($entityShortName . '.' . $fieldName . ' AS ' . $fieldName);
$this->addToSelectedTableColumns($fieldName);
continue;
}
// fields in a different query need different processing
if ($this->needsSubQuery($fullFieldName)) {
$this->selectInSubQuery($fieldName, $fieldMetaData['targetEntity'], end($fieldNameSegments));
continue;
}
// Joining and selecting
if (!isset($fieldMetaData['joinColumns']) || empty($fieldMetaData['joinColumns'])) {
throw new \Exception(sprintf('Can\'t create join query parameters for %s in Entity %s', $fieldMetaData['fieldName'], $entityShortName));
}
$joinAlias = array_key_exists($fieldName, $joinedProperties) ? $joinedProperties[$fieldName] : false;
if (!$joinAlias) {
$joinAlias = $this->getEntityShortName($fieldMetaData['targetEntity']) . count($joinedProperties);
$this->queryBuilder->leftJoin($entityShortName . '.' . $fieldName, $joinAlias);
$joinedProperties[$fieldName] = $joinAlias;
}
$fieldAlias = implode($fieldNameSegments);
$this->queryBuilder->addSelect($joinAlias . '.' . end($fieldNameSegments) . ' AS ' . $fieldAlias);
$this->addToSelectedTableColumns(implode('.', $fieldNameSegments));
}
return $this;
}
/**
* Prepare certain search condition
*
* @param \Doctrine\ORM\QueryBuilder $queryBuilder Query builder to prepare
* @param array $value Condition data
* @param boolean $countOnly "Count only" flag. Do not need to add "order by" clauses if only count is needed.
*
* @return void
*/
protected function prepareCndOrderBy(\Doctrine\ORM\QueryBuilder $queryBuilder, array $value, $countOnly)
{
if (!$countOnly) {
list($sort, $order) = $this->getSortOrderValue($value);
if ('r.rating' == $sort) {
$queryBuilder->linkLeft('p.reviews', 'r');
$queryBuilder->addSelect('SUM(r.rating) as rsm');
$sort = 'rsm';
$queryBuilder->addOrderBy($sort, $order);
} else {
parent::prepareCndOrderBy($queryBuilder, $value, $countOnly);
}
}
}
/**
* @param QueryBuilder $queryBuilder
*
* @return void
*/
public function apply($queryBuilder)
{
$compiler = new SqlFilterCompiler();
// @codingStandardsIgnoreStart
// $compiler->setSkipMissingProperties(true);
// @codingStandardsIgnoreEnd
$compiler->compile($this->properties, $this->filter);
$select = $compiler->getSelect(false) and $queryBuilder->addSelect($select);
$where = $compiler->getWhere(false) and $queryBuilder->andWhere($where);
$having = $compiler->getHaving(false) and $queryBuilder->andHaving($having);
$order = $compiler->getOrder(false) and $queryBuilder->addOrderBy($order);
foreach ($compiler->getParameters() as $key => $value) {
$queryBuilder->setParameter($key, $value);
}
}
/**
* Prepare certain search condition
*
* @param \Doctrine\ORM\QueryBuilder $queryBuilder Query builder to prepare
* @param array $value Condition data
* @param boolean $countOnly Count only flag
*
* @return void
*/
protected function prepareCndParticipateSale(\Doctrine\ORM\QueryBuilder $queryBuilder, $value, $countOnly)
{
$cnd = new \Doctrine\ORM\Query\Expr\Orx();
$pricePercentCnd = new \Doctrine\ORM\Query\Expr\Andx();
$pricePercentCnd->add('p.discountType = :discountTypePercent');
$pricePercentCnd->add('p.salePriceValue > 0');
$priceAbsoluteCnd = new \Doctrine\ORM\Query\Expr\Andx();
$priceAbsoluteCnd->add('p.discountType = :discountTypePrice');
$priceAbsoluteCnd->add('p.price > p.salePriceValue');
$cnd->add($pricePercentCnd);
$cnd->add($priceAbsoluteCnd);
if (!$countOnly) {
$queryBuilder->addSelect('if(p.discountType = :discountTypePercent, p.salePriceValue, 100 - 100 * p.salePriceValue / p.price) ' . static::PERCENT_CALCULATED_FIELD);
}
$queryBuilder->andWhere('p.participateSale = :participateSale')->andWhere($cnd)->setParameter('participateSale', $value)->setParameter('discountTypePercent', \XLite\Module\CDev\Sale\Model\Product::SALE_DISCOUNT_TYPE_PERCENT)->setParameter('discountTypePrice', \XLite\Module\CDev\Sale\Model\Product::SALE_DISCOUNT_TYPE_PRICE);
}
protected function join(QueryBuilder $qb, $add = false)
{
$qb->leftjoin('account.contacts', 'contacts');
$qb->leftjoin('account.owners', 'owners');
$qb->leftjoin('owners.end', 'owners_end');
$qb->leftjoin('account.agencies', 'agencies');
$qb->leftjoin('agencies.turnovers', 'turnovers');
$qb->leftjoin('account.city', 'city');
if ($add) {
$qb->addSelect('contacts');
$qb->addSelect('owners');
$qb->addSelect('owners_end');
$qb->addSelect('agencies');
$qb->addSelect('turnovers');
$qb->addSelect('city');
}
return $qb;
}
protected function join(QueryBuilder $qb, $add = false)
{
$qb->innerjoin('user.user', 'securityUser');
$qb->leftjoin('user.activities', 'activities');
$qb->leftjoin('user.assignedAccount', 'assignedAccount');
$qb->leftjoin('assignedAccount.end', 'assignedAccount_end');
$qb->leftjoin('user.agencies', 'agencies');
$qb->leftjoin('agencies.agency', 'agency');
$qb->leftjoin('agencies.end', 'agencies_end');
if ($add) {
$qb->addSelect('securityUser');
$qb->addSelect('assignedAccount');
$qb->addSelect('agencies');
$qb->addSelect('agency');
$qb->addSelect('agencies_end');
$qb->addSelect('assignedAccount_end');
}
return $qb;
}
/**
* A recursive function to process the specified expose fields for a fetch request (GET)
* @param array $fields - expose fields to process
* @param ORM\QueryBuilder $qb
* @param ORM\Mapping\ClassMetadata $classMetaData
* @param $rootAlias - table alias to be used on SQL query
* @param array $addedKeyFields
* @return ORM\QueryBuilder
*/
protected function registerExpose($fields, ORM\QueryBuilder $qb, ORM\Mapping\ClassMetadata $classMetaData, $rootAlias = null, &$addedKeyFields = [])
{
if (empty($fields)) {
return $qb;
}
$rootAlias = is_null($rootAlias) ? self::getAlias($classMetaData->getName()) : $rootAlias;
$addedKeyFields = (array) $addedKeyFields;
$ormAssociationMappings = $classMetaData->getAssociationMappings();
// Process single fields into a partial set - Filter fields not available on class meta data
$selectFields = $this->getFilteredAssociations($fields, $classMetaData, 'fields');
// merge required identifier fields with select fields
$keyFieldDiff = array_diff($classMetaData->getIdentifierFieldNames(), $selectFields);
if (!empty($keyFieldDiff)) {
$addedKeyFields = $keyFieldDiff;
$selectFields = array_merge($selectFields, $keyFieldDiff);
}
if (!empty($selectFields)) {
$qb->addSelect('partial ' . $rootAlias . '.{' . implode(', ', $selectFields) . '}');
}
// Process relational field with no deeper expose restrictions
foreach ($this->getFilteredAssociations($fields, $classMetaData, 'association') as $relationalField) {
$alias = self::getAlias($ormAssociationMappings[$relationalField]['targetEntity'], $relationalField);
$qb->leftJoin($rootAlias . '.' . $relationalField, $alias);
$qb->addSelect($alias);
}
foreach ($fields as $key => $value) {
if (is_array($value) && isset($ormAssociationMappings[$key])) {
$alias = self::getAlias($ormAssociationMappings[$key]['targetEntity'], $key);
$qb->leftJoin($rootAlias . '.' . $key, $alias);
$qb = $this->registerExpose($value, $qb, $this->getEntityManager()->getClassMetadata($ormAssociationMappings[$key]['targetEntity']), $alias, $addedKeyFields[$key]);
}
}
$this->addedKeyFields = $addedKeyFields;
return $qb;
}
/**
* @param QueryBuilder $query
* @param string $rootAlias
* @param string $joinAlias
* @param string $itemsType
*
* @return $this
*/
protected function prepareQuery(QueryBuilder $query, $rootAlias, $joinAlias, $itemsType)
{
$providers = $this->configManager->getProviders();
foreach ($providers as $provider) {
$configItems = $provider->getPropertyConfig()->getItems($itemsType);
foreach ($configItems as $code => $item) {
if (!isset($item['grid'])) {
continue;
}
if (!isset($item['options']['indexed']) || !$item['options']['indexed']) {
continue;
}
$alias = $joinAlias . $provider->getScope() . '_' . $code;
$fieldName = $provider->getScope() . '_' . $code;
if (isset($item['grid']['query'])) {
$query->andWhere($alias . '.value ' . $item['grid']['query']['operator'] . ' :' . $alias);
$query->setParameter($alias, (string) $item['grid']['query']['value']);
}
$query->leftJoin($rootAlias . '.indexedValues', $alias, 'WITH', $alias . ".code='" . $code . "' AND " . $alias . ".scope='" . $provider->getScope() . "'");
$query->addSelect($alias . '.value as ' . $fieldName);
}
}
return $this;
}
/**
* @param QueryBuilder $qb
* @param string $alias
* @param string $entityClass
* @param array $config
* @param boolean $withAssociations
*/
public function updateSelectQueryPart(QueryBuilder $qb, $alias, $entityClass, $config, $withAssociations = false)
{
if ($this->isPartialAllowed($config)) {
$entityMetadata = $this->doctrineHelper->getEntityMetadata($entityClass);
$fields = array_filter($this->getFields($entityClass, $config), function ($field) use($entityMetadata, $withAssociations) {
// skip metadata properties like '__class__' or '__discriminator__'
if ($this->isMetadataField($field)) {
return false;
}
return $withAssociations ? !$entityMetadata->isCollectionValuedAssociation($field) : !$entityMetadata->isAssociation($field);
});
// make sure identifier fields are added
foreach ($entityMetadata->getIdentifierFieldNames() as $field) {
if (!in_array($field, $fields, true)) {
$fields[] = $field;
}
}
$qb->addSelect(sprintf('partial %s.{%s}', $alias, implode(',', $fields)));
} else {
$qb->addSelect($alias);
}
}
/**
* {@inheritDoc}
*/
public function execute()
{
$this->queryBuilder = $this->createQueryBuilder();
foreach ($this->fields as $field) {
$this->queryBuilder->addSelect($field->getSelect() . ' AS ' . $field->getName());
}
if ($this->limit != null) {
$this->queryBuilder->setMaxResults($this->limit)->setFirstResult($this->limit * ($this->page - 1));
}
if ($this->sortField != null) {
$this->queryBuilder->orderBy($this->sortField->getSelect(), $this->sortOrder);
}
return $this->queryBuilder->getQuery()->getArrayResult();
}
