Many-to-Many Overhaul

In re-reading this issue, it didn't seem entirely clear that in addition to enhancing the hasMany functionality, I am hoping that the default behavior is changed.

To anyone with a database design background, the current behavior is counterintuitive. As we see on the mailing list at least once a week someone posts their confusion with naming of the join table's foreign keys (and I agree it is confusing, the explanation in JIRA-828 notwithstanding). If Grails is trying to adhere to conventions this is a place where it currently misses the mark.

Using the following two classes and the BOOK/PERSON data from the issue description above, you would end up with a join table called PERSON_BOOK where the ID from the BOOK table is stored in a column called AUTHORS_ID and the ID from the PERSON table is stored in a column called BOOKS_ID. So in addition to the non-standard pluralization of the column name, the IDs in the join table appear reversed. Sure you could look at the constraints, but it could/should be clearer just looking at the column names.

class Person {
static hasMany = [books: Book]
}
class Book {
static hasMany = [authors:Person]
static belongsTo = Person
}

PERSON_BOOK (current counterintuitive behavior)

So my suggestion for the default behavior is when there is a single M2M, you would not need to specify the new object & join parameters, however you would get a join table like the following.

PERSON_BOOK

A relationship like:

class Book {
    String title
    static belongsTo = Author
    static hasMany = [authors:Author]
}
class Author {
     String name
     static hasMany = [books:Book]
}

Now maps onto a table called "author_books" like:

You can also completely alter the mapping with the ORM DSL:

class Book {
    String title
    static belongsTo = Author
    static hasMany = [authors:Author]

    static mapping = {
        authors joinTable:[name:"mm_author_books", key:'mm_book_id' ]
    }
}
class Author {
     String name
     static hasMany = [books:Book]
    static mapping = {
        books joinTable:[name:"mm_author_books", key:'mm_author_id']
    }
}

And multiple many-to-many relationships are supported with the mappedBy syntax that existed already:

class Book {
    String title
    static belongsTo = Person

    static mappedBy = [publishers:'publishedBooks',
                                   authors:'books']
    static hasMany = [authors:Person,
                                 publishers:Person]
}
class Person {
    String name
    static mappedBy = [books:'authors',
                                   publishedBooks:'publishers']
    static hasMany = [books:Book,
                                 publishedBooks:Book]
}

why is in author_books the word book*s* plural but author singular? How is the logic which class is singular and which is plural?

The name is formulated from the owning class (Author) and the association name (books). They both cannot be singular because then if you had two many-to-many associations they would share the same join table (author_book). Previously the way we got around this was to name the columns after the associations, but that caused the confusion hence the change.

Perfect. This explanation should go into the online docs (and into the book, I'm afraid )

Its already in the book