## 5.2.1.1 One-to-one

A one-to-one relationship is the simplest kind, and is defined trivially using a property of the type of another domain class. Consider this example:

##### Example A

    class Face {
        Nose nose
    }
    class Nose {
    }

In this case we have unidirectional many-to-one relationship from `Face` to `Nose`. To make it a true one-to-one you should make `nose` unique:

    class Face {
        Nose nose
    	static constraints = {
    		nose unique:true
    	}
    }
    class Nose {
    }

To make this relationship bidirectional define the other side as follows:

##### Example B

    class Face {
        Nose nose
    }
    class Nose {
    	static belongsTo = [face:Face]
    }

In this case we use the `belongsTo` setting to say that `Nose` "belongs to" Face. The result of this is that we can create a Face and save it and the database updates/inserts will be cascaded down to `Nose`:

    new Face(nose:new Nose()).save()

The example above will save both face and nose. Note that the inverse is not true and will result in an error due to a transient `Face`:

    new Nose(face:new Face()).save() // will cause an error

Another important implication of `belongsTo` is that if you delete a `Face` instance the `Nose` will be deleted too:

    def f = Face.get(1)
    f.delete() // both Face and Nose deleted

In the previous example the foreign key associated the `Face` with the `Nose` is stored in the parent as column called `nose_id`. If you want the foreign key to be stored in the child you need a `hasOne` association:

##### Example C

    class Face {
        static hasOne = [nose:Nose]
    }
    class Nose {
    	Face face
    }

In this example you get a bidirectional one-to-one where the foreign key column is stored in the `nose` table inside a column called `face_id`.