Im using doctrine 2 and zend framework 3. I got an entity "Project" with an OneToOne Relation to "projectdetails". ProjectDetails is split between multiple tables depending on a the Project field "type".
Is there an easy way to tell doctrine which table to use for the projectdetails depending on the type field Value?
You can define "OneToOne" associations for each of the projectdetails tables:
/**
* #OneToOne(targetEntity="ProjectDetails1")
* #JoinColumn(name="project_details_id", referencedColumnName="id")
*/
private $projectDetails1;
/**
* #OneToOne(targetEntity="ProjectDetails2")
* #JoinColumn(name="project_details_id", referencedColumnName="id")
*/
private $projectDetails2;
Add any more projectdetails tables.
Then use a getter function to get the correct relation based on type:
function getProjectDetails() {
if($this->type === 'type1') {
return $this->projectDetails1;
}
elseif($this->type === 'type2') {
return $this->projectDetails2;
}
}
Update: In this case you cannot use doctrine console tool to generate your associations, as it will be impossible to set the foreign key on "project_details_id" to 2 different tables.
To solve this, the column project_details_id of integer type should be created with a migration or you can define a field in the Project entity:
/**
* #ORM\Column(type="integer", nullable=true)
*/
private $projectDetailsId;
generate & run the migration. Finally replace the latter field with the above associations.
Related
I'm working with relationships in Doctrine (using Symfony 5).
What I have is these 2 relations:
User
Availability
User has an ID and has Many Availabilities.
So Entity User has
/**
* #ORM\OneToMany(targetEntity="UserAvailability", mappedBy="user")
*/
private $availability;
and the reverse on Entity Availability.
Availability is a relation with:
id, user_id, day_name, start_time and end_time, that simple.
What I already achieved with ManyToMany and I want to achieve in this case too is:
I need to receive the entire set of availabilities for a User from the client and use it to update the availabilities of my User, so I defined a setAvailability method which receives a Collection of Availability entities and simply does
$this->availabilities = $availabilities.
This works when I add new availabilities but the ones that are on the DB and not in the collection are not dropped when I persist the entity.
The same method works flawlessly with ManyToMany Relationship.
What am I missing?
*** UPDATE **
public function setAvailability($availability): self
{
$this->availability = $availability;
return $this;
}
this same code works when removing relations in ManyToMany relationship but not in ManyToOne, the attribute "availability" is correctly set, but when using persist/flush the availability which was removed is not removed on the DB.
Thanks
Try to set the attributes as in the example from the doctrine documentation below :
<?php
use Doctrine\Common\Collections\ArrayCollection;
/** #Entity */
class User
{
// ...
/**
* One user has many availabilities. This is the inverse side.
* #OneToMany(targetEntity="Availability", mappedBy="user")
*/
private $availabilities;
// ...
public function __construct() {
$this->availabilities = new ArrayCollection();
}
}
/** #Entity */
class Availability
{
// ...
/**
* Many availabilities have one user. This is the owning side.
* #ManyToOne(targetEntity="User", inversedBy="availabilities")
* #JoinColumn(name="user_id", referencedColumnName="id")
*/
private $user;
// ...
}
the attribute mappedBy and inversedBy are necessary for relations
I use APYDataGridBundle for generating a data table.
I have Person entity with a relation (1 gym can have more people):
/**
* #ORM\ManyToOne(targetEntity="App\Entity\Gym", inversedBy="persons")
*/
private $gym;
I generate a grid with a list of people in controller:
public function indexAction(Grid $grid)
{
// Creates a simple grid based on your entity (ORM)
$source = new Entity(Person::class);
$grid->setSource($source);
return $grid->getGridResponse('Person/index.html.twig');
It shows me the grid with all non-relational columns, but the gym column not, because of the relation.
I can't find the solution in doc: https://github.com/APY/APYDataGridBundle/blob/master/Resources/doc/summary.md
Can you help me?
In Person entity:
/**
* #ORM\ManyToOne(targetEntity="App\Entity\Gym", inversedBy="persons")
*
* #GRID\Column(field="gym.id", title="Gym ID")
* #GRID\Column(field="gym.title", title="Gym Title")
*/
private $gym;
By default, self-referencing ManyToMany relationships under Doctrine involve an owning side and an inverse side, as explained in the documentation.
Is there a way to implement a reciprocal association whithout difference between both sides?
Following the example in the docs:
<?php
/** #Entity **/
class User
{
// ...
/**
* #ManyToMany(targetEntity="User")
**/
private $friends;
public function __construct() {
$this->friends = new \Doctrine\Common\Collections\ArrayCollection();
}
// ...
}
So, adding entity1 to entity2s friends implies that entity2 will be in entity1s friends.
There are a number of ways to solve this problem, all depending on what the requirements for the "friends" relation are.
Unidirectional
A simple approach would be to use a unidirectional ManyToMany association, and treat it as if it where a bidirectional one (keeping both sides in sync):
/**
* #Entity
*/
class User
{
/**
* #Id
* #Column(type="integer")
*/
private $id;
/**
* #ManyToMany(targetEntity="User")
* #JoinTable(name="friends",
* joinColumns={#JoinColumn(name="user_a_id", referencedColumnName="id")},
* inverseJoinColumns={#JoinColumn(name="user_b_id", referencedColumnName="id")}
* )
* #var \Doctrine\Common\Collections\ArrayCollection
*/
private $friends;
/**
* Constructor.
*/
public function __construct()
{
$this->friends = new \Doctrine\Common\Collections\ArrayCollection();
}
/**
* #return array
*/
public function getFriends()
{
return $this->friends->toArray();
}
/**
* #param User $user
* #return void
*/
public function addFriend(User $user)
{
if (!$this->friends->contains($user)) {
$this->friends->add($user);
$user->addFriend($this);
}
}
/**
* #param User $user
* #return void
*/
public function removeFriend(User $user)
{
if ($this->friends->contains($user)) {
$this->friends->removeElement($user);
$user->removeFriend($this);
}
}
// ...
}
When you call $userA->addFriend($userB), $userB will be added to the friends-collection in $userA, and $userA will be added to the friends-collection in $userB.
It will also result in 2 records added to the "friends" table (1,2 and 2,1). While this can be seen as duplicate data, it will simplify your code a lot. For example when you need to find all friends of $userA, you can simply do:
SELECT u FROM User u JOIN u.friends f WHERE f.id = :userId
No need to check 2 different properties as you would with a bidirectional association.
Bidirectional
When using a bidirectional association the User entity will have 2 properties, $myFriends and $friendsWithMe for example. You can keep them in sync the same way as described above.
The main difference is that on a database level you'll only have one record representing the relationship (either 1,2 or 2,1). This makes "find all friends" queries a bit more complex because you'll have to check both properties.
You could of course still use 2 records in the database by making sure addFriend() will update both $myFriends and $friendsWithMe (and keep the other side in sync). This will add some complexity in your entities, but queries become a little less complex.
OneToMany / ManyToOne
If you need a system where a user can add a friend, but that friend has to confirm that they are indeed friends, you'll need to store that confirmation in the join-table. You then no longer have a ManyToMany association, but something like User <- OneToMany -> Friendship <- ManyToOne -> User.
You can read my blog-posts on this subject:
Doctrine 2: How to handle join tables with extra columns
More on one-to-many/many-to-one associations in Doctrine 2
I'm having a little problem with a possible multiple relationship in one field in Doctrine 2. For example, i have an Article entity with one field called author. This field is a ManyToOne to the User entity. However, this field can also relate to the Group entity. So, how the hell can i create such schema?
I have considered creating a new entity, called ArticleAuthor which has two fields: user and group, and depending on form input, i populate one of the fields. This way, this table ArticleAuthor holds it's own id and the proper relationship to the correct table. Is this a correct approach?
This is what's referred to as a polymorphic association. Doctrine is able to handle these using Inheritance Mapping
So you'd define your base entity, such as Author, and then you'd have a GroupAuthor and a UserAuthor which both extend this. These both need to be configured as mapped classes on the base Author entity. It's up to you whether you opt for single table or class table inheritance; the end result would be the same.
The last thing to do is to associate the UserAuthor entity to your User entity, and your GroupAuthor to your Group entity.
Then you'd be able to use it somewhat like this:
$author = $article->getAuthor();
if ($author instanceof UserAuthor) {
$user = $author->getUser();
} elseif ($author instanceof GroupAuthor) {
$group = $author->getGroup();
$users = $group->getUsers(); // Not sure if you'd need this?
}
Edit: Example mapping
The 'parent' entity, Author.php
/**
* #ORM\Entity
* #ORM\Table(name="authors")
* #ORM\InheritanceType("JOINED")
* #ORM\DiscriminatorColumn(name="type", type="string")
* #ORM\DiscriminatorMap( {"user" = "UserAuthor", "group" = "GroupAuthor"} )
*/
class Author
{
/**
* #ORM\Id
* #ORM\Column(type="integer")
* #ORM\GeneratedValue(strategy="AUTO")
*/
protected $id;
/* any other shared fields... */
}
Mapped entity, UserAuthor.php
/**
* #ORM\Entity
* #ORM\Table(name="user_authors")
*/
class UserAuthor extends Author
{
/* All columns unique to the UserAuthor entity... */
}
etc
I'm using Doctrine 2.1 where Identity through foreign Entities is supported (Foreign Keys as Identifiers).
http://docs.doctrine-project.org/projects/doctrine-orm/en/2.1/tutorials/composite-primary-keys.html#identity-through-foreign-entities
Is it possible to identity through foreign Entities with a bidirectional relationship? I'm trying but I'm getting the following error when I load my data fixtures:
[PDOException]
SQLSTATE[23000]: Integrity constraint violation: 1452 Cannot add or update a child row: a foreign key constraint fails (table.user, CONSTRAINT FK_187DDE86BF396750 FOREIGN KEY (id) REFERENCES address (user_id))
Here are my entities:
/**
* #Entity
*/
class User
{
/** #Id #Column(type="integer") #GeneratedValue */
private $id;
/** #OneToOne(targetEntity="Address") */
private $address;
}
/**
* #Entity
*/
class Address
{
/** #Id #OneToOne(targetEntity="User") */
private $user;
}
If I remove the reference from User to Address the error disappears!
I would like to be able to do the following:
$address = $user->getAddress();
..but it seems I will have to do:
$address = $entityManager->find('Address', $user->getId());
Is that right? Is there a way to do this?
Update 1:
I would like to be able to set the relationship from either side (bidirectional) but this does not seem possible.
To be honest I'm not sure what the point of the inverse side of the relationship is because "Changes made only to the inverse side of an association are ignored".
Taken from the docs here: http://docs.doctrine-project.org/projects/doctrine-orm/en/2.1/reference/association-mapping.html#owning-side-and-inverse-side
What is the point?
From an Application perspective it seems to make more sense to do:
$user->setAddress($address);
rather than:
$address->setUser($user);
However the first isn't possible possible because:
Making the relationship bidirectional brakes things
The User side has to be the inverse side so $user->setAddress($address); will be ignored anyway!!
Will someone explain this please :)
Matthew
Your problem is not related to "Foreign Keys as Identifiers", but to owning-side of a relation :
In Doctrine, a relation may be bidirectional, but in this case the relation must have an "onwing-side". That means :
on your "entities part" : both your entities have an attribute referencing each other. In your case you have $address in User and $user in Address, and you can use $user->getAddress() and $address->getUser()
on your "sql part" : only one table, the owning-side, have an attribute referencing the other table.
You can inform Doctrin what is the owning side by using "mappedBy" on the non-owning side.
In your situation, with Foreign Key as Identifiers, you have not the choice : the owning-side is the one with Foreign Key.
So, test this :
/**
* #Entity
*/
class User
{
/** #Id #Column(type="integer") #GeneratedValue */
private $id;
/** #OneToOne(targetEntity="Address", mappedBy="user") */
private $address;
}
/**
* #Entity
*/
class Address
{
/** #Id #OneToOne(targetEntity="User", inversedBy="address")) */
private $user;
}
Another important point :
In a bidirectional relation, Doctrine can't automaticaly update the other side when you set the non-owning side. So you have to do it manualy. For not having do think about this each time you create new users and addresses, you can automate the process in your setter :
// in class User :
public function setAddress($address) {
$address->setUser($this); // <= here it is !!!
$this->address = $address;
return $this;
}
// in class Address :
public function setUser($user) {
$this->user = $user;
return $this;
}
Now, you can set address like you want, without bothering about this owning-side-things :
$address = new Addresse();
$address->set...
$user->setAddress($address);
Do you have getter for the address field defined in your User entity?
public function getAddress()
{
return $this->address;
}
Remember that the doctrine returns always collection.