Investigating Hibernate Associations – One to Many

My previous post covered one-to-one associations in Hibernate. This will cover one-to-many associations in Hibernate.

We will continue to the configuration and classes as defined in the previous post. Let me recap. Here’s the hibernate.cfg.xml

<hibernate-configuration>
    <session-factory>

        <!-- Database connection settings -->
        <property name="connection.driver_class">
        	com.mysql.jdbc.Driver
        </property>
        <property name="connection.url">
		jdbc:mysql://localhost:3306/<dbname>
	</property>
        <property name="connection.username"><username></property>
        <property name="connection.password"><password></property>
	<property name="transaction.factory_class">
		org.hibernate.transaction.JDBCTransactionFactory
	</property>

        <!-- JDBC connection pool (use the built-in) -->
        <property name="connection.pool_size">1</property>

        <!-- SQL dialect -->
        <property name="dialect">
		org.hibernate.dialect.MySQL5InnoDBDialect
	</property>

        <!-- Enable Hibernate's automatic session context management -->
        <property name="current_session_context_class">thread</property>

        <!-- Disable the second-level cache  -->
        <property name="cache.provider_class">
		org.hibernate.cache.NoCacheProvider
	</property>

        <!-- Echo all executed SQL to stdout -->
        <property name="show_sql">true</property>

        <!-- Drop and re-create the database schema on startup -->
        <property name="hbm2ddl.auto">update</property>
        <property name="hibernate.max_fetch_depth">1</property>

        <mapping resource="com/tutorial/hibernate/simple/Person.hbm.xml"/>
        <mapping resource="com/tutorial/hibernate/simple/Phone.hbm.xml"/>

    </session-factory>
</hibernate-configuration>

The Person.hbm.xml and Phone.hbm.xml is as below:

<hibernate-mapping package="com.tutorial.hibernate.simple">

    <class name="Person" table="PERSON" dynamic-update="true"
	dynamic-insert="true" select-before-update="false">
        <id name="id">
            <generator class="assigned"/>
        </id>
        <property name="firstName"/>
        <property name="lastName"/>
        <property name="dob" type="date" />

    </class>

</hibernate-mapping>

<hibernate-mapping package="com.tutorial.hibernate.simple">

    <class name="Phone" table="PHONE" dynamic-update="true"
	dynamic-insert="true" select-before-update="false">
        <id name="id">
            <generator class="assigned"/>
        </id>
        <property name="number" column="contactnumber"/>
        <property name="type" column="phonetype"/>
    </class>

</hibernate-mapping>

We are now step up to start working on developing one-to-many associations. Here’s how we will define the relationalship in tables as per following format:

    _____________        __________
   |             |      |          |
   |   PERSON    |      |   PHONE  |
   |_____________|      |__________|
   |             | 1  * |          |
   | ID          | ---- | ID       |
   | FIRSTNAME   |      | NUMBER   |
   | LASTNAME    |      | TYPE     |
   | DOB         |      | PERSONID |
   |_____________|      |__________|

Define the one-to-many association between person and phone in the following manner:

	<set name="phones">
		<key column="personid" not-null="true"/>
		<one-to-many class="Phone"/>
	</set>

Make the following additions in the Person.java file.

	private Set phones = new HashSet();

	public Set getPhones() {
		return phones;
	}

	public void addPhone(Phone phone) {
		this.phones.add(phone);
	}

	public void setPhones(Set phones) {
		this.phones = phones;
	}

Here’s the test program:

	Configuration cfg = new Configuration();
	cfg.configure();
	SessionFactory sessFactory = cfg.buildSessionFactory();
	try {
		Session session = sessFactory.openSession();

		Person p = new Person();
		p.setId("21823");
		p.setFirstName("T1om");
		p.setLastName("Jones");
		p.setDob(new java.util.Date());

		Phone ph = new Phone();
		ph.setId("123");
		ph.setNumber("3033838");
		ph.setType("BUS");
		p.addPhone(ph);

		Transaction tx = session.beginTransaction();
		session.save(p);
		tx.commit();

		session = sessFactory.openSession();
		Query q = session.createQuery("FROM Person as p" +
			" WHERE p.id = 21823");
		List l = q.list();
		System.out.println("Result Size: " + l.size());
		session.close();

	} catch(Exception e) {
		e.printStackTrace();
	}

The output generated shows an exception:

Hibernate: insert into PERSON (firstName, lastName, dob, id)
	       values (?, ?, ?, ?)
Hibernate: update PHONE set personid=? where id=?
	   org.hibernate.StaleStateException: Batch update
	   returned unexpected row count from update [0];
	   actual row count: 0; expected: 1
	   at org.hibernate.jdbc.Expectations$BasicExpectation.checkBatched
	   (Expectations.java:61)

