Grails Persistence Decision: Hibernate SQL vs GORM MongoDB for Grails 4.x

The decision you're facing

You are building a Grails 4.x web app and must choose a persistence mechanism. The constraints are concrete: you need ACID transactions for multi-entity writes, the team has SQL expertise, and you expect moderate horizontal scaling. The useful takeaway is that Hibernate with a relational database is the default for those constraints; GORM MongoDB is viable only when schema flexibility and easy sharding outweigh strong transactional guarantees.

Constraints that shape the choice

ACID compliance means Atomicity, Consistency, Isolation, Durability. For a service that creates a Book and links an Author in one unit of work, you want a rollback if either fails.

Team SQL expertise reduces onboarding cost for Hibernate SQL. Horizontal scaling needs influence whether you prefer vertical DB scaling with read replicas or native sharding.

Supported options at a glance

Trade-offs in practice

Hibernate gives strong consistency, rich joins, and mature tooling. It scales mainly vertically and requires schema changes for evolving models.

MongoDB offers flexible schema and easy sharding. It provides eventual consistency by default and lacks complex joins. Multi-document transactions are available only on a replica set and add latency.

Operational overhead differs. SQL needs migration tooling. MongoDB needs careful index design and replica set health monitoring.

Concrete Hibernate configuration and domain example

Run from the project root. Database credentials require create and select permissions on the target schema.

# grails-app/conf/application.yml
dataSource:
  url: jdbc:postgresql://${DB_HOST:localhost}/${DB_NAME:grailsdb}
  driverClassName: org.postgresql.Driver
  username: ${DB_USER}
  password: ${DB_PASS}
  pooled: true
hibernate:
  hbm2ddl: update

Ensure Grails version matches plugin versions, e.g., GORM 7.x for Hibernate 5.x, to avoid classpath conflicts.

// grails-app/domain/com/example/Book.groovy
package com.example
class Book {
  String title
  Author author
  static constraints = {}

Risk: hbm2ddl update is not safe for production. Use a migration tool for schema changes.

// grails-app/services/com/example/BookService.groovy
package com.example
import grails.gorm.transactions.Transactional
@Transactional
class BookService {
  Book saveBook(String title, Author author) {
    new Book(title: title, author: author).save(failOnError: true)
  }

// grails-app/controllers/com/example/BookController.groovy
package com.example
class BookController {
  BookService bookService
  def create() {
    def book = bookService.saveBook(params.title, Author.get(params.authorId))
    respond book
  }

Validation pattern to prove transactional behavior

Write an integration test using Grails Testing Support to verify rollback.

// src/integration-test/groovy/com/example/BookServiceIntegrationSpec.groovy
package com.example
import grails.testing.mixin.integration.Integration
import spock.lang.Specification
@Integration
class BookServiceIntegrationSpec extends Specification {
  BookService bookService
  def 'save rolls back on exception'() {
    given:
    def author = new Author(name: 'A').save(failOnError: true)
    when:
    bookService.saveBook('T', author)
    then:
    Book.countByTitle('T') == 1
    when:
    bookService.metaClass.saveBook = { String t, Author a -> throw new RuntimeException('boom') }
    bookService.saveBook('T2', author)
    then:
    thrown(RuntimeException)
    and:
    Book.countByTitle('T2') == 0
  }

Run from project root with permission to execute tests and access the test database:

grails test-app

Expected checks: the integration test passes and the rollback assertion holds, meaning no Book with title T2 persists after the exception. Inspect console logs for Hibernate SQL INSERT and SELECT statements and confirm no unexpected writes occur after rollback.

Limitations and how to check the result

MongoDB multi-document transactions require MongoDB 4.0+ replica set; standalone instances will not provide ACID guarantees across multiple collections.

Check the result by inspecting the test database after the test run and by reviewing Hibernate SQL logs or MongoDB driver logs for the expected statements. If you choose MongoDB, verify replica set status and enable transactions explicitly in the service.