Related to Hibernate

Hibernate also provides the nice implementation, which is in hibernate-annotations (merged into core from v3.6.0). Sample of usage:

<hibernate-mapping>
    <class name="Relationship" table="relationships">
        ...
        <property name="semanticType">
            <type name="org.hibernate.type.EnumType">
                <param name="enumClass">org.mycompany.dao.SemanticType</param>
            </type>
        </property>
    </class>
</hibernate-mapping>

public void initializeLazyCollection(MyBean bean) {
    final Session session = getSessionFactory().openSession();
 
    try {
        // Associate the bean with a session:
        session.lock(bean, LockMode.READ);
 
        Hibernate.initialize(bean.getChildren());
    }
    finally {
        session.close();
    }
}

Alternatively you may use Glead (see also Using GWT with Hibernate).

• all entity insertions, in the same order the corresponding objects were saved using session.save()
• all entity updates
• all collection deletions
• all collection element deletions, updates and insertions
• all collection insertions
• all entity deletions, in the same order the corresponding objects were deleted using session.delete()

and the only solution is to flush the session after collection.clear().

Alternative solution is to walk the entity tree and re-assign the IDs.

CREATE TABLE document
(
    id        INTEGER UNSIGNED NOT NULL AUTO_INCREMENT,
    country        VARCHAR(255) NOT NULL,
    indexed_date    datetime NOT NULL,
    CONSTRAINT document_pk PRIMARY KEY (id)
) engine=InnoDB;
 
CREATE TABLE image
(
    document_id    INTEGER UNSIGNED NOT NULL,
    page_number    INTEGER UNSIGNED NOT NULL,
    image_data    longblob NOT NULL,
    CONSTRAINT image_pk PRIMARY KEY (document_id, page_number),
    CONSTRAINT image_fk FOREIGN KEY (document_id) REFERENCES document (id) ON DELETE cascade
) engine=InnoDB;

In our example we will not introduce the synthetic key for image table to show how to deal with composite ID, which in our case is (document_id, page_number). The mapping is:

<?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.mycompany.myproject.common">
    <class name="Document" table="document">
        <id name="id">
            <generator class="native" />
        </id>
 
        <property name="country" />
        <property name="indexedDate" column="indexed_date" />
 
        <bag name="images" order-by="page_number" cascade="all-delete-orphan" lazy="true" inverse="true" fetch="select">
            <key column="document_id" />
 
            <one-to-many class="DocumentImage" />
        </bag>
    </class>
 
    <class name="DocumentImage" table="image">
        <composite-id>
            <key-many-to-one name="parentDocument" class="Document" column="document_id" />
            <key-property name="pageNumber" column="page_number" />
        </composite-id>
 
        <property name="imageData" column="image_data" />
    </class>
</hibernate-mapping>

<class name="DocumentImage" table="image">
    <composite-id>
        <key-property name="documentId" column="document_id" />
        <key-property name="pageNumber" column="page_number" />
    </composite-id>
    ...
</class>

Java code example:

Document document = new Document();
 
document.setIndexedDate(new Timestamp(9876543210L));
document.setCountry("USA")
 
Collection<DocumentImage> images = new ArrayList<DocumentImage>();
 
{
    final DocumentImage image = new DocumentImage();
 
    image.setPageNumber(1);
    image.setImageData("ANdj17shOL12p".getBytes());
    image.setParentDocument(document);
 
    images.add(image);
}
 
{
    final DocumentImage image = new DocumentImage();
 
    image.setPageNumber(2);
    image.setImageData("(*&$@!9&!".getBytes());
    image.setParentDocument(document);
 
    images.add(image);
}
 
document.setImages(images);
 
Session session = getSessionFactory().openSession();
 
session.saveOrUpdate(document);
session.flush();
session.close();

org.hibernate.HibernateException: A collection with cascade="all-delete-orphan" was no longer referenced by the owning entity instance: com.mycompany.myproject.common.Document.images
    at org.hibernate.engine.Collections.processDereferencedCollection(Collections.java:118)
    at org.hibernate.engine.Collections.processUnreachableCollection(Collections.java:62)
    at org.hibernate.event.def.AbstractFlushingEventListener.flushCollections(AbstractFlushingEventListener.java:241)
    at org.hibernate.event.def.AbstractFlushingEventListener.flushEverythingToExecutions(AbstractFlushingEventListener.java:100)
    at org.hibernate.event.def.DefaultFlushEventListener.onFlush(DefaultFlushEventListener.java:50)
    at org.hibernate.impl.SessionImpl.flush(SessionImpl.java:1206)

