I need to query a number of issues in a table of a issue tracking system limiting this query by a complicated condition:
Issues (Entity) are grouped into categories (another Entity). Persons (Entity) are members of multiple roles (fourth Entity), this is one ManyToMany relationship. And finally, a role can have access on one or many categories, this is the second ManyToMany relationship.
<?php
/**
* #Entity
* #Table(name="issue")
*/
class Issue
{
/**
* #ManyToOne(targetEntity="Category", fetch="EAGER")
* #JoinColumn(name="category", referencedColumnName="id", onDelete="RESTRICT", nullable=false)
*/
private $category;
…
}
/**
* #Entity
* #Table(name="category")
*/
class Category
{
/**
* #ManyToMany(targetEntity="Role", mappedBy="categories")
*/
private $roles;
…
}
/**
* #Entity
* #Table(name="role")
*/
class Role
{
/**
* #ManyToMany(targetEntity="Person", mappedBy="roles")
*/
private $persons;
/**
* #ManyToMany(targetEntity="Category", inversedBy="roles")
* #JoinTable(name="role_has_access_on_category",
* joinColumns={#JoinColumn(name="role_id", referencedColumnName="id")},
* inverseJoinColumns={#JoinColumn(name="category_id", referencedColumnName="id")}
* )
*/
private $categories;
…
}
/**
* #Entity
* #Table(name="person")
*/
class Person
{
/**
* #ManyToMany(targetEntity="Role", inversedBy="persons")
* #JoinTable(name="person_is_member_of_role",
* joinColumns={#JoinColumn(name="person_id", referencedColumnName="id")},
* inverseJoinColumns={#JoinColumn(name="role_id", referencedColumnName="id")})
*/
private $roles;
…
}
I have left all fields except the relationship ones away, of course there are primary keys and a lot more columns there…
I want to retrieve all issues that belong to categories to which a person with a given primary key has access via the roles it is member of.
At first I just started to experiment how to query ManyToMany relationships, so the code below does not really resemble my target.
I have finally found out how I can get the query to retrieve the other side of one ManyToMany relationship, so I can already get the roles a person belongs to. But this query does not fetch the categories a role has access to.
$qb = $this->em->createQueryBuilder();
$qb->select('person')
->addSelect('role')
->addSelect('category')
->from('Person', 'person')
->innerJoin('person.roles', 'role')
->innerJoin('role.categories', 'category');
$result = $qb->getQuery()->getResult();
$result contains the persons data with all associated roles, but a blank array of categories instead of the entities. The final query would start from the issue side of course, but for now I would only like to get through to the other side…
So now I wonder whether I have to take all the roles and loop through them to fetch all categories. Is there no easier Doctrine way?
By the way, that's the SQL I would use:
SELECT issue.* FROM person AS p, person_is_member_of_role AS pim, role_has_access_on_category AS rha, issue
WHERE
p.id = pim.person_id AND
pim.role_id = rha.role_id AND
rha.category_id = todo.category AND
p.id = ?;
I hope this all makes it clear somehow, otherwise I will revise my question…
You are over-complicating it by trying to put all join conditions in the WHERE clause.
If I understood the question correctly, the query looks like this:
SELECT
i
FROM
Issue i
JOIN
i.category c
JOIN
c.roles r
JOIN
r.persons p
WHERE
p.id = :personId
Translated in QueryBuilder API:
$qb = $entityManager->createQueryBuilder();
$issues = $qb
->select('i')
->from('Issue', 'i')
->innerJoin('i.category', 'c')
->innerJoin('c.roles', 'r')
->innerJoin('r.persons', 'p')
->andWhere($qb->expr()->eq('p.id', ':personId'))
->setParameter('personId', $personId)
->getQuery()
->getResult();
Also, consider avoiding the QueryBuilder if there's no good reason to use it. After all, it's just a string builder.
Related
I have 3 entities:
client
company
contact
client entity can have multiple contact entities, also company can have multiple contact entities.
Contact entity looks like this:
class ContactDetail
{
use Timestampable;
use Bleamable;
CONST TYPE_EMAIL = 'EMAIL';
CONST TYPE_PHONE = 'PHONE';
CONST TYPE_FAX = 'FAX';
CONST TYPE_MOBILE = 'MOBILE';
/**
* #ORM\Id
* #ORM\Column(type="integer", options={"unsigned"=true})
* #ORM\GeneratedValue(strategy="AUTO")
* #Expose
* #JMS\Groups({"ROLE_USER","ROLE_ADMIN"})
*/
private $id;
/**
* #var string
* #Assert\NotNull()
* #ORM\Column(type="string", columnDefinition="ENUM('EMAIL', 'PHONE', 'FAX', 'MOBILE')", nullable=false)
* #Expose
* #JMS\Groups({"ROLE_USER","ROLE_ADMIN"})
*/
private $type;
/**
* #var string
* #ORM\Column(type="string", nullable=false)
* #Assert\NotBlank(message="Please enter proper value")
* #Expose
* #JMS\Groups({"ROLE_USER","ROLE_ADMIN"})
*/
private $value;
(...)
}
The question is:
Should I do it in this way:
client entity:
/**
* #ORM\OneToMany(targetEntity="CoreBundle\Entity\ContactDetail", mappedBy="client")
* #ORM\JoinColumn(name="contactDetail", referencedColumnName="id")
*/
protected $contactDetails;
company entity:
/**
* #ORM\OneToMany(targetEntity="CoreBundle\Entity\ContactDetail", mappedBy="company")
* #ORM\JoinColumn(name="contactDetail", referencedColumnName="id")
*/
protected $contactDetails;
Which will creates two additional columns (company and client) in the contact entity or should I do it in some other way?
Ex.
Create two columns: entityName and entityId and bind it somehow to client and company?
If second is proper way, please tell me how to achieve this.
Consider to solve this using a unidirectional map from Client and Company to Contact. In this case is a little trick because there is no way to create a OneToMany relationship without using mappedBy and map this bidirectional so Contact need to have theses two columns one for client other for company.
Looking after doctrine documentation, the solution may be a little odd here. It's use a ManyToMany relationship unidirectional from Client and Company. And you don't need to have foreign keys in Client nor Company netheir in Contact. But will have to create a new table to intermediate this relationship.
The simple way to go is create a table for each relationship on table "Client_Contact" and other "Company_Contact" each on with to columns, one for client_id/company_id other for contact_id.col
I'm implementing a new application on top of an existing database. The existing database is being used by a mobile application and because the mobile app is being developed by a different team I am not allowed to change the structure of existing tables.
The existing database has a user table and for my own application's users I created my own table and Doctrine entity called PortalUser (table portal_user).
The PortalUser entity is going to have a OneToMany association called $children which refers to the existing User entity. In other words each PortalUser has zero or more child User entities.
The most natural way to implement this is to have something like this (simplified):
User (the existing entity):
class User
{
/**
* #var integer
*
* #ORM\Column(name="id", type="integer", nullable=false)
* #ORM\Id
* #ORM\GeneratedValue(strategy="IDENTITY")
*/
private $id;
/**
* #var PortalUser
*
* #ORM\ManyToOne(targetEntity="PortalUser", inversedBy="children")
* #ORM\JoinColumn(name="parent_id", referencedColumnName="id")
*/
private $parent;
}
PortalUser entity:
class PortalUser
{
/**
* #var int
* #ORM\Id
* #ORM\Column(type="integer")
* #ORM\GeneratedValue(strategy="AUTO")
*/
private $id;
/**
* #var array
* #ORM\OneToMany(targetEntity="User", mappedBy="parent")
*/
protected $children;
}
This will create a new column "parent_id" in the existing user table which isn't allowed. So would it be possible to get a separate link table with parent_id and child_id columns, equivalent to a regular ManyToMany link table? And if so what annotations would result in such a structure?
Okay this is embarrassing. Turns out it's in the Doctrine documentation:
A unidirectional one-to-many association can be mapped through a join
table. From Doctrine’s point of view, it is simply mapped as a
unidirectional many-to-many whereby a unique constraint on one of the
join columns enforces the one-to-many cardinality.
Doctrine manual
I'm trying that a self-referenced entity stop from querying the database everytime I fetch the children of one object, and get the whole tree in one query.
This is my entity:
/**
* #ORM\Entity(repositoryClass="ExampleRep")
* #ORM\Table(name="example_table")
*/
class Example {
/**
* #ORM\Id
* #ORM\Column(type="integer", nullable=false);
* #ORM\GeneratedValue(strategy="AUTO")
*/
protected $id;
/**
* #ORM\ManyToOne(targetEntity="Example", inversedBy="children")
* #ORM\JoinColumn(name="parent", referencedColumnName="id", onDelete="SET NULL")
*/
private $parent = null;
/**
* #ORM\OneToMany(targetEntity="Example", mappedBy="parent")
*/
private $children;
}
And i'm calling my date using queryBuilder like:
$query = $this->createQueryBuilder('e');
$query->orderBy('e.parent', 'ASC');
$example_data = $query->getQuery()->getResult();
When I cycle my example_data and call getChildren, another query is made, even if that same object, was already called in the query.
I've followed the example here: Doctrine - self-referencing entity - disable fetching of children but when i do it, my getChildren returns nothing.
Is there a way to fetch my data without overloading the database with multiple requests?
If you know the depth of your tree, you can just do a custom dql query and do:
return $this->createQueryBuilder('example')
->addSelect('children')
->leftJoin('example.children', 'children')
->addSelect('subChildren')
->leftJoin('children.children', 'subChildren')
;
Otherwise, and as stated here, you can generate a flat resultset, and then construct the tree from it.
I made this kind of implementation using materialized paths, but nothing forbids you to do it with foreign keys comparison:
https://github.com/KnpLabs/DoctrineBehaviors/blob/master/src/Knp/DoctrineBehaviors/ORM/Tree/Tree.php#L119
https://github.com/KnpLabs/DoctrineBehaviors/blob/master/src/Knp/DoctrineBehaviors/Model/Tree/Node.php#L219
I have a table product, the items in these table are referenced in tables such as cart_item and order_item as well as shipping_item etc.
All these references are optional (the product_id is set to nullable in those tables).
I need to have a way to delete a product and still keeping the other tables's records. One way I can think of is to go into all those tables, set the product_id to null, then go back to the product table to delete. However, since I may not know all the tables that are referencing to product (many other bundles can have entities that are referencing to this product), is there a way that I can know all these association to loop through and set null?
(Or perhaps there is a better way?)
PS: the idea that this is a shopping cart and the owner may want to remove expired products to clean up but for ordered, shipped items they still need to keep records.
Edit1:
This is the definition of the product reference in the OrderItem entity:
/**
* #var \Product
*
* #ORM\ManyToOne(targetEntity="Product")
* #ORM\JoinColumns({
* #ORM\JoinColumn(name="product_id", referencedColumnName="id")
* })
*/
private $product;
The error I'm getting:
PDOException: SQLSTATE[23000]: Integrity constraint violation: 1451
Cannot delete or update a parent row: a foreign key constraint fails
(test.order_item, C ONSTRAINT fk_order_item_product1 FOREIGN KEY
(product_id) REFERENCES product (id) ON DELETE NO ACTION ON
UPDATE NO ACTION)
Edit2:
I initially set onupdate="SET NULL" to the order_item entity and thought that was enough, it was not:
/**
* #var \Product
*
* #ORM\ManyToOne(targetEntity="Product")
* #ORM\JoinColumns({
* #ORM\JoinColumn(name="product_id", referencedColumnName="id", nullable=true, onDelete="SET NULL")
* })
*/
private $product;
After that, I had to update db schema as well.
Assuming you have the proper relations set up between the owning entity product and the other entities e.g. cart_item that should have a foreign_key, your wanted behaviour is the default for doctrine 2.
Take a look here in the manual
As an example they show the deletion of a User entity and its corresponding Comments
$user = $em->find('User', $deleteUserId);
foreach ($user->getAuthoredComments() AS $comment) {
$em->remove($comment);
}
$em->remove($user);
$em->flush();
The example states:
Without the loop over all the authored comments Doctrine would use an UPDATE statement only to set the foreign key to NULL and only the User would be deleted from the database during the flush()-Operation.
This suggests to me that in your case you actually want that behaviour. So just remove the product entity and doctrine 2 will automatically find all other entities with a foreign_key belonging to that product and will set it to NULL
Edit
Your error message suggests that upon attempted removal of the product entity there are still foreign_keys present, i.e. they have not been set to null properly by Doctrine.
You need to be sure to add the cascade property, specifically remove to your entity relationship. It would look something like the following:
<?php
class Product
{
//...
/**
* Bidirectional - One-To-Many (INVERSE SIDE)
*
* #OneToMany(targetEntity="Cart", mappedBy="product", cascade={"remove"})
*/
private $carts;
//...
}
The statement
I'm trying to reproduce the automatic Doctrine mechanism for handling Many-to-Many bidrectional relationships, but introducing a custom join table.
I've already digged into similar questions:
Joining-Table with Metadata Impairs Getters/Setters - Doctrine 2
but it doesn't really help me because it's absolutely unidirectional
doctrine2 many to many self referencing with intermediate details
but this one does not even talk about managing the relations
Doctrine2: Best way to handle many-to-many with extra columns in reference table
is very interesting. However, although the author mentions its bidirectional needs, he doesn't cover the case.
I'm aware that a join table with extra fields is not an association anymore, just a third entity that refers to the two other ones. And from that statement, it's obvious that one cannot expect it to work out-of-the-box as an implicit Many-to-Many association managed by Doctrine.
But i want to have this trio to work as a simple, straight, bidirectional Many-to-Many association, so that means using proxy methods and relying on a Logic class.
The code
There's a Category entity and a Product entity:
/**
* #ORM\Table(name="category")
* #ORM\Entity(repositoryClass="CategoryRepository")
*/
class Category
{
/**
...
*/
protected $id = null;
/**
* #ORM\OneToMany(targetEntity="CategoryProduct", mappedBy="category", fetch="LAZY", cascade={"persist"})
*/
protected $categoryProducts;
}
and
/**
* #ORM\Table(name="product")
* #ORM\Entity(repositoryClass="ProductRepository")
*/
class Product
{
/**
...
*/
protected $id = null;
/**
* #ORM\OneToMany(targetEntity="CategoryProduct", mappedBy="product", fetch="LAZY", cascade={"persist"})
*/
protected $categoryProducts;
}
and of course a join entity:
/**
* #ORM\Table(name="category_product")
* #ORM\Entity(repositoryClass="CategoryProductRepository")
*/
class CategoryProduct
{
/**
...
*/
protected $id = null;
/**
* #ORM\ManyToOne(targetEntity="Category", fetch="EAGER", inversedBy="categoryProducts")
* #ORM\JoinColumn(onDelete="CASCADE")
*/
protected $category;
/**
* #ORM\ManyToOne(targetEntity="Product", fetch="EAGER", inversedBy="categoryProducts")
* #ORM\JoinColumn(onDelete="CASCADE")
*/
protected $product;
/**
* #ORM\Column(type="boolean", nullable=true)
*/
protected $starred = false;
}
The problem
How to keep an up-to-date list of CategoryProduct entities available to both entities in a pure ORM-style way? In an ORM, everything is managed on the Object layer. Changes to DB are made only on user's request, but it's not compulsory as long as one only works from the ORM point of view. In other words:
$category->addProduct($product);
does not write anything to the DB, and does not even persist any object to the entity manager, but one can still retrieve or remove this product from the list as long as the script runs.
In the case of a custom join table, it's different, because when one wants to add a product, he must create and persist a CategoryProduct entity. So what if we need to retrieve this association from the inverse side?. Here is a code sample that demonstrates my problem:
$product->addCategory($category);
$category->addProduct($product);
In this bidirectional association, how can the $category::addProduct function know about the instance of CategoryProduct entity created by $product::addcategory? The risk is to create two similar join entities for the same association, and i don't know how to avoid it.