Thanks for the pointers on the SQL logging and the Hibernate logging. After figuring out how to turn on logging for MySQL, I saw that the entries into the join table were simple inserts - not the product (forgive the pun) of a join. Here is the basic class structure for the 2 classes involved:
public class Event {
private Long id;
private
String name;
private Set speakers;
public void setId(Long id) {
this.id = id;
}
public Long getId() {
return id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public void setSpeakers(Set speakers) {
this.speakers = speakers;
}
public Set getSpeakers() {
return speakers;
}
}
public class Speaker {
private Long id;
private String firstName;
private String lastName;
private Set events;
public Speaker() {
}
public SpeakerManyToMany(String firstName, String lastName) {
setFirstName(firstName);
setLastName(lastName);
}
public SpeakerManyToMany(String firstName, String lastName, Event event) {
this(firstName, lastName);
addEvent(event);
}
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public String getFirstName() {
return firstName;
}
public void setFirstName(String firstName) {
this.firstName = firstName;
}
public String getLastName() {
return lastName;
}
public void setLastName(String lastName) {
this.lastName = lastName;
}
public Set getEvents() {
return this.events;
}
public void setEvents(Set events) {
this.events = events;
}
private void addEvent(Event event) {
if (events == null) {
events = new HashSet();
}
events.add(event);
}
}
The object creation looks like the following:
Event event = new Event();
event.setName("Event1");
event.setSpeakers(new HashSet());
event.getSpeakers().add(new SpeakerManyToMany("Jane, "Jones", event));
event.getSpeakers().add(new Speaker("Joe", "Smith", event));
event.getSpeakers().add(new Speaker("John", "Smith", event));
// Save event object
session.save(event);
// second event with multiple speakers
Event event2 = new Event();
event2.setName("Event2");
event2.setSpeakers(new HashSet());
event2.getSpeakers().add(new Speaker("John", "Smith", event2));
event2.getSpeakers().add(new Speaker("Jane", "Doe", event2));
event2.getSpeakers().add(new Speaker("Dave", "Wood", event2));
The mapping files contain set statements such as:
<set name="speakers" table="event_speakers" cascade="all">
<key column="event_id"/>
<many-to-many column="speaker_id" class="Speaker"/>
</set>
The SQL being generated for the join table " insert into event_speakers
(event_id, speaker_id) values (1, 1)". The values go from (1, 1) to (1, 3) (3 speakers - same event_id). Then the SQL changes to "insert into event_speakers
(speaker_id, event_id) values (1, 1) to (3, 1)".
These SQL statements alternate back to the pair (event_id, speaker_id) then alternate again back to (speaker_id, event_id) for the 2nd event. So the insert values are as follows:
(1,1), (1,2), (1,3), (1,1), (2,1), (3,1), (2, 4), (2, 5), (2, 6), (4, 2), (5, 2), (6, 2) .
Les