The Person INSERT is generated appropriately. However no Phone INSERT script is generated. Hibernate directly moves on to updating the Phone table with personid information. Make the following change in the one-to-many association definition.

	<set name="phones" cascade="all">
		<key column="personid" not-null="true"/>
		<one-to-many class="Phone"/>
	</set>

Now run the sample program. Presto it works.

Hibernate: select phone_.id, phone_.contactnumber as contactn2_1_,
	   phone_.phonetype as phonetype1_ from PHONE phone_
	   where phone_.id=?
Hibernate: insert into PERSON (firstName, lastName, dob, id)
	   values (?, ?, ?, ?)
Hibernate: insert into PHONE (contactnumber, phonetype, personid, id)
	   values (?, ?, ?, ?)
Hibernate: update PHONE set personid=? where id=?
Hibernate: select person0_.id as id0_, person0_.firstName as firstName0_,
	   person0_.lastName as lastName0_, person0_.dob as dob0_
	   from PERSON person0_ where person0_.id=21823
Result Size: 1

The query on the Person is not retrieving the phones. Hence it is working as expected. In case we intend to retrieve the phones information along with the Person information make the following change in the query:

FROM Person as p LEFT OUTER JOIN p.phones WHERE p.id = 21823

The query generated is as follows:

select person0_.id as id0_0_, phones1_.id as id1_1_,
person0_.firstName as firstName0_0_, person0_.lastName as lastName0_0_,
person0_.dob as dob0_0_, phones1_.contactnumber as contactn2_1_1_,
phones1_.phonetype as phonetype1_1_
from PERSON person0_ left outer join PHONE phones1_
on person0_.id=phones1_.personid where person0_.id=21823

There is one other aspect to look at. An unnecessary UPDATE script is getting created.

update PHONE set personid=? where id=?

There is a way to get rid of this UPDATE. Here’s how. Change the one-to-many definition in the Person.hbm.xml file as follows:

	<set name="phones" cascade="all" inverse="true">
		<key column="personid" not-null="true"/>
		<one-to-many class="Phone"/>
	</set>

Add the following definition in the Phone.hbm.xml file.

<many-to-one name="person" class="Person" not-null="false"
	column="personid"/>

Add the following code in the Phone.java file.

	private Person person = null;

	public Person getPerson() {
		return person;
	}

	public void setPerson(Person person) {
		this.person = person;
	}

Run the sample program. The output is as below:

Hibernate: select phone_.id, phone_.contactnumber as contactn2_1_,
	   phone_.phonetype as phonetype1_, phone_.personid as personid1_
	   from PHONE phone_ where phone_.id=?
Hibernate: insert into PERSON (firstName, lastName, dob, id)
	   values (?, ?, ?, ?)
Hibernate: insert into PHONE (contactnumber, phonetype, id)
	   values (?, ?, ?)
Hibernate: select person0_.id as id0_, person0_.firstName as firstName0_,
	   person0_.lastName as lastName0_, person0_.dob as dob0_
	   from PERSON person0_ where person0_.id=21823
	   Result Size: 1

We have got rid of the UPDATE script. However in the database we will notice that the personid field in the PHONE table is set to null. Make the following change in the addPhone method of Person.

	public void addPhone(Phone phone) {
		phone.setPerson(this);
		this.phones.add(phone);
	}

A final point, hibernate generates a SELECT query on Phone before proceeding with the inserts(Thanks Basker, getting my attention and making me look into this aspect). If you want to get rid of the SELECT query, change the id declaration in Phone.hbm.xml to the following:

        <id name="id" unsaved-value="any">
            <generator class="assigned" />
        </id>

Note the unsaved-value=”any” added in the declaration. This ensures that the SELECT query does not get generated. The new hibernate output will be as follows:

Hibernate: insert into PERSON (firstName, lastName, dob, id) values (?, ?, ?, ?)
Hibernate: insert into PHONE (contactnumber, phonetype, personid, id) values (?, ?, ?, ?)
Hibernate: select person0_.id as id0_, person0_.firstName as firstName0_, person0_.lastName
           as lastName0_, person0_.dob as dob0_ from PERSON person0_ where person0_.id=21823
           Result Size: 1

That’s all for the moment. Next time I will move on to many-to-many associations.

---

Possibly related posts: (automatically generated)

• Investigating Hibernate Associations – One to One
• Investigating Hibernate Associations – Cascading Styles
• Struts 2 + Spring 2 + JPA + AJAX
• Entry for August 03, 2008