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.