MySQL composite index effect on joins

Question

I have the following SQL query (DB is MySQL 5):

select
    event.full_session_id,
    DATE(min(event.date)),
    event_exe.user_id,
    COUNT(DISTINCT event_pat.user_id)
FROM
    event AS event
JOIN event_participant AS event_pat ON
    event.pat_id = event_pat.id
JOIN event_participant AS event_exe on
    event.exe_id = event_exe.id
WHERE
    event_pat.user_id <> event_exe.user_id
GROUP BY
    event.full_session_id; 

"SHOW CREATE TABLE event":

CREATE TABLE `event` (
  `id` int(12) NOT NULL AUTO_INCREMENT,
  `date` datetime NOT NULL,
  `session_id` varchar(64) DEFAULT NULL,
  `full_session_id` varchar(72) DEFAULT NULL,
  `pat_id` int(12) DEFAULT NULL,
  `exe_id` int(12) DEFAULT NULL,
  PRIMARY KEY (`id`),
  KEY `SESSION_IDX` (`full_session_id`),
  KEY `PAT_ID_IDX` (`pat_id`),
  KEY `DATE_IDX` (`date`),
  KEY `SESSLOGPATEXEC_IDX` (`full_session_id`,`date`,`pat_id`,`exe_id`)
) ENGINE=MyISAM AUTO_INCREMENT=371955 DEFAULT CHARSET=utf8

"SHOW CREATE TABLE event_participant":

CREATE TABLE `event_participant` (
  `id` int(12) NOT NULL AUTO_INCREMENT,
  `user_id` varchar(64) NOT NULL,
  `alt_user_id` varchar(64) NOT NULL,
  `username` varchar(128) NOT NULL,
  `usertype` varchar(32) NOT NULL,
  PRIMARY KEY (`id`),
  UNIQUE KEY `ALL_UNQ` (`user_id`,`alt_user_id`,`username`,`usertype`),
  KEY `USER_ID_IDX` (`user_id`)
) ENGINE=MyISAM AUTO_INCREMENT=5397 DEFAULT CHARSET=utf8

Also, the query itself seems ugly, but this is legacy code on a production system, so we are not expected to change it (at least for now).

The problem is that, there is around 36 million record on the event table (in the production system), so there have been frequent crashes of the DB machine due to using temporary;using filesort processing (they provided these EXPLAIN outputs, unfortunately, I don't have them right now. I'll try to update them to this post later.)

The customer asks for a "quick fix" by adding indices. Currently we have indices on full_session_id, pat_id, date (separately) on event and user_id on event_participant. Thus I'm thinking of creating a composite index (pat_id, exe_id, full_session_id, date) on event- this index comprises of the fields in the join (equivalent to where ?), then group by, then aggregate (min) parts. This is just an idea because we currently don't have that kind of data volume to test, so we try the best we could first.

My question is:

• Could the index above help in the performance ? (It's quite confusing on the effect because I have found two really contrasting results: https://dba.stackexchange.com/questions/158385/compound-index-on-inner-join-table versus Separate Join clause in a Composite Index, where the latter suggests that composite index on joins won't work and the former that it'll work.
• Does this path (adding indices) have hopes ? Or should we forget it and just try to optimize the query instead ?

Thanks in advance for your help :)

Update:

I have updated the full table description for the two related tables.

MySQL version is 5.1.69. But I think we don't need to worry about the ambiguous data issue mentioned in the comments, because it seems there won't be ambiguity for our data. Specifically, for each full_session_id, there is only one "event_exe.user_id" returned (it's just a business logic in the application)

So, what do you think about my 2 questions ?