Ordered Collection

In an earlier post we saw that hibernate provides us with the option to use Sorted Collections. In these collections the objects were fetched form the database and inserted into collections in a sorted order. Thus the sorting of elements happened in the Java Domain. This was an example of in-memory sorting.
Hibernate also provides an alternative to the above technique called ordered collections.
In this case the data is fetched in a particular sequence/order from the database. The sort is achieved by using the SQL order-by clause. I tried the same for a set of hobbies of a Person.

public class HobbiedPerson {
    private String name;
    private Integer id;
    private Set<String> hobbies = new HashSet<String>();
        //setter-getter methods 
}

The java class here includes a set of hobbies. The mapping file provides information of the ordering to be used

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="com.collection.basic">
    <class name="HobbiedPerson" table="HOBBIED_PERSON">
        <id name="id" type="integer">
            <column name="ID" />
            <generator class="identity" />
        </id>
        <property name="name" type="string">
            <column name="NAME" />
        </property>

        <set name="hobbies" table="PERSON_HOBBIES" order-by="lower(HOBBY) asc">
            <key column="PERSON_ID" />
            <element type="string" column="HOBBY" not-null="true" />
        </set>

    </class>
</hibernate-mapping>

As can be seen above the order-by attribute includes a SQL order-by clause, that specifies the ordering to be used by Hibernate when loading the collection. I executed a code to insert records in the database

static void createHobbiedPerson() {
    HobbiedPerson person = new HobbiedPerson();
    Set<String> hobbies = new HashSet<String>();
    hobbies.add("Tennis");
    hobbies.add("Philately");
    hobbies.add("Gaming");
    hobbies.add("Cooking");
    hobbies.add("Singing");
    person.setName("Raman");
    person.setHobbies(hobbies);
    Session session = sessionFactory.openSession();
    Transaction t = session.beginTransaction();
    session.save(person);
    t.commit();
}

The logs(cleaned) at start up are as follows:

2281 [main] DEBUG org.hibernate.loader.collection.BasicCollectionLoader  - Stati
c select for collection com.collection.basic.HobbiedPerson.hobbies: select hobbi
es0_.PERSON_ID as PERSON1_0_, hobbies0_.HOBBY as HOBBY0_ from PERSON_HOBBIES hob
bies0_ where hobbies0_.PERSON_ID=? order by lower(hobbies0_.HOBBY) asc
...
2375 [main] DEBUG org.hibernate.tool.hbm2ddl.SchemaExport  - 
    create table HOBBIED_PERSON (
        ID integer not null auto_increment,
        NAME varchar(255),
        primary key (ID)
    )
2390 [main] DEBUG org.hibernate.tool.hbm2ddl.SchemaExport  - 
    create table PERSON_HOBBIES (
        PERSON_ID integer not null,
        HOBBY varchar(255) not null,
        primary key (PERSON_ID, HOBBY)
    )
2406 [main] DEBUG org.hibernate.tool.hbm2ddl.SchemaExport  - 
    alter table PERSON_HOBBIES 
        add index FK2310BEE62D1D2FB8 (PERSON_ID), 
        add constraint FK2310BEE62D1D2FB8 
        foreign key (PERSON_ID) 
        references HOBBIED_PERSON (ID)
...
2593 [main] DEBUG org.hibernate.SQL  - 
    insert 
    into
        HOBBIED_PERSON
        (NAME) 
    values
        (?)
...

2656 [main] DEBUG org.hibernate.SQL  - 
    insert 
    into
        PERSON_HOBBIES
        (PERSON_ID, HOBBY) 
    values
        (?, ?)

The generated SQL select statement for the collection includes the order-by clause specified in the file.
On calling the session.create() method, the insert queries were fired.
The insertion logs indicate the data is inserted successfully.
An interesting to note in the insert logs was the order of hobby creation.

2469 [main] DEBUG org.hibernate.pretty.Printer  - listing entities:
2469 [main] DEBUG org.hibernate.pretty.Printer  - com.collection.basic.HobbiedPe
rson{id=1, name=Raman, hobbies=[Philately, Tennis, Cooking, Gaming, Singing]}
...
2531 [main] DEBUG org.hibernate.type.IntegerType  - binding '1' to parameter: 1
2531 [main] DEBUG org.hibernate.type.StringType  - binding 'Philately' to parame
ter: 2
2531 [main] DEBUG org.hibernate.type.IntegerType  - binding '1' to parameter: 1
2531 [main] DEBUG org.hibernate.type.StringType  - binding 'Tennis' to parameter
: 2
2531 [main] DEBUG org.hibernate.type.IntegerType  - binding '1' to parameter: 1
2531 [main] DEBUG org.hibernate.type.StringType  - binding 'Cooking' to paramete
r: 2
2531 [main] DEBUG org.hibernate.type.IntegerType  - binding '1' to parameter: 1
2531 [main] DEBUG org.hibernate.type.StringType  - binding 'Gaming' to parameter
: 2
2531 [main] DEBUG org.hibernate.type.IntegerType  - binding '1' to parameter: 1
2531 [main] DEBUG org.hibernate.type.StringType  - binding 'Singing' to paramete
r: 2

As can be seen, my order of insertion in the Set was not the order used in the insert queries generated.Which makes sense , since I used a HashSet and not LinkedHashSet. But the records generated in the database did not match my insert sequence.

On replacing the HashSet with a LinkedHasSet instance and keeping the rest of the cide same, the ordering was preserved:

2468 [main] DEBUG org.hibernate.pretty.Printer  - com.collection.basic.HobbiedPe
rson{id=1, name=Raman, hobbies=[Tennis, Philately, Gaming, Cooking, Singing]}

The insert queries were fired in the same sequence. But the database sequence of records remained unchanged. 
InfactI inserted a record "Moonlighting" for this person and then fired the select * query.
The result was :

I am still not sure why.
Fetching the records:

static void retrive() {
    Session session = sessionFactory.openSession();
    HobbiedPerson person = (HobbiedPerson) session.load(HobbiedPerson.class, 1);
    System.out.println(person.getHobbies());
}

The logs indicate the above SQL select query was fired and the output indicates the
Set contains data in the ascending order:

2657 [main] DEBUG org.hibernate.event.def.DefaultInitializeCollectionEventListen
er  - collection initialized
[Cooking, Gaming, Philately, Singing, Tennis]

Hibernate internally represents the set as a LinkedHashSet, thus successfully preserving the insertion order.
The same can be implemented for the other collections.

1. Map: Hibernate ensures the ordering using a LinkedHashMap
2. Bag: Hibernate ensures an ordered bag by internally using an ArrayList.

The functionality is not available for the list elements, as list have their own index column to manage the order.