Hibernate one-to-one properties

5.1.11. one-to-one

A one-to-one association to another persistent class is declared using a one-to-one element.

(1)
     class="ClassName"                                            (2)
     cascade="cascade_style"                                      (3)
     constrained="true|false"                                     (4)
     fetch="join|select"                                          (5)
     property-ref="propertyNameFromAssociatedClass"               (6)
     access="field|property|ClassName"                            (7)
     formula="any SQL expression"                                 (8)
     lazy="proxy|no-proxy|false"                                  (9)
     entity-name="EntityName"                                     (10)
     node="element-name|@attribute-name|element/@attribute|."
     embed-xml="true|false"
     foreign-key="foreign_key_name"
/>

(1)	name: The name of the property.
(2)	class (optional - defaults to the property type determined by reflection): The name of the associated class.
(3)	cascade (optional) specifies which operations should be cascaded from the parent object to the associated object.
(4)	constrained (optional) specifies that a foreign key constraint on the primary key of the mapped table references the table of the associated class. This option affects the order in which save() and delete() are cascaded, and determines whether the association may be proxied (it is also used by the schema export tool).
(5)	fetch (optional - defaults to select): Chooses between outer-join fetching or sequential select fetching.
(6)	property-ref: (optional) The name of a property of the associated class that is joined to the primary key of this class. If not specified, the primary key of the associated class is used.
(7)	access (optional - defaults to property): The strategy Hibernate should use for accessing the property value.
(8)	formula (optional): Almost all one to one associations map to the primary key of the owning entity. In the rare case that this is not the case, you may specify a some other column, columns or expression to join on using an SQL formula. (See org.hibernate.test.onetooneformula for an example.)
(9)	lazy (optional - defaults to proxy): By default, single point associations are proxied. lazy="no-proxy" specifies that the property should be fetched lazily when the instance variable is first accessed (requires build-time bytecode instrumentation). lazy="false" specifies that the association will always be eagerly fetched. Note that if constrained="false", proxying is impossible and Hibernate will eager fetch the association!
(10)	entity-name (optional): The entity name of the associated class. Refer for more:::::: http://www.hibernate.org/hib_docs/reference/en/html/mapping.html

Hibernate many-to-one properties

5.1.10. many-to-one

An ordinary association to another persistent class is declared using a many-to-one element. The relational model is a many-to-one association: a foreign key in one table is referencing the primary key column(s) of the target table.

(1)
      column="column_name"                                         (2)
      class="ClassName"                                            (3)
      cascade="cascade_style"                                      (4)
      fetch="join|select"                                          (5)
      update="true|false"                                          (6)
      insert="true|false"                                          (6)
      property-ref="propertyNameFromAssociatedClass"               (7)
      access="field|property|ClassName"                            (8)
      unique="true|false"                                          (9)
      not-null="true|false"                                        (10)
      optimistic-lock="true|false"                                 (11)
      lazy="proxy|no-proxy|false"                                  (12)
      not-found="ignore|exception"                                 (13)
      entity-name="EntityName"                                     (14)
      formula="arbitrary SQL expression"                           (15)
      node="element-name|@attribute-name|element/@attribute|."
      embed-xml="true|false"
      index="index_name"
      unique_key="unique_key_id"
      foreign-key="foreign_key_name"
/>

(1)	name: The name of the property.
(2)	column (optional): The name of the foreign key column. This may also be specified by nested element(s).
(3)	class (optional - defaults to the property type determined by reflection): The name of the associated class.
(4)	cascade (optional): Specifies which operations should be cascaded from the parent object to the associated object.
(5)	fetch (optional - defaults to select): Chooses between outer-join fetching or sequential select fetching.
(6)	update, insert (optional - defaults to true) specifies that the mapped columns should be included in SQL UPDATE and/or INSERT statements. Setting both to false allows a pure "derived" association whose value is initialized from some other property that maps to the same colum(s) or by a trigger or other application.
(7)	property-ref: (optional) The name of a property of the associated class that is joined to this foreign key. If not specified, the primary key of the associated class is used.
(8)	access (optional - defaults to property): The strategy Hibernate should use for accessing the property value.
(9)	unique (optional): Enable the DDL generation of a unique constraint for the foreign-key column. Also, allow this to be the target of a property-ref. This makes the association multiplicity effectively one to one.
(10)	not-null (optional): Enable the DDL generation of a nullability constraint for the foreign key columns.
(11)	optimistic-lock (optional - defaults to true): Specifies that updates to this property do or do not require acquisition of the optimistic lock. In other words, dertermines if a version increment should occur when this property is dirty.
(12)	lazy (optional - defaults to proxy): By default, single point associations are proxied. lazy="no-proxy" specifies that the property should be fetched lazily when the instance variable is first accessed (requires build-time bytecode instrumentation). lazy="false" specifies that the association will always be eagerly fetched.
(13)	not-found (optional - defaults to exception): Specifies how foreign keys that reference missing rows will be handled: ignore will treat a missing row as a null association.
(14)	entity-name (optional): The entity name of the associated class.