Java tutorial
/* * Copyright 2004-2009 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package org.compass.gps.device.jpa.indexer; import java.util.Arrays; import java.util.HashMap; import java.util.Map; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; import org.compass.core.CompassSession; import org.compass.gps.device.jpa.EntityManagerWrapper; import org.compass.gps.device.jpa.JpaGpsDevice; import org.compass.gps.device.jpa.JpaGpsDeviceException; import org.compass.gps.device.jpa.entities.EntityInformation; import org.compass.gps.device.jpa.queryprovider.HibernateJpaQueryProvider; import org.compass.gps.device.support.parallel.IndexEntity; import org.hibernate.CacheMode; import org.hibernate.Criteria; import org.hibernate.ObjectNotFoundException; import org.hibernate.ScrollMode; import org.hibernate.ScrollableResults; import org.hibernate.Session; import org.hibernate.criterion.Order; import org.hibernate.ejb.HibernateEntityManager; import org.hibernate.ejb.HibernateQuery; import org.hibernate.metadata.ClassMetadata; /** * A Hibernate indexer uses Hibernate <code>ScrollableResults</code> to index the database * instead of using <code>setFirstResult</code> and <code>setMaxResults</code>. Using scrollable * results yields better performance especially for large result set. * * <p>Also takes into accont if using {@link HibernateJpaQueryProvider} by called its <code>createCriteria</code> * instead of the default <code>createQuery</code>. The criteria better handles outer joins, allows to set the * fetch size, and automatically supports ordering by the ids of the entities. * * <p>Note, if using {@link org.compass.gps.device.jpa.JpaGpsDevice#setIndexSelectQuery(Class, String)} will cause * not to be able to use <code>Criteria</code>. Instead, make sure to use {@link org.compass.gps.device.jpa.JpaGpsDevice#setIndexQueryProvider(Class, org.compass.gps.device.jpa.queryprovider.JpaQueryProvider)} * and provider your own extension on top of {@link org.compass.gps.device.jpa.queryprovider.HibernateJpaQueryProvider} * that returns your own <code>Criteria</code>. * * @author kimchy */ public class HibernateJpaIndexEntitiesIndexer implements JpaIndexEntitiesIndexer { private static final Log log = LogFactory.getLog(HibernateJpaIndexEntitiesIndexer.class); private JpaGpsDevice jpaGpsDevice; private boolean performOrderById = true; private Map<String, Boolean> performOrderByPerEntity = new HashMap<String, Boolean>(); public void setJpaGpsDevice(JpaGpsDevice jpaGpsDevice) { this.jpaGpsDevice = jpaGpsDevice; } /** * Should this indxer order by the ids when <code>Criteria</code> is available. * Defaults to <code>true</code>. */ public void setPerformOrderById(boolean performOrderById) { this.performOrderById = performOrderById; } /** * Should this indxer order by the ids when <code>Criteria</code> is available for * the given entity. Defaults to {@link #setPerformOrderById(boolean)}. */ public void setPerformOrderById(String entity, boolean performOrderById) { performOrderByPerEntity.put(entity, performOrderById); } public void performIndex(CompassSession session, IndexEntity[] entities) { for (IndexEntity indexEntity : entities) { EntityInformation entityInformation = (EntityInformation) indexEntity; if (jpaGpsDevice.isFilteredForIndex(entityInformation.getName())) { continue; } int fetchCount = jpaGpsDevice.getFetchCount(); if (!jpaGpsDevice.isRunning()) { return; } EntityManagerWrapper wrapper = jpaGpsDevice.getEntityManagerWrapper().newInstance(); ScrollableResults cursor = null; try { wrapper.open(); HibernateEntityManager entityManager = (HibernateEntityManager) wrapper.getEntityManager(); entityManager.getSession().setCacheMode(CacheMode.IGNORE); if (log.isDebugEnabled()) { log.debug(jpaGpsDevice.buildMessage("Indexing entities [" + entityInformation.getName() + "] using query [" + entityInformation.getQueryProvider() + "]")); } if (entityInformation.getQueryProvider() instanceof HibernateJpaQueryProvider) { Criteria criteria = ((HibernateJpaQueryProvider) entityInformation.getQueryProvider()) .createCriteria(entityManager, entityInformation); if (criteria != null) { if (performOrderById) { Boolean performOrder = performOrderByPerEntity.get(entityInformation.getName()); if (performOrder == null || performOrder) { ClassMetadata metadata = entityManager.getSession().getSessionFactory() .getClassMetadata(entityInformation.getName()); String idPropName = metadata.getIdentifierPropertyName(); if (idPropName != null) { criteria.addOrder(Order.asc(idPropName)); } } } criteria.setFetchSize(fetchCount); cursor = criteria.scroll(ScrollMode.FORWARD_ONLY); } } if (cursor == null) { HibernateQuery query = (HibernateQuery) entityInformation.getQueryProvider() .createQuery(entityManager, entityInformation); cursor = query.getHibernateQuery().scroll(ScrollMode.FORWARD_ONLY); } // store things in row buffer to allow using batch fetching in Hibernate RowBuffer buffer = new RowBuffer(session, entityManager.getSession(), fetchCount); Object prev = null; while (true) { try { if (!cursor.next()) { break; } } catch (ObjectNotFoundException e) { continue; } Object item = cursor.get(0); if (item != prev && prev != null) { buffer.put(prev); } prev = item; if (buffer.shouldFlush()) { // put also the item/prev since we are clearing the session // in the flush process buffer.put(prev); buffer.flush(); prev = null; } } if (prev != null) { buffer.put(prev); } buffer.close(); cursor.close(); entityManager.clear(); wrapper.close(); } catch (Exception e) { log.error(jpaGpsDevice.buildMessage("Failed to index the database"), e); if (cursor != null) { try { cursor.close(); } catch (Exception e1) { log.warn(jpaGpsDevice.buildMessage("Failed to close cursor on error, ignoring"), e1); } } wrapper.closeOnError(); if (!(e instanceof JpaGpsDeviceException)) { throw new JpaGpsDeviceException(jpaGpsDevice.buildMessage("Failed to index the database"), e); } throw (JpaGpsDeviceException) e; } } } private class RowBuffer { private Object[] buffer; private int fetchCount; private int index = 0; private CompassSession compassSession; private Session hibernateSession; RowBuffer(CompassSession compassSession, Session hibernateSession, int fetchCount) { this.compassSession = compassSession; this.hibernateSession = hibernateSession; this.fetchCount = fetchCount; this.buffer = new Object[fetchCount + 1]; } public void put(Object row) { buffer[index] = row; index++; } public boolean shouldFlush() { return index >= fetchCount; } public void close() { flush(); buffer = null; } private void flush() { for (int i = 0; i < index; i++) { compassSession.create(buffer[i]); } // clear buffer and sessions to allow for GC Arrays.fill(buffer, null); compassSession.evictAll(); hibernateSession.clear(); index = 0; } } }