One-to-many relationships
Let's assume that there are two domain classes and you need to create one-to-many relationship from one domain to another. For this purpose, you can use static hasMany property at the "one" side:
1
2
3
4
5
class User {
static hasMany = [articles: Article]
}
class Article {
}
Two things happens here:
- GORM creates a join table in the database:
- Grails automatically injects Set of Articles into the User domain (you can refer to them by the articles property)
Relationship I've described defines cascade relationships between two classes, i.e. cascading behavior for saving and updating. For example:
1
2
3
4
def user = new User()
def article = new Article()
user.addToArticles(article)
user.save()
We've used dynamic addToArticles method to add created article to user. We did not save the article manually, but it was saved by cascade. In spite of cascading behavior for saving and updating, this won't work for deleting. When you delete a user, only relationships between the user and the articles will be removed, but not the articles themselves (the records will be removed from the join table only). There are two ways to delete articles by cascade:
Use belongsTo in the Article class:
1 2 3 4 5 6 7
class User { static hasMany = [articles: Article] } class Article { static belongsTo = User }Configure cascading behavior of the association using the following mapping:
1 2 3 4 5 6 7 8 9
class User { static hasMany = [articles: Article] static mapping = { articles cascade: 'all-delete-orphan' } } class Article { }
In both of these cases, GORM creates a join table as well, but now you may not worry about the user articles deleting, because they will be deleted by cascade when you delete a user.
Relationships direction
Domains relationships can be either unidirectional or bidirectional. Have a look at the next example:
1
2
3
4
5
6
class User {
static hasMany = [articles: Article]
}
class Article {
static belongsTo = User
}
This is a unidirectional relationship: you can get user's articles via the articles set, but you cannot refer to the user from one of the articles. All the relationships in examples above are unidirectional. You can add back references (i.e. properties linking back to the owner) in one of the following ways:
1
2
3
4
5
6
7
8
class Article {
static belongsTo = [user: User]
}
or:
class Article {
User user
static belongsTo = User
}
Both of these examples describes bidirectional relationships, so you can refer from one of the articles to its owner
through the user link. In this case, GORM will not create join table. The bidirectional relationship will be mapped
through a straight foreign key on the 'articles' table: 
Few examples of the referring to the User:
1
2
3
4
5
6
7
8
9
10
11
def user = new User()
def articles = [new Article(), new Article()]
articles.each { article ->
user.addToArticles(article)
}
user.save()
assert Article.countByUser(user), 2 // countByUser method can't be executed without the _user_ property in the _Article_
class
articles.each {article ->
assert article.user.id, user.id // true for both of articles
}
One-to-one
There are two ways of specifying one-to-one relationship:
Add an article property and unique constraint to the User class:
1 2 3 4 5 6 7 8 9 10
class User { Article article static constraints = { article(unique: true) } } class Article { static belongsTo = [user: User] }Use hasOne property on the owning (User) side:
1 2 3 4 5 6 7
class User { static hasOne = [article: Article] } class Article { static belongsTo = [user: User] }
hasOne works with bidirectional relationships only (you should have belongsTo with back reference to the User class in the Article class). If it's missing, you'll get the following exception during project compilation:
1
2
org.hibernate.MappingException: hasOne property [User.article] is not bidirectional. Specify the other side of the
relationship!
Note that the difference between those two cases is that GORM will put foreign key to the different tables:
to the 'user' table in the first case:
to the 'article' table in the second case:
Many-to-many
Many-to-many relationships in Grails are specified by defining a hasMany on both sides of the relationship and having a belongsTo on the owned side:
1
2
3
4
5
6
7
class Tag {
static belongsTo = Post
static hasMany = [posts: Post]
}
class Post {
static hasMany = [tags: Tag]
}
In this case, GORM will create the post_tags join table with the following columns: post_id and tag_id. These fields are foreign keys. GORM will perform cascade saving and removing of relationships if you save / remove an object of the Post domain class only, because it's the relationship owner. The following example may clarify:
1
2
3
4
5
def post = new Post()
post.addToTags(new Tag())
post.addToTags(new Tag())
new Tag().addToPosts(post)
post.save()
Here, three new tags were saved in the database by cascade. If you want to remove a tag, you need to remove its relationships with posts first. But if you delete certain post, its relationships with tags will be removed from the database automatically:
1
2
3
4
5
6
7
8
def tag = Tag.get(1)
def posts = [] + tag.posts ?: []
posts.each { Post post ->
post.removeFromTags(tag)
}
tag.delete()
Post.get(1).delete()
note: I have copied tag's posts to the new collection to avoid the ConcurrentModificationException exception.
Another way to create many-to-many relationship is manual join table mapping. All you need is:
- create the PostTag domain class with fields of Post and Tag classes and composite primary key
- make the PostTag class serializable as it is a Hibernate composite primary key class
- remove hasMany and belongsTo from the Tag and Post domains
- map the PostTag class to existing 'post_tags' table in case of you don't want to make current database changes
1
2
3
4
5
6
7
8
9
10
class PostTag implements Serializable {
Post post
Tag tag
static mapping = {
id composite: ['tag', 'post']
table 'post_tags'
}
}
In this case, you'll need to save and delete PostTag objects explicitly. Note that if you'll try to delete some post or tag without deleting its relationships before, you'll get the MySQLIntegrityConstraintViolationException exception and no object will be removed from the database:
1
2
com.mysql.jdbc.exceptions.jdbc4.MySQLIntegrityConstraintViolationException: Cannot delete or update a parent row:
a foreign key constraint fails (`gorm_db`.`post_tags`, CONSTRAINT `FK74F452DAF7BD8628` FOREIGN KEY (`post_id`) REFERENCES `post` (`id`))
In order to get saved relationships, you can use standard Grails dynamic methods of the PostTag class (find, findAll, list).
Dmitriy Drenkalyuk,
SysGears
