generate - symfony2: cómo usar group_concat en QueryBuilder

generate entity symfony

Question

Estoy teniendo una entidad de conjunto anidado (utilizando el árbol Gedmo) llamada "Ubicación". La entidad "Appartment" tiene location_id y lo que necesito hacer para asignar un valor escalar llamado, por ejemplo, "path" a la consulta que devuelve todos los apartamentos.

En Doctrine1, tenía este código:

/**
* Add "path" to each element
*
* @param Doctrine_Query $query
* @param string $separator
*/
protected function addScalar_path(Doctrine_Query $query, $separator=", ")
{
$subquery = "k99.root_id=o.root_id AND k99.lft<=o.lft AND k99.rgt>=o.rgt AND k99.level<=o.level" ;
$query->addSelect("(SELECT GROUP_CONCAT(k99.name ORDER BY k99.level SEPARATOR ''$separator'') FROM Location k99 WHERE $subquery) AS path") ;
}

Nota: el alias "o" se usa para la consulta primaria. Este código me permitiría usar

{foreach .... as $appartment}
{$appartment->path}
...

Lo que imprimiría:

Australia, Victoria, Melbourne, ...other children...

¿Cómo hacer lo mismo en D2? ¿Y cómo incluso incluir explicaciones de doctrina en mi proyecto symfony2?

Answer 1

Si aparece alguno en esta publicación, ahora hay un repositorio de Doctrine Extensions en Github. El repositorio tiene instrucciones sobre cómo usarlo. Puedes usar Composer para instalarlo y luego usar cualquier función que te interese.

EDITAR:

Por el bien del usuario Tushar, la forma de usar GROUP_CONCAT en el DQL de Doctrine2 es simplemente instalar Doctrine Extensions :

composer require beberlei/DoctrineExtensions

Para habilitarlo: agregue lo siguiente en su config.yml:

doctrine:
orm:
dql:
string_functions:
group_concat: DoctrineExtensions/Query/Mysql/GroupConcat

Luego, en tu código, deberías poder usar Group Concat en tus DQL:

$this->createQueryBuilder(''location'')
->select(''location'')
->addSelect("GROUP_CONCAT(DISTINCT location.name SEPARATOR ''; '') AS locationNames");
$result = $queryBuilder->getQuery()->getResult();

O en el caso de la pregunta original:

$query->addSelect("(SELECT GROUP_CONCAT(k99.name ORDER BY k99.level SEPARATOR ''$separator'') FROM Location k99 WHERE $subquery) AS path");

Answer 2

Si quieres usarlo en QueryBuilder debes:

1) agregar funciones DQL GroupConcat: GroupConcat

2) Registro de GroupConcat: funciones definidas por el usuario DQL

Otra alternativa es usar NativeQuery: SQL nativo.

En symfony2 registrar una función DQL es muy simple, simplemente agrega GROUP_CONCAT en config.yml como:

 entity_managers:
default:
dql:
string_functions:
GROUP_CONCAT: YourBundle/Query/Mysql/GroupConcat

Para más información visite Registro de funciones DQL personalizadas.

Answer 3

Solo una adición a la respuesta de @a.aitboudad:
La función DQL GroupConcat vinculada parece tener un «soporte limitado para GROUP_CONCAT».
Aquí está la versión de soporte completo: La configuración es como él mencionó.

// -------------------------------------------------
// Complete support of GROUP_CONCAT in Doctrine2
// -------------------------------------------------
// Original Article: http://habrahabr.ru/post/181666/
// Automated translation to English: http://sysmagazine.com/posts/181666/
// Original github commit: https://github.com/denisvmedia/DoctrineExtensions/blob/d1caf21cd7c71cc557e60c26e9bf25323a194dd1/lib/DoctrineExtensions/Query/Mysql/GroupConcat.php
/**
* DoctrineExtensions Mysql Function Pack
*
* LICENSE
*
* This source file is subject to the new BSD license that is bundled
* with this package in the file LICENSE.txt.
* If you did not receive a copy of the license and are unable to
* obtain it through the world-wide-web, please send an email
* to [email protected] so I can send you a copy immediately.
*/
namespace DoctrineExtensions/Query/Mysql;
use Doctrine/ORM/Query/AST/Functions/FunctionNode,
Doctrine/ORM/Query/Lexer;
/**
* Full support for:
*
* GROUP_CONCAT([DISTINCT] expr [,expr ...]
* [ORDER BY {unsigned_integer | col_name | expr}
* [ASC | DESC] [,col_name ...]]
* [SEPARATOR str_val])
*
*/
class GroupConcat extends FunctionNode
{
public $isDistinct = false;
public $pathExp = null;
public $separator = null;
public $orderBy = null;
public function parse(/Doctrine/ORM/Query/Parser $parser)
{
$parser->match(Lexer::T_IDENTIFIER);
$parser->match(Lexer::T_OPEN_PARENTHESIS);
$lexer = $parser->getLexer();
if ($lexer->isNextToken(Lexer::T_DISTINCT)) {
$parser->match(Lexer::T_DISTINCT);
$this->isDistinct = true;
}
// first Path Expression is mandatory
$this->pathExp = array();
$this->pathExp[] = $parser->SingleValuedPathExpression();
while ($lexer->isNextToken(Lexer::T_COMMA)) {
$parser->match(Lexer::T_COMMA);
$this->pathExp[] = $parser->StringPrimary();
}
if ($lexer->isNextToken(Lexer::T_ORDER)) {
$this->orderBy = $parser->OrderByClause();
}
if ($lexer->isNextToken(Lexer::T_IDENTIFIER)) {
if (strtolower($lexer->lookahead[''value'']) !== ''separator'') {
$parser->syntaxError(''separator'');
}
$parser->match(Lexer::T_IDENTIFIER);
$this->separator = $parser->StringPrimary();
}
$parser->match(Lexer::T_CLOSE_PARENTHESIS);
}
public function getSql(/Doctrine/ORM/Query/SqlWalker $sqlWalker)
{
$result = ''GROUP_CONCAT('' . ($this->isDistinct ? ''DISTINCT '' : '''');
$fields = array();
foreach ($this->pathExp as $pathExp) {
$fields[] = $pathExp->dispatch($sqlWalker);
}
$result .= sprintf(''%s'', implode('', '', $fields));
if ($this->orderBy) {
$result .= '' '' . $sqlWalker->walkOrderByClause($this->orderBy);
}
if ($this->separator) {
$result .= '' SEPARATOR '' . $sqlWalker->walkStringPrimary($this->separator);
}
$result .= '')'';
return $result;
}
}
// -------------------------------------------------
// Example of usage:
// -------------------------------------------------
$query = $this->createQueryBuilder(''c'')
->select("
c as company,
GroupConcat(b.id, '';'', b.headOffice, '';'', b.city, '';'', s.name
ORDER by b.id
SEPARATOR ''|'') AS branches
")->leftJoin(''c.branches'', ''b'')
->leftJoin(''b.country'', ''s'')
->groupBy(''c.id'')
->setFirstResult(0)
->setMaxResults(10)
->getQuery();
$result = $query->getResult();

Answer 4

Tuve un problema similar. GROUP_CONCAT no permite usar CASE-WHEN dentro. Esta biblioteca solucionó mis problemas, así que quizás sea útil.