7 Object Relational Mapping (GORM) 3.2.7

(Quick Reference) # 7 Object Relational Mapping (GORM) Version: 3.2.7 ## Table of Contents # 7 Object Relational Mapping (GORM) Domain classes are core to any business application. They hold state about business processes and hopefully also implement behavior. They are linked together through relationships; one-to-one, one-to-many, or many-to-many. GORM is Grails' object relational mapping (ORM) implementation. Under the hood it uses Hibernate (a very popular and flexible open source ORM solution) and thanks to the dynamic nature of Groovy with its static and dynamic typing, along with the convention of Grails, there is far less configuration involved in creating Grails domain classes. You can also write Grails domain classes in Java. See the section on Hibernate Integration for how to write domain classes in Java but still use dynamic persistent methods. Below is a preview of GORM in action:
    def book = Book.findByTitle("Groovy in Action")

    book
      .addToAuthors(name:"Dierk Koenig")
      .addToAuthors(name:"Guillaume LaForge")
      .save()
## 7.1 Quick Start Guide A domain class can be created with the create-domain-class command:
    grails create-domain-class helloworld.Person
| If no package is specified with the create-domain-class script, Grails automatically uses the application name as the package name.
This will create a class at the location `grails-app/domain/helloworld/Person.groovy` such as the one below:
    package helloworld

    class Person {
    }
| If you have the `dbCreate` property set to "update", "create" or "create-drop" on your DataSource, Grails will automatically generate/modify the database tables for you.
You can customize the class by adding properties:
    class Person {
        String name
        Integer age
        Date lastVisit
    }
Once you have a domain class try and manipulate it with the shell or console by typing:
    grails console
This loads an interactive GUI where you can run Groovy commands with access to the Spring ApplicationContext, GORM, etc. ## 7.1.1 Basic CRUD Try performing some basic CRUD (Create/Read/Update/Delete) operations. ### Create To create a domain class use Map constructor to set its properties and call save:
    def p = new Person(name: "Fred", age: 40, lastVisit: new Date())
    p.save()
The save method will persist your class to the database using the underlying Hibernate ORM layer. ### Read Grails transparently adds an implicit `id` property to your domain class which you can use for retrieval:
    def p = Person.get(1)
    assert 1 == p.id
This uses the get method that expects a database identifier to read the `Person` object back from the database. You can also load an object in a read-only state by using the read method:
    def p = Person.read(1)
In this case the underlying Hibernate engine will not do any dirty checking and the object will not be persisted. Note that if you explicitly call the save method then the object is placed back into a read-write state. In addition, you can also load a proxy for an instance by using the load method:
    def p = Person.load(1)
This incurs no database access until a method other than getId() is called. Hibernate then initializes the proxied instance, or throws an exception if no record is found for the specified id. ### Update To update an instance, change some properties and then call save again:
    def p = Person.get(1)
    p.name = "Bob"
    p.save()
### Delete To delete an instance use the delete method:
    def p = Person.get(1)
    p.delete()
## 7.2 Further Reading on GORM For more information on using GORM see the dedicated documentation for the GORM project. | Quick Reference (hide)