Discussion :

[FadeToBlack]

Bonjour à tous,

J'ai besoin d'un conseil, mais surtout d'une confirmation pour la structure de ma base de données.

Le thème de la base est plus ou moins un arbre généalogique. Du coup, j'ai une entité "Personne".

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
 
namespace Rom\BaseBundle\Entity;
 
use Doctrine\Common\Collections\ArrayCollection;
 
use Doctrine\ORM\Mapping as ORM;
 
/**
 * Gene\BaseBundle\Entity\Personne
 *
 * @ORM\Table()
 * @ORM\Entity(repositoryClass="Gene\BaseBundle\Entity\PersonneRepository")
 */
class Personne
{
    /**
     * @var string $nom
     *
     * @ORM\Column(name="nom", type="string", length=25)
     */
    private $nom;
 
    /**
     * @var string $prenom
     *
     * @ORM\Column(name="prenom", type="string", length=25)
     */
    private $prenom;
 
      //etc.....
}

La problématique c'est :

1) une personne peut être "mariée" à une autre personne d'où relation OneToOne réflexive.

2) Une personne peut avoir plusieurs enfants (Personnes) et un enfant-Personne à deux Parents-Personnes. On a donc une relation réflexive ManyToMany.

ce qui me donne le code suivant :
// Pour la situation maritale

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
    /**
     *@ORM\OneToOne(targetEntity="Personne", mappedBy="indiv", cascade={"persist" , "remove"})
     *@ORM\joinColumn(onDelete="set null", nullable=true)
     */
    private $conjoint;
 
    /**
     *@ORM\OneToOne(targetEntity="Personne", inversedBy="conjoint", cascade={"persist" , "remove"})
     *@ORM\joinColumn(onDelete="set null", nullable=true)
     */
    private $indiv;

Pour les enfants_parents :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
 
     /**
     *@ORM\ManyToMany(targetEntity="Personne" mappedBy="parents", cascade={"persist"})
     *@ORM\joinColumn(nullable=true)
     */
    private $enfants;
 
    /**
     *@ORM\ManyToMany(targetEntity="Personne" inversedBy="enfants", cascade={"persist"})
     *@ORM\joinColumn(nullable=true)
     */
    private $parents;
 
 
    public function(){
        $this->parents = new arrayCollection();
        $this->enfants = new arrayCollection();
 
}

Est-ce que cette structure vous parait correcte ?

Au final dans le formulaire, je dois pouvoir :
1) Créer Conjoint2 et sélectionner le nom et prenom du conjoint1 déjà enregistré. Ce qui met à jour la ligne du conjoint1 avec référence à conjoint2.

2) créer parents1 et créer ses enfants en même temps. Ce qui implique que :
- les Enfants-personnes créés apparaissent en temps que personnes
- les références aux parents apparaissent aussi suivant la situation maritale
- les enfants apparaissent dans la "fiche"' parents2.

Je ne sais pas si je suis très claire. Et d'ailleurs, j'ai un peu de mal à voir la tête de mon(mes) controllers. Mais pour lemoment, j'aimerais avoir des Entites et une base fonctionnelles, et je m'arrache déjà suffisamment les cheveux...........

A votre avis est-ce que cela irait ?
Merci pour votre aide

[FadeToBlack]

Pour ce qui est de la relation OneToOne des "mariés", je ne sais pas si cela fonctionne.

Mais pour les enfants, cela n'a pas l'air de faire ce que je veux.

En faisant un

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

php app/console doctrine:schema:update -- force

