需要MySQL数据库结构建议。 从一张桌子到另外两个桌子一对多的两个多对多关系

Question

I have this setup as my database structure which already works pretty well, but I feel like it could be better, but cannot figure out how.

Database Structure:-

Events can have multiple sub-events. Users can join these events and optionally their sub-events. With this structure I have all constraints, but the one that links the event attending with the sub event attendings => there can be sub event attendings left without having the main event attending (this shouldn't be possible as users who don't attend the main event cannot attend it's sub events).

I am currently working with Laravel so it looks like this:

User :

• hasMany Event (as organizer of these events)
• belongsToMany EventAttending (which events is a user joining)
• belongsToMany SubEventAttending (which sub-events is a user joining)

Event :

• belongsTo User
• hasMany SubEvent
• belongsToMany EventAttending (which users are attending this event)

SubEvent :

• belongsTo Event
• belongsToMany SubEventAttending (which users are attending this sub-event)

The problem arises when trying to manage the sub-event attendings of a user. How would I make this constraint between the event and sub-event attendings exist, while keeping it clean with the capabilities of Laravel / What can you give as advice for a better structuring / How would you guys do it?

Edit

To clarify, the events and sub-events store different things, have different properties. Also I need to store information for the event attendings (like did he attend in real life) and sub-event attendings, most likely differing ones.

Edit

Edward Haber has the better structure, but as my two pivot tables (the connection between User-Event and User-SubEvent) store additional diferent type of information, currently chose to remain with the initial design.

One of the biggest problems I am facing (which does exist with both structure) is querying for a User while getting the attended Events with the attended SubEvents . Trying to achive this result:

User[]:{  
  ...,  
    attending_events[]:{  
      ...,  
       attending_sub_events[]:{  
         ...  
       }  
    }  
}

Been thinking for hours for a clean solution, couldn't get anything else to work. Wouldn't like to write the whole SQL query manually. My current implementation with the two pivot table looks like this (result not nested, code messy):

$users = User::withCount(['attendingEvents' => function($query) use($eventId){
            $query->where('event_id', $eventId);
        }])
        ->with(['attendingSubEvents' => function($query) use($eventId){
            $query->select('id')->whereHas('event', function($query) use($eventId){
                $query->where('id', $eventId);
            });
        }]);

With this approach I get the sub-events separated from the main event. (querying only for the main attending-event count, because I only need to determine whether he is joining or not).

Answer 1

The pattern for this type of solution is to use a Polymorphic Relationship . This solution focuses just on connecting the User to the Event and SubEvent - the rest of the relations look correct.

<?php
class User extends Model {
    public function attending() {
        return $this->morphTo();
    }
}

<?php 
class Event extends Model {
    public function attendees() {
        return $this->morphMany('App\User', 'attending')
    }
}


<?php 
class Subevent extends Model {
    public function attendees() {
        return $this->morphMany('App\User', 'attending')
    }
}

The users table needs these fields:

*users*
-----
id
attending_id
attending_type

This is all untested - but the basic idea. (Edited: changed name of polymorphic method to attending from attendee)