I have a site with many Users and many Designs, each of which was created by one User. Users can also select other Designs as a favorite, and can go to a page that shows their favorites. So, there's a many-to-many relationship between Users and Designs termed "Favorite".
I'm wondering what the best way is to implement this Favorite relationship. I'm only ever looking for Favorites for a particular user, and only on one page. It seems that Doctrine defaults to returning an object with all its related objects, so I'm concerned that by adding this relationship I'll suddenly get a ton of extra objects added to all my Design list API calls.
Advice on how to set this up? I have repositories in place for all entities.
I'll share an implementation I have between Tags and Posts (Posts can have multiple tags, and each tag can be associated with more than one post). I think it's similar enough to get you started. It's super simple to setup:
In the Post entity, I have this:
/**
* #ManyToMany(targetEntity="Tag", inversedBy="posts")
* #JoinTable(name="activity_relationship",
* joinColumns={#JoinColumn(name="object", referencedColumnName="id")},
* inverseJoinColumns={#JoinColumn(name="subject", referencedColumnName="id")}
* )
*/
protected $tags;
In the Tag entity, I have this:
/**
* #ManyToMany(targetEntity="Post", mappedBy="tags")
*/
protected $posts;
There no entity necessary for the joining table.
In the case of posts carrying tags, it's enough for me to just access the tags property since there will always be a small amount, but each tag is likely to have tons and tons of posts, so I want some LIMIT and OFFSET controls over this. For this reason, as Cerad mentioned above, you don't need to use the $posts variable directly, instead I query that separately using dql.
SELECT t
FROM Post p
JOIN p.tags t
<add whatever other stuff you want>
Whichever way you prefer to execute that query, you will probably have a query object from Doctrine, to apply the LIMIT and OFFSET, just do
$query->setMaxResults($limit);
$query->setFirstResult($offset);
Related
In my app, I have a few entities that share some common properties. Example entities:
Image
Video
Event
ForumPost
I want these classes to share some common functions, such as:
Have a list of comments, as well as keep counts of comments
Voting
List of subscribers and subscriber counts
View counts
etc..
I really would not want duplicate these functions for each of the entities above. So... I've been reading about Doctrine inheritance mapping and I've come up with an idea that "Class Table Inheritance" is the most elegant way to solve this. The plan was as follows:
Create a parent Post entity
/**
* #ORM\Entity
* #ORM\InheritanceType("JOINED")
* #ORM\DiscriminatorColumn(name="type", type="string")
*/
class Post
{
protected $likeCount;
protected $subscriberCount;
protected $subscribers;
// ...
}
Have many-to-one relations of likes, comments, votes, etc to Post entity:
class PostLike
{
/**
* #ORM\ManyToOne(targetEntity="Post")
* #ORM\JoinColumn(name="post_id", referencedColumnName="id", nullable=false)
*/
protected $post;
}
Have the Image, Video, etc entity extend Post:
class Video extends Post
{
// Post properties become available here
}
All worked like charm until I looked at the actual queries Doctrine is executing. The problem is: whenever I select a PostLike, doctrine will eager-load Post entity as well, which will in turn join all the child tables as well. So for example, a simple PostLike remove operation triggers a join on 4 tables and will actually join even more tables as my hierarchy grows.
If I have 10 entities extending Post, that would make a join on 10 tables. I am not a fan of premature optimization, but this just doesn't sound like a good plan.
In Doctrine documentation, this behavior is actually mentioned at "6.3.2. Performance impact".
Finally, my question: What are my other options to create reusable tables with doctrine?
I was thinking to do a One-To-One mapping (Post entity being a property of the Video, as well as the Image, etc), but I've read in a few blogs that One-to-One should be avoided with doctrine also for performance reasons.
thanks!
Edit and ansewer to Raphaël Malié regarding Mapped Superclasses:
I am aware that I can use Mapped Superclass and Trait features to avoid code duplication. However, these features allow me to reuse the code but don't allow me to reuse sql tables. Here is an example:
Say I want Image, Video and Event entities to have comments. I can create one Mapped Superclass AbstractComment and then extend it in ImageComment, VideoComment, EventComment. Next, I want to add comment votes. Since I can't reuse same sql table, I will need to create ImageCommentVote, VideoCommentVote, EventCommentVote, etc. Then I want users to be able to report abusive comments. There goes again: ImageCommentReport, VideoCommentReport, EventCommentReport. You get the idea. Every feature that I want to add to comment will need a separate table for each entity like image, video, etc. Lots of tables.
The reasons why I prefer to use centralized approach instead of using traits with many tables:
Easier administration. I can easily search/edit/delete comments of the entire app by sending a query to one table.
The same controller can handle actions for multiple entities, no need to create one abstract and many concrete controllers
Showing user notifications about new comments/likes etc is MUCH easier when actions are centralized.
I am also aware of the drawbacks of such system, but I can live with them for now. My question is how to get Doctrine to do what I want without actually joining everything when not necessary.
In my opinion you are doing wrong. Your entities have nothing in common, except some functionalities, so there is no reason to use single table or class table inheritance.
You should use Traits: http://php.net/manual/en/language.oop5.traits.php
It works with Doctrine. You define one or several traits with some properties / methods with annotations, and then you import these traits in your entities.
You can also use a Mapped Superclass : http://doctrine-orm.readthedocs.org/projects/doctrine-orm/en/latest/reference/inheritance-mapping.html#mapped-superclasses which is quite close to your example, but with a different entity annotation.
After some thought, your decision really depends on the size of your database. If it is big the performance hit of the Class Tabel approach might be unacceptable. But if your tables are small, the performance hit is minor and you can use all the advantages of Class Table Inheritance, which you discussed yourself in your post.
I have a data model that contains persons and companies (amongst other things). I have created a many-to-many relation between them by creating an intermediate object PersonCompanyRelation that contains many-to-one relations to person and companies. The reason for this is that I want to store information about the relation. This works fine
Now I want to do the same but for linking persons to persons. I have again created a relationship object called PersonPersonRelation. The problem I run into is that in the Person object I have to specify what property the object is mapped to in the relationship object, however this is problematic since it will differ from relationship to relationship. Sometimes this will be A, sometimes it will be B. It doesn't matter which one it is but without a logical system I cannot logically retrieve the relations. How do I do this?
the code in PersonPersonRelation
/**
* #ORM\ManyToOne(targetEntity="Person", inversedBy="personPersonRelations")
*/
protected $personA;
/**
* #ORM\ManyToOne(targetEntity="Person", inversedBy="personPersonRelations")
*/
protected $personB;
the code in Person. Note how I need to specify the property in the relation it is mapped to, but from the perspective of Person I do not know whether this will be PersonA or PersonB
/**
* #ORM\OneToMany(targetEntity="PersonPersonRelation", mappedBy="personA")
*/
protected $personPersonRelations;
To clarify as asked below; The case is that I want to store professional relations between people, including details about that relation like how they met (colleagues, friends, family etc) as well as dates etc.
I'm sure that if you specify less generic names, all should be more clear.
Just to make and example, let's say that Person-Person relationship is a relation between Boss and Employee.
So, basically, every person will have two attributes
class Person
{
//other properties
/**
* #ORM\OneToMany(targetEntity="person", mappedBy="employees")
*/
$boss;
/**
* #ORM\ManyToOne(targetEntity="person", inversedBy="boss")
*/
$employees;
}
If I understood correctly the question, in every moment, you can alternatively try to retrieve:
from a boss-person point of view, all employees under him
from a employee-person point of view, its boss
Of course mine is only an example, don't know if you could fit your mind in it to adapt to your specific case. Hope so.
I am trying to understand Symfony2, but there is something that is not making sense to me. I reversed engineered an existing database to produce my entities, so maybe thats the problem.
I have a table called availability_alert, nothing special, a few fields including an id (which is the primary key). This table has no link to anything else.
I then have a second table called booking_class, once again nothing special, but it does have the field $availabilityAlert which links to the availability_alerts tables id.
In essence, an Availability Alert can have one or many Booking Class.
Now in my booking class entity, I have the link
/**
* #var \AlertBundle\Entity\AvailabilityAlert
*
* #ORM\ManyToOne(targetEntity="AlertBundle\Entity\AvailabilityAlert")
* #ORM\JoinColumns({
* #ORM\JoinColumn(name="availability_alert_id", referencedColumnName="id")
* })
*/
private $availabilityAlert;
So this all looks ok. The setter for it though came out like so
public function setAvailabilityAlert(\AlertBundle\Entity\AvailabilityAlert $availabilityAlert = null)
{
$this->availabilityAlert = $availabilityAlert;
return $this;
}
So that appears to take an AvailabilityAlert Object as a parameter, not the AvailabilityAlert id?
So with the above, I am presuming doing something like this in my controller will not work?
$alert = new AvailabilityAlert();
$bookingClass = new BookingClass();
$bookingClass->setAvailabilityAlert($alert->getId());
Could someone give me some advice on whether things are correct here, or if I should be doing something else? Essentially AvailabilityAlert should be a static table, other tables link to this.
Any advice appreciated.
Thanks
Yes this is correct.
In the Doctrine world, you are working with objects, not with integers or strings, when it comes to relationships between Entities.
You can read more about Doctrine 2 relationships here: http://symfony.com/doc/current/book/doctrine.html#entity-relationships-associations
That's correct. You don't use integers, strings. It's because the relationships are given in entity annotations and Doctrine uses them to figure out what is used exactly to reference the one object from the other. This even let you change how objects reference themselves - for example you change the id to a compound primary key in AvailabilityAlert class and your code wouldn't change much except for the annotations.
Using Symfony 2.5+ and Doctrine 2.2+, is it a bad idea to create multiple entities which all have a ManyToMany association with one other single shared entity?
Background
Put on your thinking caps :) I am building 2.0 of our existing CMS in Symfony 2.5 where we have many different "Content Types", e.g. Article, Profile, Map, Image, Video, Document, etc. When users create a new piece of content (based on one of these content types) they may choose images to associate with that content (yes the image is a content type as well).
The content types are really a CMS construct for making it easier for people to add content to the site. Each content type has a controller which determines what entity the content type maps to. For the most part, each content type has it's own entity for persisting the data. The image, document and video content types are a little different in that they all map to a shared media entity (so that I can easily manage the cloud storage for all these files from one table, since they are all essentially "media" and the content type distinction is largely just UI).
So my plan is to make a bidirectional ManyToMany association between each content type entity (e.g. Articles) and the Media entity. So that when someone selects an image to associate with an article, the association is mapped in a join table article_media. This will allow us to find all content where an image is in use, so that we don't delete an active image (or at least make sure they explicitly agree).
For the sake of simplification, we'll just map one $media association, instead of separate ones for images, documents and videos, which could also be associated with an article (I think we will handle this with a controller that extracts the full Media list for separate form inputs and then merges them back into the Media array for persistence, so that we don't have to make multiple calls to the database).
This requires that the Article entity have an association like this:
/**
*
* #ORM\ManyToMany(targetEntity="\Gutensite\MediaBundle\Entity\Media", inversedBy="version", cascade={"persist", "remove"})
* #ORM\JoinTable(name="article_media")
*/
protected $media;
And the Media Entity will have an inverse association like this:
/**
* #ORM\ManyToMany(targetEntity="\Gutensite\ArticleBundle\Entity\Article", mappedBy=“media”)
*/
protected $article;
But if I have multiple content types, each entity will need this as well, and so soon the Media entity will have a lot of additional associations:
// Article Association plus additional ones for each entity...
/**
* #ORM\ManyToMany(targetEntity="\Gutensite\ProfileBundle\Entity\Profile", mappedBy=“media”)
*/
protected $profile;
/**
* This is self referential since a video may need to specify a thumbnail image...
* I'm not sure yet how best to do this, but it will be necessary.
* #ORM\ManyToMany(targetEntity="\Gutensite\MediaBundle\Entity\Media", mappedBy=“media”)
*/
protected $media;
// ...etc...
This would end up creating unique join tables for every content type, e.g. article_media, profile_media, media_media. That is probably nice for keeping these tables smaller.
Cons
The downside of this is that everytime we create a new content type, we have to add an additional association on the Media entity. If we start to get 10+ content types, that's a lot of associations. Is that a problem?
Any other problems?
Alternatives
Is it possible to make the join table have a entity field that indicates the content type, so that we only have one join table for all the different content types? For example:
id | entity | entityId | MediaId
If so how would you define in Doctrine this extra entity distinction field to prevent collisions with entityId for different content types?
Other Considerations
Later when we allow third party developers to create their own content types, this solution will no longer work because we don't want there to be hundreds of associations. So in this case, we thought that we would create an intermediate entity like MediaMap. Each entity will have a OneToMany relationship with MediaMap (uni-directional so that we only have to define the inverese side on MediaMap back to every content type). And then MediaMap will have a ManyToMany relationship with Media with a join table in between. That way Media will only maintain one association to the MediaMap.
This seems a bit cumbersome, and introduces another database query into the sequence, which I don't at all like.
Solutions
So is there a better way to do this?
Should we just maintain our own MediaMap table manually, and not rely on Doctrine entity association?
I think your first alternative is the best answer. You will have to do a manual lookup to get the original entity from the media, or to get all the media used by an entity, but you can write that as a utility class pretty quickly. This method will work no matter how many different content types you add in the future.
Your table would look like this
id | entity class (ie Biz/CMS/Article) | entityId | mediaId
There are ways to make this even more abstract that I am using on a project right now, but this would be a good start for your project.
Just out of curiosity, why did you choose to create your own CMS instead of using one of the existing options?
I want to do mapping that does this:
User can own multiple Games. Games can have multiple owners.
I have id column in game table and game and user columns in ownership table. How I can connect these fields? I want to have game and user fields in ownership related to user and game tables.
I tried OneToMany and ManyToMany, but the first one results in generating additional columns. I don't want to insert anything in game table.
--edit--
My #ManyToMany code:
/**
* #ORM\ManyToMany(targetEntity="Ownership")
* #ORM\JoinTable(name="ownership",
* joinColumns={JoinColumn(name="user", referencedColumnName="id")},
* inverseJoinColumns={JoinColumn(name="game", referencedColumnName="id")}
* )
*/
It causes an error in Symfony's command line:
[Doctrine\Common\Annotations\AnnotationException]
[Semantical Error] Couldn't find constant JoinColumn, property GameShelf\Us
ersBundle\Entity\User::$ownership.
Of course you need many to many relations if, like you said:
User can own multiple Games. Games can have multiple owners.
The Doctrine should create third table (which could contains only two foreign keys: game_id and ownership_id).
The error is caused because Doctrine dosen't know what JoinColumn is. You just did wrong annotation because you forgot (again! ;)) precede JoinColumn with `#ORM. The right annotation should look like this:
/**
* #ORM\ManyToMany(targetEntity="Ownership")
* #ORM\JoinTable(name="ownership",
* joinColumns={#ORM\JoinColumn(name="user", referencedColumnName="id")},
* inverseJoinColumns={#ORM\JoinColumn(name="game", referencedColumnName="id")}
* )
*/
Sounds like you need to introduce a new entity (something like OwnedGame) that holds the connection between a Game and an Owner (and possibly its own properties like when it was bought and such).
Then OwnedGame would be ManyToOne with Game and with Owner, and neither Game nor Owner would need to include a new column.
Your description of what you want doesn't fit at all.
On the one hand you want to have a relation between only Users and Games, and only between Games and Owners.
But on the other hand you say that Users and Owners are related in some way, but Games and Users aren't.
You should read through
http://docs.doctrine-project.org/en/2.0.x/reference/association-mapping.html#many-to-many-unidirectional
and try to find what you really need.
I would recommend a ManyToMany relation with a join table. Thus you don't have to deal with additional fields in your tables