Here is the case, I have 2 entities, such as Contract、Media。 

    public class Media : Entity
    {
        public string Name {get; set;}
        public bool Enabled
        *//other properties can be ignored..*
    }

    public class Contract : Entity
    {
        public string Code {get; set;}
        *//other properties can be ignored..*
    }

Contract has many Medias, it seems that they are many to many.

**But!! at ef code first, i need 3 more fields  in the ContractMedia table(ef auto generated).
such as StartDate,EndDate and Price. these could not be added in Media entity.**

How to map at this case??




How to create a many-to-many mapping in Entity Framework?

I am trying to print a list of all the Conferences and for each conference, print its 3 Speakers.

In my template I have:

    {% if conferences %}
            &lt;ul&gt;
            {% for conference in conferences %}
                    &lt;li&gt;{{ conference.date }}&lt;/li&gt;
                    {% for speakers in conference.speakers %}
                            &lt;li&gt;{{ conference.speakers }}&lt;/li&gt;
                    {% endfor %}
            {% endfor %}
            &lt;/ul&gt;
    {% else %}
    &lt;p&gt;No Conferences&lt;/p&gt;
    {% endif %}

in my views.py file I have:

    from django.shortcuts import render_to_response
    from youthconf.conference.models import Conference
    
    def manageconf(request):
            conferences = Conference.objects.all().order_by(&#39;-date&#39;)[:5]
            return render_to_response(&#39;conference/manageconf.html&#39;, {&#39;conferences&#39;: conferences})

there is a model named **conference**. which has a class named **Conferences** with a *ManyToManyField* named **speakers**

I get the error:

    Caught an exception while rendering: &#39;ManyRelatedManager&#39; object is not iterable

with this line: `{% for speakers in conference.speakers %}`

listing objects from ManyToManyField

I have 3 tables: User, Community, community_members (for relationship many2many of users and community). 

I create this tables using Flask-SQLAlchemy:

    community_members = db.Table(&#39;community_members&#39;,
                    db.Column(&#39;user_id&#39;, db.Integer, db.ForeignKey(&#39;user.id&#39;)),
                    db.Column(&#39;community_id&#39;, db.Integer, db.ForeignKey(&#39;community.id&#39;)),
                    )


    class Community(db.Model):
        __tablename__ = &#39;community&#39;
    
        id = db.Column(db.Integer, primary_key=True)
        name = db.Column(db.String(100), nullable=False, unique=True)
        members = db.relationship(User, secondary=community_members,
                                backref=db.backref(&#39;community_members&#39;, lazy=&#39;dynamic&#39;))


Now I want add additional field to community_members like this:

    community_members = db.Table(&#39;community_members&#39;,
                    db.Column(&#39;id&#39;, db.Integer, primary_key=True),
                    db.Column(&#39;user_id&#39;, db.Integer, db.ForeignKey(&#39;user.id&#39;)),
                    db.Column(&#39;community_id&#39;, db.Integer, db.ForeignKey(&#39;community.id&#39;)),
                    db.Column(&#39;time_create&#39;, db.DateTime, nullable=False, default=func.now()),
                    )


And now in python shell I can do this:

create community:

    &gt; c = Community()
    &gt; c.name = &#39;c1&#39;
    &gt; db.session.add(c)
    &gt; db.session.commit()

add members to community:

    &gt; u1 = User.query.get(1)
    &gt; u2 = User.query.get(2)
    &gt; c.members.append(u1)
    &gt; c.members.append(u2)
    &gt; db.session.commit()

    &gt; c.members
    [&lt;User 1&gt;, &lt;User 2&gt;]


Ok, this works.

But how now I can get time_create of community_members table?

SQLAlchemy ManyToMany secondary table with additional fields

I&#39;ve set up a simple many-to-many relationship account : role with Hibernate but when I try to save an account in a unit test after it has had its role added I get an UnsupportedOperationException:


    java.lang.UnsupportedOperationException
    	at java.util.AbstractList.remove(AbstractList.java:144)
    	at java.util.AbstractList$Itr.remove(AbstractList.java:360)
    	at java.util.AbstractList.removeRange(AbstractList.java:559)
    	at java.util.AbstractList.clear(AbstractList.java:217)
    	at org.hibernate.type.CollectionType.replaceElements(CollectionType.java:502)
    	at org.hibernate.type.CollectionType.replace(CollectionType.java:582)
    	at org.hibernate.type.TypeHelper.replace(TypeHelper.java:178)
    	at org.hibernate.event.def.DefaultMergeEventListener.copyValues(DefaultMergeEventListener.java:563)
    	at org.hibernate.event.def.DefaultMergeEventListener.entityIsPersistent(DefaultMergeEventListener.java:288)
    	at org.hibernate.event.def.DefaultMergeEventListener.onMerge(DefaultMergeEventListener.java:261)
    	at org.hibernate.event.def.DefaultMergeEventListener.onMerge(DefaultMergeEventListener.java:84)
    	at org.hibernate.impl.SessionImpl.fireMerge(SessionImpl.java:867)
    	at org.hibernate.impl.SessionImpl.merge(SessionImpl.java:851)
    	at org.hibernate.impl.SessionImpl.merge(SessionImpl.java:855)
    	at org.hibernate.ejb.AbstractEntityManagerImpl.merge(AbstractEntityManagerImpl.java:686)
    	at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
    	at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:39)
    	at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:25)
    	at java.lang.reflect.Method.invoke(Method.java:597)
    	at org.springframework.orm.jpa.SharedEntityManagerCreator$SharedEntityManagerInvocationHandler.invoke(SharedEntityManagerCreator.java:240)
    	at $Proxy33.merge(Unknown Source)
    	at org.springframework.data.jpa.repository.support.SimpleJpaRepository.save(SimpleJpaRepository.java:360)
    	at ....JpaProvider.save(JpaProvider.java:161)
    	at ....DataModelTest.testAccountRole(DataModelTest.java:47)
    	at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
    	at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:39)
    	at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:25)
    	at java.lang.reflect.Method.invoke(Method.java:597)
    	at org.junit.runners.model.FrameworkMethod$1.runReflectiveCall(FrameworkMethod.java:44)
    	at org.junit.internal.runners.model.ReflectiveCallable.run(ReflectiveCallable.java:15)
    	at org.junit.runners.model.FrameworkMethod.invokeExplosively(FrameworkMethod.java:41)
    	at org.junit.internal.runners.statements.InvokeMethod.evaluate(InvokeMethod.java:20)
    	at org.junit.internal.runners.statements.RunBefores.evaluate(RunBefores.java:28)
    	at org.springframework.test.context.junit4.statements.RunBeforeTestMethodCallbacks.evaluate(RunBeforeTestMethodCallbacks.java:74)
    	at org.springframework.test.context.junit4.statements.RunAfterTestMethodCallbacks.evaluate(RunAfterTestMethodCallbacks.java:82)
    	at org.springframework.test.context.junit4.statements.SpringRepeat.evaluate(SpringRepeat.java:72)
    	at org.springframework.test.context.junit4.SpringJUnit4ClassRunner.runChild(SpringJUnit4ClassRunner.java:240)
    	at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:49)
    	at org.junit.runners.ParentRunner$3.run(ParentRunner.java:193)
    	at org.junit.runners.ParentRunner$1.schedule(ParentRunner.java:52)
    	at org.junit.runners.ParentRunner.runChildren(ParentRunner.java:191)
    	at org.junit.runners.ParentRunner.access$000(ParentRunner.java:42)
    	at org.junit.runners.ParentRunner$2.evaluate(ParentRunner.java:184)
    	at org.springframework.test.context.junit4.statements.RunBeforeTestClassCallbacks.evaluate(RunBeforeTestClassCallbacks.java:61)
    	at org.springframework.test.context.junit4.statements.RunAfterTestClassCallbacks.evaluate(RunAfterTestClassCallbacks.java:70)
    	at org.junit.runners.ParentRunner.run(ParentRunner.java:236)
    	at org.springframework.test.context.junit4.SpringJUnit4ClassRunner.run(SpringJUnit4ClassRunner.java:180)
    	at org.eclipse.jdt.internal.junit4.runner.JUnit4TestReference.run(JUnit4TestReference.java:50)
    	at org.eclipse.jdt.internal.junit.runner.TestExecution.run(TestExecution.java:38)
    	at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.runTests(RemoteTestRunner.java:467)
    	at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.runTests(RemoteTestRunner.java:683)
    	at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.run(RemoteTestRunner.java:390)
    	at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.main(RemoteTestRunner.java:197)

What&#39;s going wrong here? Is my entity setup faulty or is this a hibernate or JPA limitation forcing me to split apart my m:m relationship into 3 1:n relations modeling the m:n relationship table as well (which I wanted to avoid since it does not have any additional information). I&#39;ve modeled other 1:n entities in my prototype and that seemed to work out nicely so far...


Here&#39;s my setup, any thoughts whether it might be faulty are appreciated. 

Entities (simplified):


    @Entity
    @Table(name=&quot;account&quot;)
    public class Account extends AbstractPersistable&lt;Long&gt; {
    
    	private static final long serialVersionUID = 627519641892468240L;
    
    	private String username;
    
        
        @ManyToMany
        @JoinTable(	name = &quot;account_roles&quot;, 
        			joinColumns = { @JoinColumn(name = &quot;account_id&quot;)}, 
        			inverseJoinColumns={@JoinColumn(name=&quot;role_id&quot;)})  
        private List&lt;Role&gt; roles;   
    	   
       
    	public List&lt;Role&gt; getRoles() {
    		return roles;
    	}
    	public void setRoles(List&lt;Role&gt; roles) {
    		this.roles = roles;
    	}
    
    
    
        @Entity
        @Table(name=&quot;role&quot;)
        public class Role extends AbstractPersistable&lt;Long&gt; {
        
        	private static final long serialVersionUID = 8127092070228048914L;
        	
        	private String name;
        
        	@ManyToMany
        	@JoinTable(	name = &quot;account_roles&quot;,   
        				joinColumns={@JoinColumn(name=&quot;role_id&quot;)},   
        				inverseJoinColumns={@JoinColumn(name=&quot;account_id&quot;)})  
        	private List&lt;Account&gt; accounts;
        	
        
        	public List&lt;Account&gt; getAccounts() {
        		return accounts;
        	}
        
        	public void setAccounts(List&lt;Account&gt; accounts) {
        		this.accounts = accounts;
        	}

Unit Test:

    @TransactionConfiguration
    @ContextConfiguration({&quot;classpath:dw-security-context-test.xml&quot;})
    @Transactional
    @RunWith(SpringJUnit4ClassRunner.class)
    public class DataModelTest {
    
    	@Inject
    	private AccountProvider accountProvider;	
    	
    	@Inject 
    	private RoleProvider roleProvider;
    	
    	@Before
    	public void mockAccountRolePermission(){
    		Account account = MockAccount.getSavedInstance(accountProvider);
    		Role role = MockRole.getSavedInstance(roleProvider);
    	}
    
    	@Test
    	public void testAccountRole(){		
    		Account returnedAccount = accountProvider.findAll().get(0);
    		returnedAccount.setRoles(Arrays.asList(roleProvider.findAll().get(0)));
    		accountProvider.save(returnedAccount);
    
    	}
    }

MockAccount (same for MockRole):

    public class MockAccount {
    	
    	public static Account getInstance(){
    		Account account = new Account();
    		account.setUsername(RandomData.rndStr(&quot;userName-&quot;, 5));
    		return account;
    	}
    	
    	public static Account getSavedInstance(AccountProvider accountProvider){
    		Account account = getInstance();
    		accountProvider.save(account);
    		return account;
    	}
    	
    }

And finally the Provider:

    @Repository
    public class AccountProvider extends JpaProvider&lt;Account, Long&gt; {
    	
    }

where JPAProvider just wraps a lot of JPARepository methods (at least as far as it is important in this case):

    public abstract class JpaProvider&lt;T extends Object, ID extends Serializable&gt; implements JpaRepository&lt;T, ID&gt;, JpaSpecificationExecutor&lt;T&gt;, QueryDslPredicateExecutor&lt;T&gt; {
    ...
    }


Any Ideas on why the save might be an UnsupportedOperation?  


UnsupportedOperationException merge-saving many-to-many relation with hibernate and JPA

I&#39;m trying to create a messaging system where a message&#39;s sender and recipients can be generic entities. This seems fine for the sender, where there is only object to reference (GenericForeignKey) but I can&#39;t figure out how to go about this for the recipients (GenericManyToManyKey ??)

Below is a simplified example. PersonClient and CompanyClient inherit attributes from Client but have their own specific details. The last line is the sticking point. How do you allow message recipients to be a set of CompanyClients and PersonClients



      class Client(models.Model):
          city = models.CharField(max_length=16)
        
          class Meta:
              abstract = True
    
      class PersonClient(Client):
          first_name = models.CharField(max_length=16)
          last_name = models.CharField(max_length=16)
          gender = models.CharField(max_length=1)
    
      class CompanyClient(Client):
          name = models.CharField(max_length=32)
          tax_no = PositiveIntegerField()
        
      class Message(models.Model):
          msg_body = models.CharField(max_length=1024)
          sender = models.ForeignKey(ContentType)
          recipients = models.ManyToManyField(ContentType)



Generic many-to-many relationships

When you have a many-to-many relationship (`related_name`, not `through`) and you are trying to use the admin interface you are required to enter one of the relationships even though it does not have to exist for you to create the first entry.

I&#39;m creating an app that is an event organizer. Imagine we had `Event` and `Group` models, bound with many-to-many relationship.

Django [`related_name`][1] creates another table with the indices of the two other tables.   
**But I see no reason why this extra table *has* to be populated.**

If I work with the database through phpMyAdmin I can create a `Group` without registering an `Event`, since the connection between the two is only through a separate table, and there is no database value enforcement at given level.

How do I make the admin interface this realize it?  
**How do I make the many-to-many field optional in Django?**


  [1]: https://docs.djangoproject.com/en/dev/ref/models/fields/#django.db.models.ForeignKey.related_name

How do I make many-to-many field optional in Django?

There is a handy dynamic attribute in active-record called find_or_create_by:

`Model.find_or_create_by_&lt;attribute&gt;(:&lt;attribute&gt; =&gt; &quot;&quot;)`

But what if I need to find_or_create by more than one attribute?

Say I have a model to handle a M:M relationship between Group and Member called GroupMember. I could have many instances where member_id = 4, but I don&#39;t ever want more than once instance where member_id = 4 and group_id = 7. I&#39;m trying to figure out if it&#39;s possible to do something like this:

    GroupMember.find_or_create(:member_id =&gt; 4, :group_id =&gt; 7)

I realize there may be better ways to handle this, but I like the convenience of the idea of find_or_create.

Rails find_or_create_by more than one attribute?

Ok so this is probably a trivial question but I&#39;m having trouble visualizing and understanding the differences and when to use each. I&#39;m also a little unclear as to how concepts like uni-directional and bi-directional mappings affect the one-to-many/many-to-many relationships. I&#39;m using Hibernate right now so any explanation that&#39;s ORM related will be helpful. 

As an example let&#39;s say I have the following set-up:

    public class Person{
        private Long personId;
        private Set&lt;Skill&gt; skills;
        //Getters and setters
    }
    
    public class Skill{
        private Long skillId;
        private String skillName;
        //Getters and setters
    }

So in this case what kind of mapping would I have? Answers to this specific example are definitely appreciated but I would also really like an overview of when to use either one-to-many and many-to-many and when to use a join table versus a join column and unidirectional versus bidirectional.

Difference Between One-to-Many, Many-to-One and Many-to-Many?

In which case do you use the JPA `@JoinTable` annotation?

In which case do you use the JPA @JoinTable annotation?

How would you do a many-to-many association with MongoDB?

For example; let&#39;s say you have a Users table and a Roles table. Users have many roles, and roles have many users. In SQL land you would create a UserRoles table.

    Users:
        Id
        Name

    Roles:
        Id
        Name

    UserRoles:
        UserId
        RoleId

How is same sort of relationship handled in MongoDB?


MongoDB Many-to-Many Association

How would I delete an object from a Many-to-Many relationship without removing the actual object?

**Example:**

I have the models `Moods` and `Interest`.

`Mood` has a many-to-many field `interests` (which is a `models.ManyToManyField(Interest)`). 

I create an instance of `Moods` called `my_mood`. In `my_moods`&#39;s interests field I have `my_interest`, meaning 

    &gt;&gt;&gt; my_mood.interests.all()
    [my_interest, ...]

How do I remove `my_interest` from `my_mood` without deleting either model instance? In other words, how do I remove the relationship without affecting the related models?

Django removing object from ManyToMany relationship

This question comes up after reading a comment in this question:

https://stackoverflow.com/questions/2190089/database-design/2190101

When you create a many-to-many table, should you create a composite primary key on the two foreign key columns, or create a auto-increment surrogate &quot;ID&quot; primary key, and just put indexes on your two FK columns (and maybe a unique constraint)?  What are the implications on performance for inserting new records/re-indexing in each case?

Basically, this:

    PartDevice
    ----------
    PartID (PK/FK)
    DeviceID (PK/FK)

vs. this:

    PartDevice
    ----------
    ID (PK/auto-increment)
    PartID (FK)
    DeviceID (FK)


The commenter says:

&gt; making the two IDs the PK means the
&gt; table is physically sorted on the disk
&gt; in that order. So if we insert
&gt; (Part1/Device1), (Part1/Device2),
&gt; (Part2/Device3), then (Part 1/Device3)
&gt; the database will have to break the
&gt; table apart and insert the last one
&gt; between entries 2 and 3. For many
&gt; records, this becomes very problematic
&gt; as it involves shuffling hundreds,
&gt; thousands, or millions of records
&gt; every time one is added. By contrast,
&gt; an autoincrementing PK allows the new
&gt; records to be tacked on to the end.

The reason I&#39;m asking is because I&#39;ve always been inclined to do the composite primary key with no surrogate auto-increment column, but I&#39;m not sure if the surrogate key is actually more performant.



SQL - many-to-many table primary key

My database contains 3 tables:
User and Service entities have many-to-many relationship and are joined with the SERVICE_USER table as follows:

USERS - SERVICE_USER - SERVICES

SERVICE_USER table contains additional BLOCKED column.

What is the best way to perform such a mapping?
These are my Entity classes

    @Entity
    @Table(name = &quot;USERS&quot;)
    public class User implements java.io.Serializable {
    
    private String userid;
    private String email;
    
    @Id
    @Column(name = &quot;USERID&quot;, unique = true, nullable = false,)
    public String getUserid() {
    return this.userid;
    }
    
    .... some get/set methods
    }
    
    @Entity
    @Table(name = &quot;SERVICES&quot;)
    public class CmsService implements java.io.Serializable {
    private String serviceCode;
    
    @Id
    @Column(name = &quot;SERVICE_CODE&quot;, unique = true, nullable = false, length = 100)
    public String getServiceCode() {
    return this.serviceCode;
    }
    .... some additional fields and get/set methods
    }

I followed this example http://giannigar.wordpress.com/2009/09/04/m ... using-jpa/
Here is some test code:

    User user = new User();
    user.setEmail(&quot;e2&quot;);
    user.setUserid(&quot;ui2&quot;);
    user.setPassword(&quot;p2&quot;);
    
    CmsService service= new CmsService(&quot;cd2&quot;,&quot;name2&quot;);
    
    List&lt;UserService&gt; userServiceList = new ArrayList&lt;UserService&gt;();
    
    UserService userService = new UserService();
    userService.setService(service);
    userService.setUser(user);
    userService.setBlocked(true);
    service.getUserServices().add(userService);
    
    userDAO.save(user);

The problem is that hibernate persists User object and UserService one. No success with the CmsService object

I tried to use EAGER fetch - no progress

Is it possible to achieve the behaviour I&#39;m expecting with the mapping provided above?

Maybe there is some more elegant way of mapping many to many join table with additional column?

Mapping many-to-many association table with extra column(s)

I believe the title is self-explanatory. How do you create the table structure in  PostgreSQL to make a many-to-many relationship.

My example:

    Product(name, price);
    Bill(name, date, Products);

How to implement a many-to-many relationship in PostgreSQL?

What is the `related_name` argument useful for on `ManyToManyField` and `ForeignKey` fields? For example, given the following code, what is the effect of `related_name=&#39;maps&#39;`?


    class Map(db.Model):
        members = models.ManyToManyField(User, related_name=&#39;maps&#39;,
                                         verbose_name=_(&#39;members&#39;))

What is related_name used for?

I&#39;m using EF4 and new to it. I have a many to many in my project and cannot seem to work out how to insert or update. I have build a small project just to see how it should be coded.

Suppose I have 3 tables

 1. Class : ClassID-ClassName 
 2. Student : StudentID-FirstName-Surname
 3. StudentClass : StudentID-ClassID

After adding all the relationship and updated the model via model browser I have noticed that StudentClass does not appear, this seems to be default behaviour.

Now I need to do both an Insert and Update. How do you do it? Any code samples or link where I can download an example, or can you spare 5 mins?

Insert/Update Many to Many Entity Framework . How do I do it?

I am trying to filter a bunch of objects through a many-to-many relation. Because the `trigger_roles` field may contain multiple entries I tried the `contains` filter. But as that is designed to be used with strings I&#39;m pretty much helpless how i should filter this relation (you can ignore the `values_list()` atm.).

This function is attached to the user profile:

    def getVisiblePackages(self):
        visiblePackages = {}   
        for product in self.products.all():
            moduleDict = {}
            for module in product.module_set.all():
                pkgList = []
                involvedStatus = module.workflow_set.filter(trigger_roles__contains=self.role.id,allowed=True).values_list(&#39;current_state&#39;, flat=True)

My workflow model looks like this (simplified):

    class Workflow(models.Model):
        module = models.ForeignKey(Module)
        current_state = models.ForeignKey(Status)
        next_state = models.ForeignKey(Status)
        allowed = models.BooleanField(default=False)
        involved_roles = models.ManyToManyField(Role, blank=True, null=True)
        trigger_roles = models.ManyToManyField(Role, blank=True, null=True)

Though the solution might be quiet simple, my brain won&#39;t tell me.

Thanks for your help.

Django filter many-to-many with contains

I&#39;m having a little difficulty getting my head around relationships in Django models. 

Could someone explain what the difference is between a OneToOne, ManyToMany and ForeignKey?

Whats the difference between a OneToOne, ManyToMany, and a ForeignKey Field in Django?

In Django, when you have a parent class and multiple child classes that inherit from it you would normally access a child through parentclass.childclass1_set or parentclass.childclass2_set, but what if I don&#39;t know the name of the specific child class I want?

Is there a way to get the related objects in the parent-&gt;child direction without knowing the child class name?

How do I access the child classes of an object in django without knowing the name of the child class?

I want to store some additional information in that, automatically created, ManyToMany join-table. How would I do that in Django? 

In my case I have two tables: &quot;Employees&quot; and &quot;Projects&quot;. What I want to store is how much each of the employees receives per hour of work in each of the projects, since those values are not the same. So, how would I do that?

What occurred to me was to, instead of the method &quot;ManyToManyField&quot;, create explicitly a third class/table to store those new informations and to set its relationship with &quot;Employees&quot; and &quot;Projects&quot; using the &quot;ForeignKey&quot; method. I&#39;m pretty sure it will work, but is this the best approach?



Django&#39;s ManyToMany Relationship with Additional Fields

I have a phone_models, phone_problems, and a phone_model_phone_problem pivot table. The pivot table has an extra column &#39;price&#39;.

PhoneModel:

    class PhoneModel extends \Eloquent
    {
        public function problems()
        {
            return $this-&gt;belongsToMany(&#39;RL\Phones\Entities\PhoneProblem&#39;)-&gt;withPivot(&#39;price&#39;);
        }
    }

PhoneProblem:

    class PhoneProblem extends \Eloquent
    {
        public function models()
        {
            return $this-&gt;belongsToMany(&#39;PhoneModel&#39;)-&gt;withPivot(&#39;price&#39;);
        }
    }

What I&#39;m trying to do is get the price of a specific phone with a specific problem.

This is how I have it now but I feel like Laravel has a built in Eloquent feature I can&#39;t find to do this in a much simpler way:

    $model = $this-&gt;phoneService-&gt;getModelFromSlug($model_slug);
    $problem = $this-&gt;phoneService-&gt;getProblemFromSlug($problem_slug);

all this does is select the specific model and problem from their slug.

then what I do is with those credentials I get the price like so:

    $row = DB::table(&#39;phone_model_phone_problem&#39;)
    -&gt;where(&#39;phone_model_id&#39;, &#39;=&#39;, $model-&gt;id)
    -&gt;where(&#39;phone_problem&#39;, &#39;=&#39;, $problem-&gt;id)
    -&gt;first();

so now I can get the price like so `$row-&gt;price` but I feel like there needs to be a much easier and more &#39;Laravel&#39; way to do this.




getting the value of an extra pivot table column laravel

What is the difference between `fetch=&quot;EAGER&quot;` and `fetch=&quot;LAZY&quot;` in annotation `@ManyToOne` in Doctrine ?

    /**
     * @ManyToOne(targetEntity=&quot;Cart&quot;, cascade={&quot;all&quot;}, fetch=&quot;EAGER&quot;)
     */
    
    /**
     * @ManyToOne(targetEntity=&quot;Cart&quot;, cascade={&quot;all&quot;}, fetch=&quot;LAZY&quot;)
     */

What is the difference between fetch=&quot;EAGER&quot; and fetch=&quot;LAZY&quot; in doctrine

I&#39;d like to create a many-to-many relationship from and to a user class object.

I have something like this:

    class MyUser(models.Model):
        ...
        blocked_users = models.ManyToManyField(MyUser, blank=True, null=True)



The question is if I can use the class reference inside itself. Or do I have to use `&quot;self&quot;` insead of `&quot;MyUser&quot;` in the `ManyToManyField`? Or is there another (and better) way to do it?


Django Many-to-Many (m2m) Relation to same model

I have two tables/collections; Users and Groups. A user can be a member of any number of groups and a user can also be an owner of any number of groups. In a relational database I&#39;d probably have a third table called UserGroups with a UserID column, a GroupID column and an IsOwner column.

I&#39;m using MongoDB and I&#39;m sure there is a different approach for this kind of relationship in a document database. Should I embed the list of groups and groups-as-owner inside the Users table as two arrays of ObjectIDs? Should I also store the list of members and owners in the Groups table as two arrays, effectively mirroring the relationship causing a duplication of relationship information?

Or is a bridging UserGroups table a legitimate concept in document databases for many to many relationships?

Thanks



How to organise a many to many relationship in MongoDB

I am using JPA 2.0 and hibernate. I have a User class and a Group class as follows:

    public class User implements Serializable {
        @Id
        @Column(name=&quot;USER_ID&quot;)
        private String userId;
    
        @ManyToMany
        @JoinTable(name = &quot;USER_GROUP&quot;,
                   joinColumns = {
                       @JoinColumn(name = &quot;GROUP_ID&quot;)
                   },
                   inverseJoinColumns = {
                       @JoinColumn(name = &quot;USER_ID&quot;)
                   }
        )
        private Set&lt;Group&gt; groupList;
        
        //get set methods
    }

    public class Group
    {
        @Id
        @Column(name=&quot;GROUP_ID&quot;)
        private String groupId;
    
        @ManyToMany(mappedBy=&quot;groupList&quot;)
        private Set&lt;User&gt; memberList;
        //get set methods
    }

And then, I create a user and group and then assign the user to the group.

What I want to have is when I delete the group, the group will be deleted (of course) and all the user-group relationship that the group has will be automatically deleted from the USER_GROUP join table but the user itself is not deleted from the USER table.

With the code I have above, only the row in the GROUP table will be deleted when I delete a group and the user will still have an entry to the deleted group in the USER_GROUP join table.


If I put cascade in the User class like this:

    @ManyToMany(cascade=CascadeType.ALL)
    @JoinTable(name = &quot;USER_GROUP&quot;,
    joinColumns =
    {
        @JoinColumn(name = &quot;GROUP_ID&quot;)
    },
    inverseJoinColumns =
    {
        @JoinColumn(name = &quot;USER_ID&quot;)
    })
    private Set&lt;Group&gt; groupList;
When I delete the group, the user will be deleted as well!

Is there any way to achieve what I want?

JPA Hibernate many-to-many cascading

I have two PHP model classes named Category and Item. A Category may have many Items and an Item may belong to many Categories.
I have created a ManyToMany relation to both classes:

    class Category
    {
        /**
         * @ORM\ManyToMany(targetEntity=&quot;Item&quot;, mappedBy=&quot;categories&quot;, cascade={&quot;persist&quot;})
         */
        private $items;
    
        /**
         * Add items
         *
         * @param Ako\StoreBundle\Entity\Item $items
         */
        public function addItems(\Ako\StoreBundle\Entity\Item $items)
        {
            $this-&gt;items[] = $items;
        }
    
        /**
         * Get items
         *
         * @return Doctrine\Common\Collections\Collection 
         */
        public function getItems()
        {
            return $this-&gt;items;
        }
    }

And:

    class Item
    {
        /**
         * @ORM\ManyToMany(targetEntity=&quot;Category&quot;, inversedBy=&quot;items&quot;, cascade={&quot;persist&quot;})
         * @ORM\JoinTable(name=&quot;item_category&quot;,
         * joinColumns={@ORM\JoinColumn(name=&quot;item_id&quot;, referencedColumnName=&quot;id&quot;)},
         * inverseJoinColumns={@ORM\JoinColumn(name=&quot;category_id&quot;, referencedColumnName=&quot;id&quot;)}
         * )
         */
        private $categories;
    
        /**
         * Add categories
         *
         * @param Ako\StoreBundle\Entity\Category $categories
         */
        public function addCategories(\Ako\StoreBundle\Entity\Category $categories)
        {
            $this-&gt;categories[] = $categories;
        }
    
        /**
         * Get categories
         *
         * @return Doctrine\Common\Collections\Collection 
         */
        public function getCategories()
        {
            return $this-&gt;categories;
        }
    }

Now in my controller:

    $em = $this-&gt;getDoctrine()-&gt;getEntityManager();
    
    $item = $em-&gt;getRepository(&#39;AkoStoreBundle:Item&#39;)-&gt;find($item_id);
    $category = $em-&gt;getRepository(&#39;AkoStoreBundle:Category&#39;)-&gt;find($category_id);
    
    $category-&gt;addItems($item);
    
    $em-&gt;flush();
    // Render the same page again.

In this page, I show the list of all items in a select field. The user can select one item, and add it to the category.

The list of items which belong to the category are shown below the form.

When the I submit the form, the selected item is added to the list of Category items, and is shown below, but it is not stored in the database, and if refresh the page, it disappears.

Can anyone please help me with this?
Thanks in advance.

Symfony2-Doctrine: ManyToMany relation is not saved to database

From examples that I have seen online and in a Programming Entity Framework CodeFirst book, when you have a collection on both classes EF would create a mapping table such as `MembersRecipes` and the primary key from each class would link to this table.

However when I do the below, I instead get a new field in the `Recipes` table called `Member_Id` and a `Recipe_Id` in the `Members` table.

Which only creates two one-to-many relationships, but not a many-to-many so I could have Member 3 linked to Recipes (4,5,6) and Recipe 4 linked to Members (1,2,3) etc.

Is there a way to create this mapping table? and if so how do you name it something else such as &quot;cookbooks&quot; ?

Thanks

        public abstract class Entity {
    		[Required]
    		public int Id { get; set; }
    	}	
    
        public class Member : Entity {
    		[Required]
    		public string Name { get; set; }
    
    		public virtual IList&lt;Recipe&gt; Recipes { get; set; }
    	}
    
    	public class Recipe : Entity {	
    		[Required]
    		public string Name { get; set; }
    
    		[ForeignKey(&quot;Author&quot;)]
    		public int AuthorId { get; set; }
    		public virtual Member Author { get; set; }
                
                ....
    
    		public virtual IList&lt;Member&gt; Members { get; set; }
    	}


**UPDATE:** 
Below is another approach I have tried which doesn&#39;t use the Fluent API and replaces the `AuthorId` &amp; `Author` on `Recipe` with an owner flag, I have also renamed the below example from `Cookbooks` to `MembersRecipes`, this also fixes my issue similar to the answer but as mentioned has further implications.

	public class MembersRecipes {

		[Key, Column(Order = 0)]
		[ForeignKey(&quot;Recipe&quot;)]
		public int RecipeId { get; set; }
		public virtual Recipe Recipe { get; set; }

		[Key, Column(Order = 1)]
		[ForeignKey(&quot;Member&quot;)]
		public int MemberId { get; set; }
		public virtual Member Member { get; set; }

		public bool Owner { get; set; }
	}

and in `Recipe` &amp; `Member` classes I changed the collections to

    public virtual IList&lt;MembersRecipes&gt; MembersRecipes { get; set; }

Many-to-many mapping table

I have this scenario:

    public class Member
    {
        public int MemberID { get; set; }

        public string FirstName { get; set; }
        public string LastName { get; set; }

        public virtual ICollection&lt;Comment&gt; Comments { get; set; }
    }

    public class Comment
    {
        public int CommentID { get; set; }
        public string Message { get; set; }

        public virtual ICollection&lt;Member&gt; Members { get; set; }
    }

    public class MemberComment
    {
        public int MemberID { get; set; }
        public int CommentID { get; set; }
        public int Something { get; set; }
        public string SomethingElse { get; set; }
    }

How do I configure my association with [fluent API][1]? Or is there a better way to create the association table?



  [1]: https://www.quora.com/What-is-fluent-API-in-this-context/answer/Adam-Leffert

All Many to-Many Solutions on Gang of Coders

Total of 28 Many to-Many Solutions