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