Получить данные из соединения

Question

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

Он - моя функция репозитория:

    $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 дает мне некогерентное значение.Это, вероятно, происходит из "плохой" группы. Где-то, я не знаю ..

Edit3:

Работы:

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

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

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

Объекты:

Joueur Entity

<?php

namespace App\Entity;

use Doctrine\Common\Collections\ArrayCollection;
use Doctrine\Common\Collections\Collection;
use Doctrine\ORM\Mapping as ORM;

/**
 * @ORM\Entity(repositoryClass="App\Repository\JoueurRepository")
 */
class Joueur
{
    /**
     * @ORM\Id()
     * @ORM\GeneratedValue()
     * @ORM\Column(type="integer")
     */
    private $id;

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

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

    /**
     * @ORM\OneToMany(targetEntity="App\Entity\Disputed", mappedBy="joueur", orphanRemoval=true)
     */
    private $disputeds;

    /**
     * @ORM\OneToMany(targetEntity="App\Entity\Played", 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;
    }
}

Спорный объект

<?php

namespace App\Entity;

use Doctrine\ORM\Mapping as ORM;

/**
 * @ORM\Entity(repositoryClass="App\Repository\DisputedRepository")
 */
class Disputed
{
    /**
     * @ORM\Id()
     * @ORM\GeneratedValue()
     * @ORM\Column(type="integer")
     */
    private $id;

    /**
     * @ORM\Column(type="integer")
     */
    private $points;

    /**
     * @ORM\Column(type="integer")
     */
    private $position;

    /**
     * @ORM\ManyToOne(targetEntity="App\Entity\Joueur", inversedBy="disputeds")
     * @ORM\JoinColumn(nullable=false)
     */
    private $joueur;

    /**
     * @ORM\ManyToOne(targetEntity="App\Entity\Tournoi", inversedBy="disputeds")
     * @ORM\JoinColumn(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;
    }
}

Tournoi Entity

<?php

namespace App\Entity;

use Doctrine\Common\Collections\ArrayCollection;
use Doctrine\Common\Collections\Collection;
use Doctrine\ORM\Mapping as ORM;

/**
 * @ORM\Entity(repositoryClass="App\Repository\TournoiRepository")
 */
class Tournoi
{
    /**
     * @ORM\Id()
     * @ORM\GeneratedValue()
     * @ORM\Column(type="integer")
     */
    private $id;

    /**
     * @ORM\Column(type="date")
     */
    private $date;

    /**
     * @ORM\OneToMany(targetEntity="App\Entity\Disputed", mappedBy="tournament")
     * @ORM\OrderBy({"points" = "DESC"})
     */
    private $disputeds;

    /**
     * @ORM\OneToMany(targetEntity="App\Entity\Partie", mappedBy="tournoi")
     */
    private $Parties;

    /**
     * @ORM\Column(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;
    }

}