Блог

Я здесь какое-то время борюсь. Мне нужно отобразить таблицу с некоторыми данными. Я должен получить эти данные от разных сущностей. Я не могу правильно получить одно значение, так как мое соединение, похоже, прерывается для исправления данных.

Он-моя функция хранилища :

     $qb->select('j AS jou')
        ->innerJoin('j.playeds', 'p')
        ->addSelect('SUM(p.points) AS sumpoints')
        ->addSelect('SUM(p.max) AS summax')
        ->addSelect('COUNT(p.partie) as sumparties')
        ->addSelect('SUM(CASE WHEN p.position = 1 THEN 1 ELSE 0 END) AS sumwins')
        ->groupBy('j.id')
        ->orderBy('sumpoints', 'DESC')
        ->innerJoin('j.disputeds','d')
        ->addSelect('COUNT(d.id) AS nbDisputeds')
        ->addGroupBy('d.id');
 

На данный момент все работает, кроме этого :

 ->addSelect('COUNT(d.id) AS nbDisputeds')
 

Отображаемые данные неверны, вероятно, из-за моей группы.
Это должно дать мне количество «спорных» случаев, которые у меня есть для каждого «j», но результат неверен.

Любая помощь приветствуется 🙂

Edit2: Я попытался из другого репозитория, но получил тот же результат, проблема просто сообщается о других атрибутах :

     $qb->select('d')
        ->innerJoin('d.joueur', 'j')
        ->addSelect('j.nom, j.prenom')
        ->addSelect('SUM(d.points) AS sumpoints')
        ->addSelect('COUNT(d) as sumparties')
        ->addSelect('SUM(CASE WHEN d.position = 1 THEN 1 ELSE 0 END) AS sumwins')
        ->GroupBy('d.joueur')
        ->leftJoin('j.playeds','p')
        ->addSelect('SUM(p.max) AS summax')
        ->addGroupBy('j.id')
        ->addGroupBy('p.partie');
 

В этом случае я получаю правильные значения для sumpoints, sumparties, sumwins, но summax дает мне некогерентное значение. Это, вероятно, исходит от «плохой» группы где-то, я не знаю..

Правка3 :

Работает :

 SELECT SUM(d0_.points) AS points, d0_.position AS position, j1_.nom AS nom, j1_.prenom AS prenom FROM disputed d0_ INNER JOIN joueur j1_ ON d0_.joueur_id = j1_.id GROUP BY d0_.joueur_id
 

Но у меня нет «максимального» значения. Таблица «сыграно» также не присоединяется

Не Работает :

 SELECT SUM(d0_.points) AS points, j1_.nom AS nom, j1_.prenom AS prenom, SUM(p2_.max) AS maxs FROM disputed d0_ INNER JOIN joueur j1_ ON d0_.joueur_id = j1_.id INNER JOIN played p2_ ON j1_.id = p2_.joueur_id GROUP BY p2_.joueur_id
 

Таблица «сыграно» объединена, «очки» и «макс» не являются правильными значениями

Схема базы данных :

Entities :

Joueur Entity

 <?php

namespace AppEntity;

use DoctrineCommonCollectionsArrayCollection;
use DoctrineCommonCollectionsCollection;
use DoctrineORMMapping as ORM;

/**
 * @ORMEntity(repositoryClass="AppRepositoryJoueurRepository")
 */
class Joueur
{
    /**
     * @ORMId()
     * @ORMGeneratedValue()
     * @ORMColumn(type="integer")
     */
    private $id;

    /**
     * @ORMColumn(type="string", length=100)
     */
    private $nom;

    /**
     * @ORMColumn(type="string", length=100)
     */
    private $prenom;

    /**
     * @ORMOneToMany(targetEntity="AppEntityDisputed", mappedBy="joueur", orphanRemoval=true)
     */
    private $disputeds;

    /**
     * @ORMOneToMany(targetEntity="AppEntityPlayed", mappedBy="joueur")
     */
    private $playeds;

    public function __construct()
    {
        $this->disputeds = new ArrayCollection();
        $this->playeds = new ArrayCollection();
    }


    public function getId(): ?int
    {
        return $this->id;
    }

    public function getNom(): ?string
    {
        return $this->nom;
    }

    public function setNom(string $nom): self
    {
        $this->nom = $nom;

        return $this;
    }

    public function getPrenom(): ?string
    {
        return $this->prenom;
    }

    public function setPrenom(string $prenom): self
    {
        $this->prenom = $prenom;

        return $this;
    }

    /**
     * @return Collection|Disputed[]
     */
    public function getDisputeds(): Collection
    {
        return $this->disputeds;
    }

    public function addDisputed(Disputed $disputed): self
    {
        if (!$this->disputeds->contains($disputed)) {
            $this->disputeds[] = $disputed;
            $disputed->setJoueur($this);
        }

        return $this;
    }

    public function removeDisputed(Disputed $disputed): self
    {
        if ($this->disputeds->contains($disputed)) {
            $this->disputeds->removeElement($disputed);
            // set the owning side to null (unless already changed)
            if ($disputed->getJoueur() === $this) {
                $disputed->setJoueur(null);
            }
        }

        return $this;
    }

    public function __toString()
{
    $string = $this->getPrenom().' '.$this->getNom();
    return $string;
}

    /**
     * @return Collection|Played[]
     */
    public function getPlayeds(): Collection
    {
        return $this->playeds;
    }