je me retrouve, dans MySql, avec une table Personne_Personne (Table de liaison, là c'est bon). Mais elle n'a qu'un champ Personne_id, alors qu'il devrait y en avoir deux Personne_ID, et Personne_ID2, tous les deux en clefs primaires

[arnooo999]

Bonjour,

pour la relation "conjoint", tu n'as pas besoin d'avoir 2 attributs 'conjoint' et 'indiv':
cf http://docs.doctrine-project.org/pro...lf-referencing

Sur le fond, je ne sais pas si c'est vraiment adapté car il n'y a pas de dimension de temporalité.
Si c'est une application à but généalogique, tu ne peux pas par exemple garder les différents mariages d'une personne.
Peu-être faut t'il créer une
entité "Union"
dateUnion
typeUnion (mariage, concubinage,...)
hasOne conjoint1 (Personne)
hasOne conjoint2 (Personne)
hasMany naissances (Personne)
et
entité Personne
hasMany unions (Union) ->liste des Unions, permet donc de retrouver le(s) conjoint(s)
hasOne néDe (Union) -> permet de remonter aux parents

[FadeToBlack]

Salut arnooo999,

quand je dis base "généalogique" c'est un peu exagéré, mais c'était pour illustrer le propos.

En fait on part du principe que l'on a zéro ou un seul conjoint. Mais ton idée n'est pas mauvaise sauf que je n'ai pas besoin de la date ni du type d'union, pour le moment....... et sans doute pas après.

Concernant les has....., j'avoue que mon apprentissage n'est pas encore allé assez loin. Qu'entends tu par là ?

On aurait un truc du genre ???? :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
 
 /**
     * @ManyToMany(targetEntity="Personne", mappedBy="mesEnfants")
     **/
    private $leParents;
 
    /**
     * @ManyToMany(targetEntity="Personne", inversedBy="$leParents")
     * @JoinTable(name="enfants",
     *      joinColumns={@JoinColumn(name="Personne_id", referencedColumnName="id")},
     *      inverseJoinColumns={@JoinColumn(name="leParents_id", referencedColumnName="id")}
     *      )
     **/
    private $mesEnfants;
 
    public function __construct() {
    	$this->leParents = new \Doctrine\Common\Collections\ArrayCollection();
    	$this->mesEnfants = new \Doctrine\Common\Collections\ArrayCollection();
    }

[arnooo999]

Concernant la relation Parent-enfants en ManyToMany, l'annotation JoinColumn ne semble pas nécessaire (voire pas cohérente).
Enleves là et regénère le shéma,
Tu devrais avoir une table de liaison avec des colonnes child_id et parent_id.
Si ce n'est toujours pas bon, inspire toi de l'exemple de la doc:
http://docs.doctrine-project.org/en/...e/association-
mapping.html#many-to-many-self-referencing
(NB: Avec symfony il faut remplacer les @ par @ORM\ )

Concernant les has....., j'avoue que mon apprentissage n'est pas encore allé assez loin. Qu'entends tu par là ?

Ce n'est qu'une manière personelle de procéder pour expliciter les relations entre entité avant de passer à la phase codage/mapping, (je trouve que les 0,n en UML ou en MCD ne sont pas assez explicites).
Union has one conjoint1
Personne has many Union
-> donc l'entité Personne a un attribut $unions en OneToMany vers l'entité Union

[edit]
nos messages se sont croisés, mais comme dit plus haut il faut remplacer les @ par des @ORM lorsque l'on est sous SF

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
 
 /**
     * @ORM\ManyToMany(targetEntity="Personne", mappedBy="enfants")
     **/
    private $parents;
 
    /**
     * @ORM\ManyToMany(targetEntity="Personne", inversedBy="parents")
     * @ORM\JoinTable(name="enfants",
     *      joinColumns={@ORM\JoinColumn(name="enfant_id", referencedColumnName="id")},
     *      inverseJoinColumns={@ORM\JoinColumn(name="parent_id", referencedColumnName="id")}
     *      )
     **/
    private $enfants;
 
    public function __construct() {
    	$this->parents = new \Doctrine\Common\Collections\ArrayCollection();
    	$this->enfants = new \Doctrine\Common\Collections\ArrayCollection();
    }

[FadeToBlack]

c'est en m'inspirant de la doc de doctrine que j'ai fait cela.

j'essaie et te dis après