For more examples of how to use bidirectional associations with composite keys, see examples that come together with Hibernate distribution (e.g. have a loot at hibernate-distribution.tar.gz/project\testsuite\src\test\java\org\hibernate\test\legacy\Middle.hbm.xml).

Cascade delete means if parent entity is deleted, delete the related entities. delete-orphan means: if an entity is removed from a related one-to-many collection, then not only disassociate it from the current entity, but delete it (does not allow it to stay orphan).

all-delete-orphan and all,delete-orphan are synonyms and should result the same behaviour (see here).

• if inverse='false' then when collection entry is removed, the parent key is set to null (update child set parent_id = null where parent_id = ?)
• if inverse='true' then when collection entry is removed, it is deleted by key (delete from child where id = ?)

<?xml version="1.0" encoding="UTF-8"?>
<beans
    xmlns="http://www.springframework.org/schema/beans"
    xmlns:mvc="http://www.springframework.org/schema/mvc"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans    http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
        http://www.springframework.org/schema/mvc    http://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd">
 
    <mvc:interceptors>
        <bean class="org.springframework.orm.hibernate3.support.OpenSessionInViewInterceptor">
            <property name="sessionFactory" ref="hibernateSessionFactory" />
        </bean>
    </mvc:interceptors>
</beans>

To Unit test it you need a helper method, that repeats the functionality of Spring DispatcherServlet:

public abstract class AbstractTest {
 
    @Autowired
    protected HandlerAdapter            handlerAdapter;
 
    @Autowired
    protected HandlerMapping            handlerMapping;
 
    protected MockHttpServletRequest    request        = new MockHttpServletRequest();
    protected MockHttpServletResponse    response    = new MockHttpServletResponse();
 
    /**
     * This function feeds the given request to Spring MVC. The code is a simplified flow from
     * {@link org.springframework.web.servlet.DispatcherServlet}.
     */
    protected void handleRequest() throws Exception {
        final HandlerExecutionChain handler = handlerMapping.getHandler(request);
        final HandlerInterceptor[] interceptors = handler.getInterceptors();
 
        if (interceptors != null) {
            for (int i = 0; i < interceptors.length; i++) {
                if (!interceptors[i].preHandle(request, response, handler.getHandler())) {
                    throw new IllegalStateException("The interceptor " + interceptors[i]
                                + " prevents the request from being processed");
                }
            }
        }
 
        handlerAdapter.handle(request, response, handler.getHandler());
    }
 
    /**
     * The same as {@link #handleRequest()} but sets a request URL beforehand.
     */
    protected void handleRequest(String requestURI) throws Exception {
        request.setRequestURI(requestURI);
        handleRequest();
    }
}

Alternatively, you can use the following code (assuming that property HibernateTemplate.alwaysUseNewSession = false):

SessionFactoryUtils.initDeferredClose(getHibernateTemplate().getSessionFactory());
 
try {
    getHibernateTemplate().doSomething();
    ...
    getHibernateTemplate().doAgain();
}
finally {
    SessionFactoryUtils.processDeferredClose(getHibernateTemplate().getSessionFactory());
}

final Session session = getSessionFactory().getCurrentSession();
 
if (session instanceof SessionImplementor) {
    ((SessionImplementor) session).setAutoClear(true);
}

You may also wish to disable the 2^nd level cache and analyse the heap dump (export JAVA_OPTS=-verbose:gc -XX:+PrintClassHistogram -XX:+PrintGCDetails -Xloggc:/tmp/jvm_loggc.log -XX:+HeapDumpOnOutOfMemoryError -XX:HeapDumpPath=/tmp + Memory Analyzer). See the complete note.

<sql-query name="myQuery">
    <query-param name="days" type="int" />
    <return-scalar column="count" type="int" />
    <return-scalar column="section_name" type="string" />
    <![CDATA[select count(id) as count, section_name from document where days <= :days]]>
</sql-query>

or programmatically via org.hibernate.SQLQuery#addScalar(String columnAlias, Type type).