    public function addPlayed(Played $played): self
    {
        if (!$this->playeds->contains($played)) {
            $this->playeds[] = $played;
            $played->setJoueur($this);
        }

        return $this;
    }

    public function removePlayed(Played $played): self
    {
        if ($this->playeds->contains($played)) {
            $this->playeds->removeElement($played);
            // set the owning side to null (unless already changed)
            if ($played->getJoueur() === $this) {
                $played->setJoueur(null);
            }
        }

        return $this;
    }
}
 

Disputed Entity

 <?php

namespace AppEntity;

use DoctrineORMMapping as ORM;

/**
 * @ORMEntity(repositoryClass="AppRepositoryDisputedRepository")
 */
class Disputed
{
    /**
     * @ORMId()
     * @ORMGeneratedValue()
     * @ORMColumn(type="integer")
     */
    private $id;

    /**
     * @ORMColumn(type="integer")
     */
    private $points;

    /**
     * @ORMColumn(type="integer")
     */
    private $position;

    /**
     * @ORMManyToOne(targetEntity="AppEntityJoueur", inversedBy="disputeds")
     * @ORMJoinColumn(nullable=false)
     */
    private $joueur;

    /**
     * @ORMManyToOne(targetEntity="AppEntityTournoi", inversedBy="disputeds")
     * @ORMJoinColumn(nullable=false)
     */
    private $tournament;

    public function getId(): ?int
    {
        return $this->id;
    }

    public function getPoints(): ?int
    {
        return $this->points;
    }

    public function setPoints(int $points): self
    {
        $this->points = $points;

        return $this;
    }

    public function getPosition(): ?int
    {
        return $this->position;
    }

    public function setPosition(int $position): self
    {
        $this->position = $position;

        return $this;
    }

    public function getJoueur(): ?Joueur
    {
        return $this->joueur;
    }

    public function setJoueur(?Joueur $joueur): self
    {
        $this->joueur = $joueur;

        return $this;
    }

    public function getTournament(): ?Tournoi
    {
        return $this->tournament;
    }

    public function setTournament(?Tournoi $tournament): self
    {
        $this->tournament = $tournament;

        return $this;
    }
}
 

Турной Сущности

 <?php

namespace AppEntity;

use DoctrineCommonCollectionsArrayCollection;
use DoctrineCommonCollectionsCollection;
use DoctrineORMMapping as ORM;

/**
 * @ORMEntity(repositoryClass="AppRepositoryTournoiRepository")
 */
class Tournoi
{
    /**
     * @ORMId()
     * @ORMGeneratedValue()
     * @ORMColumn(type="integer")
     */
    private $id;

    /**
     * @ORMColumn(type="date")
     */
    private $date;

    /**
     * @ORMOneToMany(targetEntity="AppEntityDisputed", mappedBy="tournament")
     * @ORMOrderBy({"points" = "DESC"})
     */
    private $disputeds;

    /**
     * @ORMOneToMany(targetEntity="AppEntityPartie", mappedBy="tournoi")
     */
    private $Parties;

    /**
     * @ORMColumn(type="integer", nullable=true)
     */
    private $nbPlayers;

    public function __construct()
    {
        $this->disputeds = new ArrayCollection();
        $this->parties = new ArrayCollection();
        $this->Parties = new ArrayCollection();
    }

    public function getId(): ?int
    {
        return $this->id;
    }

    public function getDate(): ?DateTimeInterface
    {
        return $this->date;
    }

    public function setDate(DateTimeInterface $date): self
    {
        $this->date = $date;

        return $this;
    }

    /**
     * @return Collection|Disputed[]
     */
    public function getDisputeds(): Collection
    {
        return $this->disputeds;
    }

    public function addDisputed(Disputed $disputed): self
    {
        if (!$this->disputeds->contains($disputed)) {
            $this->disputeds[] = $disputed;
            $disputed->setTournament($this);
        }

        return $this;
    }

    public function removeDisputed(Disputed $disputed): self
    {
        if ($this->disputeds->contains($disputed)) {
            $this->disputeds->removeElement($disputed);
            // set the owning side to null (unless already changed)
            if ($disputed->getTournament() === $this) {
                $disputed->setTournament(null);
            }
        }

        return $this;
    }

    /**
     * @return Collection|Partie[]
     */
    public function getParties(): Collection
    {
        return $this->parties;
    }

    public function addPartie(Partie $partie): self
    {
        if (!$this->parties->contains($partie)) {
            $this->parties[] = $partie;
            $partie->setTournoi($this);
        }

        return $this;
    }

    public function removePartie(Partie $partie): self
    {
        if ($this->parties->contains($partie)) {
            $this->parties->removeElement($partie);
            // set the owning side to null (unless already changed)
            if ($partie->getTournoi() === $this) {
                $partie->setTournoi(null);
            }
        }

        return $this;
    }

    public function getNbPlayers(): ?int
    {
        return $this->nbPlayers;
    }

    public function setNbPlayers(?int $nbPlayers): self
    {
        $this->nbPlayers = $nbPlayers;

        return $this;
    }

    public function addParty(Partie $party): self
    {
        if (!$this->Parties->contains($party)) {
            $this->Parties[] = $party;
            $party->setTournoi($this);
        }

        return $this;
    }

    public function removeParty(Partie $party): self
    {
        if ($this->Parties->contains($party)) {
            $this->Parties->removeElement($party);
            // set the owning side to null (unless already changed)
            if ($party->getTournoi() === $this) {
                $party->setTournoi(null);
            }
        }

        return $this;
    }

}