• Home
• org.ow2.bonita
• bonita-server
• 5.9.1
• source code
• DbSessionImpl.java

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

org.ow2.bonita.persistence.db.DbSessionImpl Maven / Gradle / Ivy

/**
 * Copyright (C) 2006 Bull S. A. S.
 * Bull, Rue Jean Jaures, B.P.68, 78340, Les Clayes-sous-Bois
 * This library is free software; you can redistribute it and/or modify it under the terms
 * of the GNU Lesser General Public License as published by the Free Software Foundation
 * version 2.1 of the License.
 * This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
 * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 * See the GNU Lesser General Public License for more details.
 * You should have received a copy of the GNU Lesser General Public License along with this
 * program; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth
 * Floor, Boston, MA 02110-1301, USA.
 * 
 * Modified by Charles Souillard, Matthieu Chaffotte, Nicolas Chabanoles, Elias Ricken de Medeiros -
 * BonitaSoft S.A.
 **/
package org.ow2.bonita.persistence.db;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.Date;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.logging.Level;
import java.util.logging.Logger;

import org.apache.commons.collections.CollectionUtils;
import org.apache.lucene.analysis.standard.StandardAnalyzer;
import org.apache.lucene.queryParser.MultiFieldQueryParser;
import org.apache.lucene.queryParser.ParseException;
import org.apache.lucene.queryParser.QueryParser;
import org.apache.lucene.util.Version;
import org.hibernate.ConnectionReleaseMode;
import org.hibernate.Hibernate;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.engine.SessionFactoryImplementor;
import org.hibernate.search.FullTextQuery;
import org.hibernate.search.FullTextSession;
import org.hibernate.search.Search;
import org.hibernate.transform.Transformers;
import org.hibernate.type.Type;
import org.ow2.bonita.facade.def.InternalActivityDefinition;
import org.ow2.bonita.facade.def.InternalProcessDefinition;
import org.ow2.bonita.facade.def.element.impl.MetaDataImpl;
import org.ow2.bonita.facade.def.majorElement.ProcessDefinition.ProcessState;
import org.ow2.bonita.facade.exception.BonitaInternalException;
import org.ow2.bonita.facade.identity.impl.GroupImpl;
import org.ow2.bonita.facade.identity.impl.MembershipImpl;
import org.ow2.bonita.facade.identity.impl.ProfileMetadataImpl;
import org.ow2.bonita.facade.identity.impl.RoleImpl;
import org.ow2.bonita.facade.identity.impl.UserImpl;
import org.ow2.bonita.facade.paging.ActivityInstanceCriterion;
import org.ow2.bonita.facade.paging.GroupCriterion;
import org.ow2.bonita.facade.paging.ProcessDefinitionCriterion;
import org.ow2.bonita.facade.paging.ProcessInstanceCriterion;
import org.ow2.bonita.facade.paging.RoleCriterion;
import org.ow2.bonita.facade.paging.UserCriterion;
import org.ow2.bonita.facade.privilege.Rule;
import org.ow2.bonita.facade.privilege.Rule.RuleType;
import org.ow2.bonita.facade.privilege.RuleTypePolicy;
import org.ow2.bonita.facade.runtime.ActivityState;
import org.ow2.bonita.facade.runtime.Category;
import org.ow2.bonita.facade.runtime.Comment;
import org.ow2.bonita.facade.runtime.InstanceState;
import org.ow2.bonita.facade.runtime.TaskInstance;
import org.ow2.bonita.facade.runtime.WebTemporaryToken;
import org.ow2.bonita.facade.runtime.impl.CaseImpl;
import org.ow2.bonita.facade.runtime.impl.CategoryImpl;
import org.ow2.bonita.facade.runtime.impl.InternalActivityInstance;
import org.ow2.bonita.facade.runtime.impl.InternalProcessInstance;
import org.ow2.bonita.facade.runtime.impl.LabelImpl;
import org.ow2.bonita.facade.uuid.ActivityDefinitionUUID;
import org.ow2.bonita.facade.uuid.ActivityInstanceUUID;
import org.ow2.bonita.facade.uuid.CategoryUUID;
import org.ow2.bonita.facade.uuid.ProcessDefinitionUUID;
import org.ow2.bonita.facade.uuid.ProcessInstanceUUID;
import org.ow2.bonita.persistence.DocumentDbSession;
import org.ow2.bonita.persistence.EventDbSession;
import org.ow2.bonita.persistence.IdentityDbSession;
import org.ow2.bonita.persistence.JournalDbSession;
import org.ow2.bonita.persistence.PrivilegeDbSession;
import org.ow2.bonita.persistence.QuerierDbSession;
import org.ow2.bonita.persistence.WebDbSession;
import org.ow2.bonita.persistence.WebTokenManagementDbSession;
import org.ow2.bonita.runtime.event.EventCouple;
import org.ow2.bonita.runtime.event.IncomingEventInstance;
import org.ow2.bonita.runtime.event.Job;
import org.ow2.bonita.runtime.event.OutgoingEventInstance;
import org.ow2.bonita.runtime.model.Execution;
import org.ow2.bonita.search.DocumentCriterion;
import org.ow2.bonita.search.DocumentSearchBuilder;
import org.ow2.bonita.search.SearchQueryBuilder;
import org.ow2.bonita.search.SearchUtil;
import org.ow2.bonita.search.index.DocumentIndex;
import org.ow2.bonita.services.Document;
import org.ow2.bonita.services.DocumentContent;
import org.ow2.bonita.services.DocumentDescriptor;
import org.ow2.bonita.services.DocumentDescriptorMapping;
import org.ow2.bonita.services.DocumentVersion;
import org.ow2.bonita.services.impl.DocumentContentImpl;
import org.ow2.bonita.services.impl.DocumentDescriptorImpl;
import org.ow2.bonita.services.impl.DocumentVersionImpl;
import org.ow2.bonita.util.BonitaConstants;
import org.ow2.bonita.util.BonitaRuntimeException;
import org.ow2.bonita.util.DateUtil;
import org.ow2.bonita.util.Misc;
import org.ow2.bonita.util.ProcessInstanceEndedDateComparatorAsc;
import org.ow2.bonita.util.ProcessInstanceEndedDateComparatorDesc;
import org.ow2.bonita.util.ProcessInstanceLastUpdateComparator;
import org.ow2.bonita.util.ProcessInstanceLastUpdateComparatorAsc;
import org.ow2.bonita.util.ProcessInstanceNbComparatorAsc;
import org.ow2.bonita.util.ProcessInstanceNbComparatorDesc;
import org.ow2.bonita.util.ProcessInstanceStartedDateComparatorAsc;
import org.ow2.bonita.util.ProcessInstanceStartedDateComparatorDesc;
import org.ow2.bonita.util.ProcessInstanceUUIDComparatorAsc;
import org.ow2.bonita.util.ProcessInstanceUUIDComparatorDesc;
import org.ow2.bonita.util.hibernate.GenericEnumUserType;

@SuppressWarnings("deprecation")
public class DbSessionImpl extends HibernateDbSession implements QuerierDbSession, JournalDbSession, WebDbSession,
    IdentityDbSession, EventDbSession, PrivilegeDbSession, WebTokenManagementDbSession, DocumentDbSession {

  private static final Logger LOG = Logger.getLogger(DbSessionImpl.class.getName());

  private static final int MAX_LOOP = 100;

  private static final long PAUSE_TIME_MILLIS = 100L;

  private static final String METADATA_TABLE = "BN_METADATA";

  private static final String EXECUTION_TABLE = "BN_PVM_EXEC";

  public DbSessionImpl(final Session session) {
    super();
    setSession(session);
  }

  /*
   * QUERIER
   */
  private static final Type DEFINITION_STATE_USER_TYPE = Hibernate.custom(GenericEnumUserType.class,
      new String[] { "enumClass" }, new String[] { ProcessState.class.getName() });

  private static final Type ACTIVITY_STATE_USER_TYPE = Hibernate.custom(GenericEnumUserType.class,
      new String[] { "enumClass" }, new String[] { ActivityState.class.getName() });

  private static final Type INSTANCE_STATE_USER_TYPE = Hibernate.custom(GenericEnumUserType.class,
      new String[] { "enumClass" }, new String[] { InstanceState.class.getName() });

  protected static final Version LUCENE_VERSION = SearchUtil.LUCENE_VERSION;

  private static String getInsertMetadataStatement(final String schemaPrefix) {
    return "insert into " + schemaPrefix + METADATA_TABLE + " (key_, value_) values (?,'0')";
  }

  private static String getSelectMetadataStatement(final String schemaPrefix) {
    return "select value_ from " + schemaPrefix + METADATA_TABLE + " where key_=?";
  }

  private static String getLockMetadataStatement(final String schemaPrefix) {
    return "update " + schemaPrefix + METADATA_TABLE + " set value_ = value_ where key_=?";
  }

  private static String getUpdateMetadata(final String schemaPrefix) {
    return "update " + schemaPrefix + METADATA_TABLE + " set value_ = ? where key_=?";
  }

  private static String getRemoveMetadataStatement(final String schemaPrefix) {
    return "delete from " + schemaPrefix + METADATA_TABLE + " where key_=?";
  }

  private static String getRemoveExecution(final String schemaPrefix) {
    return "delete from " + schemaPrefix + EXECUTION_TABLE + " where dbid_=?";
  }

  @Override
  public long getLockedMetadata(final String key) {
    Connection connection = null;
    try {
      connection = getConnection();
      return getMetadata(connection, key);
    } catch (final SQLException e) {
      // FIXME find a more appropriate exception type
      throw new BonitaInternalException("Unexpected DB access exception: " + e, e);
    } finally {
      releaseConnection(connection);
    }
  }

  @Override
  public void lockMetadata(final String key) {
    Connection connection = null;
    try {
      connection = getConnection();
      final boolean locked = lockMetadata(connection, key);
      if (!locked) {
        createMetadata(connection, key);
      }
    } catch (final SQLException e) {
      // FIXME find a more appropriate exception type
      throw new BonitaInternalException("Unexpected DB access exception: " + e, e);
    } finally {
      releaseConnection(connection);
    }
  }

  @Override
  public void updateLockedMetadata(final String key, final long value) {
    Connection connection = null;
    try {
      connection = getConnection();
      updateMetadata(connection, key, value);
    } catch (final SQLException e) {
      // FIXME find a more appropriate exception type
      throw new BonitaInternalException("Unexpected DB access exception: " + e, e);
    } finally {
      releaseConnection(connection);
    }
  }

  @Override
  public void removeLockedMetadata(final String key) {
    Connection connection = null;
    try {
      connection = getConnection();
      removeMetadata(connection, key);
    } catch (final SQLException e) {
      // FIXME find a more appropriate exception type
      throw new BonitaInternalException("Unexpected DB access exception: " + e, e);
    } finally {
      releaseConnection(connection);
    }
  }

  private void releaseConnection(final Connection connection) {
    if (connection != null && shouldReleaseConnections()) {
      try {
        connection.close();
      } catch (final SQLException e) {
        if (LOG.isLoggable(Level.FINE)) {
          LOG.fine("SQLException during connection close: " + e);
        }
      }
    }
  }

  private boolean shouldReleaseConnections() {
    return ((SessionFactoryImplementor) session.getSessionFactory()).getSettings().getConnectionReleaseMode() == ConnectionReleaseMode.AFTER_STATEMENT;
  }

  private Connection getConnection() {
    return session.connection();
  }

  private long getMetadata(final Connection connection, final String key) throws SQLException {
    final String schemaPrefix = getSchemaPrefix();
    final PreparedStatement selectStmt = connection.prepareStatement(getSelectMetadataStatement(schemaPrefix));
    try {
      selectStmt.setString(1, key);
      final ResultSet resultSet = selectStmt.executeQuery();
      try {
        if (resultSet.next()) {
          final String value = resultSet.getString(1);
          return Long.valueOf(value);
        } else {
          throw new IllegalStateException("value not found for key=" + key);
        }
      } finally {
        resultSet.close();
      }
    } finally {
      selectStmt.close();
    }
  }

  private String getSchemaPrefix() throws SQLException {
    String schemaPrefix = "";
    final String defaultSchema = ((SessionFactoryImplementor) session.getSessionFactory()).getSettings()
        .getDefaultSchemaName();
    if (defaultSchema != null && !defaultSchema.trim().isEmpty()) {
      schemaPrefix = defaultSchema + ".";
    }
    return schemaPrefix;
  }

  private void updateMetadata(final Connection connection, final String key, final long nb) throws SQLException {
    final String schemaName = getSchemaPrefix();
    final PreparedStatement updateStmt = connection.prepareStatement(getUpdateMetadata(schemaName));
    try {
      updateStmt.setString(1, String.valueOf(nb));
      updateStmt.setString(2, key);
      updateStmt.executeUpdate();
    } finally {
      updateStmt.close();
    }
  }

  @Override
  public void deleteExecution(final long id) {
    Connection connection = null;
    try {
      connection = getConnection();
      final String schemaName = getSchemaPrefix();
      final PreparedStatement updateStmt = connection.prepareStatement(getRemoveExecution(schemaName));
      try {
        updateStmt.setLong(1, id);
        updateStmt.executeUpdate();
      } finally {
        updateStmt.close();
      }
    } catch (final SQLException e) {
      // FIXME find a more appropriate exception type
      throw new BonitaInternalException("Unexpected DB access exception: " + e, e);
    } finally {
      releaseConnection(connection);
    }
  }

  private void removeMetadata(final Connection connection, final String key) throws SQLException {
    final String schemaName = getSchemaPrefix();
    final PreparedStatement updateStmt = connection.prepareStatement(getRemoveMetadataStatement(schemaName));
    try {
      updateStmt.setString(1, key);
      updateStmt.executeUpdate();
    } finally {
      updateStmt.close();
    }
  }

  private void createMetadata(final Connection connection, final String key) throws SQLException {
    int loops = 0;
    final String schemaName = getSchemaPrefix();
    do {
      final PreparedStatement insertStmt = connection.prepareStatement(getInsertMetadataStatement(schemaName));
      try {
        insertStmt.setString(1, key);
        insertStmt.executeUpdate();
        return;
      } catch (final SQLException e) {
        if (isConstraintViolation(e)) {
          try {
            Thread.sleep(PAUSE_TIME_MILLIS);
          } catch (final InterruptedException e1) {
            LOG.log(Level.FINE, "interrupted");
          }
          // another process has inserted or is inserting at the same time
          final boolean locked = lockMetadata(connection, key);
          if (locked) {
            return;
          }
        } else {
          throw e;
        }
      } finally {
        insertStmt.close();
      }
      loops++;
    } while (loops < MAX_LOOP);
    throw new IllegalStateException(" Could not create or lock value for key=" + key + ". Giving up after " + loops
        + " iterations.");
  }

  private boolean lockMetadata(final Connection connection, final String key) throws SQLException {
    final String schemaName = getSchemaPrefix();
    final PreparedStatement updateStmt = connection.prepareStatement(getLockMetadataStatement(schemaName));
    try {
      updateStmt.setString(1, key);
      final int updateCount = updateStmt.executeUpdate();
      return updateCount > 0;
    } finally {
      updateStmt.close();
    }
  }

  private boolean isConstraintViolation(final SQLException e) {
    final String sqlState = getSqlState(e);
    boolean isConstraintViolation = false;
    if (sqlState != null && sqlState.length() >= 2) {
      final String classCode = sqlState.substring(0, 2);
      if ("23".equals(classCode)) {
        isConstraintViolation = true;
      }
    }
    return isConstraintViolation;
  }

  private String getSqlState(final SQLException e) {
    String sqlState = e.getSQLState();
    if (sqlState == null) {
      if (e.getCause() != null) {
        final SQLException nextException = e.getNextException();
        if (nextException != null) {
          sqlState = nextException.getSQLState();
        }
      }
    }
    return sqlState;
  }

  @Override
  public int getNumberOfParentProcessInstances() {
    final Query query = getSession().getNamedQuery("getNumberOfParentProcessInstances");

    return ((Long) query.uniqueResult()).intValue();
  }

  @Override
  public int getNumberOfProcessInstances() {
    final Query query = getSession().getNamedQuery("getNumberOfProcessInstances");

    return ((Long) query.uniqueResult()).intValue();
  }

  @Override
  public int getNumberOfProcesses() {
    final Query query = getSession().getNamedQuery("getNumberOfProcesses");

    return ((Long) query.uniqueResult()).intValue();
  }

  @Override
  public Set getUserInstanceTasks(final String userId, final ProcessInstanceUUID instanceUUID,
      final ActivityState taskState) {
    final Set result = new HashSet();
    final Query query = getSession().getNamedQuery("getUserInstanceTasksWithState");

    query.setString("userId", userId);
    query.setString("instanceUUID", instanceUUID.toString());
    query.setParameter("state", taskState, ACTIVITY_STATE_USER_TYPE);
    CollectionUtils.addAll(result, query.iterate());
    return result;
  }

  @Override
  public Set getUserTasks(final String userId, final Collection taskStates) {
    final Query query = getSession().getNamedQuery("getUserTasksWithStates");

    query.setString("userId", userId);
    query.setParameterList("states", taskStates, ACTIVITY_STATE_USER_TYPE);
    final Set result = new HashSet();
    CollectionUtils.addAll(result, query.iterate());
    return result;
  }

  @Override
  public Set getActivityInstances(final ProcessInstanceUUID instanceUUID,
      final String activityName) {
    final Query query = getSession().getNamedQuery("getActivityInstancesWithName");

    query.setString("instanceUUID", instanceUUID.getValue());
    query.setString("name", activityName);
    final Set result = new HashSet();
    CollectionUtils.addAll(result, query.iterate());
    return result;
  }

  @Override
  public Set getActivityInstances(final ProcessInstanceUUID instanceUUID,
      final String activityName, final String iterationId) {
    final Query query = getSession().getNamedQuery("getActivityInstances");

    query.setString("instanceUUID", instanceUUID.getValue());
    query.setString("activityName", activityName);
    query.setString("iterationId", iterationId);
    final Set result = new HashSet();
    CollectionUtils.addAll(result, query.iterate());
    return result;
  }

  @Override
  @SuppressWarnings("unchecked")
  public List getActivityInstancesFromRoot(final ProcessInstanceUUID rootInstanceUUID) {
    if (rootInstanceUUID == null) {
      return Collections.emptyList();
    }
    final Query query = getSession().getNamedQuery("getActivityInstancesFromRoot");

    query.setString("rootInstanceUUID", rootInstanceUUID.getValue());
    return query.list();
  }

  @Override
  @SuppressWarnings("unchecked")
  public List getActivityInstancesFromRoot(final Set rootInstanceUUIDs) {
    if (rootInstanceUUIDs == null || rootInstanceUUIDs.isEmpty()) {
      return Collections.emptyList();
    }
    final Collection uuids = new HashSet();
    for (final ProcessInstanceUUID processInstanceUUID : rootInstanceUUIDs) {
      uuids.add(processInstanceUUID.getValue());
    }

    final Query query = getSession().getNamedQuery("getMatchingActivityInstancesFromRoot");

    query.setParameterList("rootInstanceUUIDs", uuids);
    return query.list();
  }

  @Override
  @SuppressWarnings("unchecked")
  public Map getLastUpdatedActivityInstanceFromRoot(
      final Set rootInstanceUUIDs, final boolean considerSystemTaks) {
    if (rootInstanceUUIDs == null || rootInstanceUUIDs.isEmpty()) {
      return Collections.emptyMap();
    }

    final Map result = new HashMap();
    Query query;
    for (final ProcessInstanceUUID processInstanceUUID : rootInstanceUUIDs) {
      if (considerSystemTaks) {
        query = getSession().getNamedQuery("getMatchingActivityInstancesFromRoot");
      } else {
        query = getSession().getNamedQuery("getMatchingHumanTaskInstancesFromRoot");
      }

      query.setParameterList("rootInstanceUUIDs", Arrays.asList(processInstanceUUID.getValue()));
      query.setMaxResults(1);

      final List tmp = query.list();
      if (tmp != null && !tmp.isEmpty()) {
        result.put(processInstanceUUID, tmp.get(0));
      }
    }
    return result;
  }

  @Override
  @SuppressWarnings("unchecked")
  public List getActivityInstancesFromRoot(final Set rootInstanceUUIDs,
      final ActivityState state) {
    if (rootInstanceUUIDs == null || rootInstanceUUIDs.isEmpty()) {
      return Collections.emptyList();
    }
    final Collection uuids = new HashSet();
    for (final ProcessInstanceUUID processInstanceUUID : rootInstanceUUIDs) {
      uuids.add(processInstanceUUID.getValue());
    }

    final Query query = getSession().getNamedQuery("getMatchingActivityInstancesWithStateFromRoot");

    query.setParameterList("rootInstanceUUIDs", uuids);
    query.setParameter("state", state, ACTIVITY_STATE_USER_TYPE);
    return query.list();
  }

  @Override
  public TaskInstance getOneTask(final String userId, final ActivityState taskState) {
    final Query query = getSession().getNamedQuery("getOneTask");

    query.setString("userId", userId);
    query.setParameter("state", taskState, ACTIVITY_STATE_USER_TYPE);
    query.setMaxResults(1);
    return (TaskInstance) query.uniqueResult();
  }

  @Override
  public TaskInstance getOneTask(final String userId, final ProcessDefinitionUUID processUUID,
      final ActivityState taskState) {
    final Query query = getSession().getNamedQuery("getOneTaskOfProcess");

    query.setString("userId", userId);
    query.setString("processUUID", processUUID.getValue());
    query.setParameter("state", taskState, ACTIVITY_STATE_USER_TYPE);
    query.setMaxResults(1);
    return (TaskInstance) query.uniqueResult();
  }

  @Override
  public TaskInstance getOneTask(final String userId, final ProcessInstanceUUID instanceUUID,
      final ActivityState taskState) {
    final Query query = getSession().getNamedQuery("getOneTaskOfInstance");

    query.setString("userId", userId);
    query.setString("instanceUUID", instanceUUID.getValue());
    query.setParameter("state", taskState, ACTIVITY_STATE_USER_TYPE);
    query.setMaxResults(1);
    return (TaskInstance) query.uniqueResult();
  }

  @Override
  public Set getUserInstances(final String userId) {
    final Query query = getSession().getNamedQuery("getUserInstances");

    query.setString("userId", userId);
    final Set result = new HashSet();
    CollectionUtils.addAll(result, query.iterate());
    return result;
  }

  @Override
  @SuppressWarnings("unchecked")
  public List getParentUserInstances(final String userId, final int fromIndex,
      final int pageSize) {
    final Query query = getSession().getNamedQuery("getParentUserInstancesPage");

    query.setFirstResult(fromIndex);
    query.setMaxResults(pageSize);
    query.setString("userId", userId);
    final List results = query.list();
    if (results == null) {
      return Collections.emptyList();
    }
    return results;

  }

  @Override
  @SuppressWarnings("unchecked")
  public List getParentUserInstances(final String userId, final int startingIndex,
      final int pageSize, final ProcessInstanceCriterion pagingCriterion) {
    Query query = null;
    switch (pagingCriterion) {
      case LAST_UPDATE_ASC:
        query = getSession().getNamedQuery("getParentUserInstancesPageOrderByLastUpdateAsc");
        break;
      case STARTED_DATE_ASC:
        query = getSession().getNamedQuery("getParentUserInstancesPageOrderByStartedDateAsc");
        break;
      case ENDED_DATE_ASC:
        query = getSession().getNamedQuery("getParentUserInstancesPageOrderByEndedDateAsc");
        break;
      case INSTANCE_NUMBER_ASC:
        query = getSession().getNamedQuery("getParentUserInstancesPageOrderByInstanceNumberAsc");
        break;
      case INSTANCE_UUID_ASC:
        query = getSession().getNamedQuery("getParentUserInstancesPageOrderByInstanceUUIDAsc");
        break;
      case LAST_UPDATE_DESC:
        query = getSession().getNamedQuery("getParentUserInstancesPageOrderByLastUpdateDesc");
        break;
      case STARTED_DATE_DESC:
        query = getSession().getNamedQuery("getParentUserInstancesPageOrderByStartedDateDesc");
        break;
      case ENDED_DATE_DESC:
        query = getSession().getNamedQuery("getParentUserInstancesPageOrderByEndedDateDesc");
        break;
      case INSTANCE_NUMBER_DESC:
        query = getSession().getNamedQuery("getParentUserInstancesPageOrderByInstanceNumberDesc");
        break;
      case INSTANCE_UUID_DESC:
        query = getSession().getNamedQuery("getParentUserInstancesPageOrderByInstanceUUIDDesc");
        break;
      case DEFAULT:
        query = getSession().getNamedQuery("getParentUserInstancesPage");
        break;
    }

    query.setFirstResult(startingIndex);
    query.setMaxResults(pageSize);
    query.setString("userId", userId);
    final List results = query.list();
    if (results == null) {
      return Collections.emptyList();
    }
    return results;
  }

  @Override
  public Set getUserInstances(final String userId, final Date minStartDate) {
    final Query query = getSession().getNamedQuery("getUserInstancesAfterDate");

    query.setString("userId", userId);
    query.setLong("minStartDate", minStartDate.getTime());
    final Set result = new HashSet();
    CollectionUtils.addAll(result, query.iterate());
    return result;
  }

  @Override
  public Set getUserParentInstances(final String userId, final Date minStartDate) {
    final Query query = getSession().getNamedQuery("getUserParentInstancesAfterDate");

    query.setString("userId", userId);
    query.setLong("minStartDate", minStartDate.getTime());
    final Set result = new HashSet();
    CollectionUtils.addAll(result, query.iterate());
    return result;
  }

  @Override
  public Set getUserInstancesExcept(final String userId,
      final Set instances) {
    if (instances == null || instances.isEmpty()) {
      return getUserInstances(userId);
    }
    final Collection uuids = new HashSet();
    for (final ProcessInstanceUUID processInstanceUUID : instances) {
      uuids.add(processInstanceUUID.getValue());
    }
    final Query query = getSession().getNamedQuery("getUserInstancesExcept");

    query.setString("userId", userId);
    return executeSplittedQuery(InternalProcessInstance.class, query, "uuids", uuids);
  }

  @Override
  @SuppressWarnings("unchecked")
  public Set getActivityInstances(final ProcessInstanceUUID instanceUUID) {
    final Query query = getSession().getNamedQuery("findActivityInstances");

    query.setString("instanceUUID", instanceUUID.toString());
    final List results = query.list();
    if (results != null) {
      return new HashSet(results);
    }
    return null;
  }

  @Override
  @SuppressWarnings("unchecked")
  public List getActivityInstances(final ProcessInstanceUUID instanceUUID,
      final int fromIndex, final int pageSize, final ActivityInstanceCriterion pagingCriterion) {
    Query query = null;

    switch (pagingCriterion) {
      case LAST_UPDATE_ASC:
        query = getSession().getNamedQuery("findActivityInstancesOrderByLastUpdateAsc");
        break;
      case STARTED_DATE_ASC:
        query = getSession().getNamedQuery("findActivityInstancesOrderByStartedDateAsc");
        break;
      case ENDED_DATE_ASC:
        query = getSession().getNamedQuery("findActivityInstancesOrderByEndedDateAsc");
        break;
      case NAME_ASC:
        query = getSession().getNamedQuery("findActivityInstancesOrderByNameAsc");
        break;
      case PRIORITY_ASC:
        query = getSession().getNamedQuery("findActivityInstancesOrderByPriorityAsc");
        break;
      case LAST_UPDATE_DESC:
        query = getSession().getNamedQuery("findActivityInstancesOrderByLastUpdateDesc");
        break;
      case STARTED_DATE_DESC:
        query = getSession().getNamedQuery("findActivityInstancesOrderByStartedDateDesc");
        break;
      case ENDED_DATE_DESC:
        query = getSession().getNamedQuery("findActivityInstancesOrderByEndedDateDesc");
        break;
      case NAME_DESC:
        query = getSession().getNamedQuery("findActivityInstancesOrderByNameDesc");
        break;
      case PRIORITY_DESC:
        query = getSession().getNamedQuery("findActivityInstancesOrderByPriorityDesc");
        break;
      case DEFAULT:
        query = getSession().getNamedQuery("findActivityInstancesOrderByLastUpdateDesc");
        break;
    }

    query.setString("instanceUUID", instanceUUID.toString());
    query.setFirstResult(fromIndex);
    query.setMaxResults(pageSize);

    final List results = query.list();
    if (results != null) {
      return new ArrayList(results);
    }
    return null;
  }

  @Override
  public long getLastProcessInstanceNb(final ProcessDefinitionUUID processUUID) {
    final Query query = getSession().getNamedQuery("getLastProcessInstanceNb");

    query.setString("processUUID", processUUID.getValue());
    query.setMaxResults(1);
    final Long result = (Long) query.uniqueResult();
    if (result == null) {
      return -1;
    }
    return result;
  }

  @Override
  public InternalProcessInstance getProcessInstance(final ProcessInstanceUUID instanceUUID) {
    final Query query = getSession().getNamedQuery("findProcessInstance");

    query.setString("instanceUUID", instanceUUID.toString());
    query.setMaxResults(1);
    return (InternalProcessInstance) query.uniqueResult();
  }

  @Override
  @SuppressWarnings("unchecked")
  public Set getProcessInstances() {
    final Set processInsts = new HashSet();
    final Query query = getSession().getNamedQuery("findAllProcessInstances");

    final List results = query.list();
    if (results != null) {
      processInsts.addAll(results);
    }
    return processInsts;
  }

  @Override
  @SuppressWarnings("unchecked")
  public List getProcessInstances(final int fromIndex, final int pageSize) {
    final Query query = getSession().getNamedQuery("findAllProcessInstances");

    query.setFirstResult(fromIndex);
    query.setMaxResults(pageSize);
    final List results = query.list();
    if (results == null) {
      return Collections.emptyList();
    }
    return results;
  }

  @Override
  @SuppressWarnings("unchecked")
  public List getProcessInstances(final int fromIndex, final int pageSize,
      final ProcessInstanceCriterion pagingCriterion) {
    Query query = null;
    switch (pagingCriterion) {
      case LAST_UPDATE_ASC:
        query = getSession().getNamedQuery("findAllProcessInstancesOrderByLastUpdateAsc");
        break;
      case STARTED_DATE_ASC:
        query = getSession().getNamedQuery("findAllProcessInstancesOrderByStartedDateAsc");
        break;
      case ENDED_DATE_ASC:
        query = getSession().getNamedQuery("findAllProcessInstancesOrderByEndedDateAsc");
        break;
      case INSTANCE_NUMBER_ASC:
        query = getSession().getNamedQuery("findAllProcessInstancesOrderByInstanceNumberAsc");
        break;
      case INSTANCE_UUID_ASC:
        query = getSession().getNamedQuery("findAllProcessInstancesOrderByInstanceUUIDAsc");
        break;
      case LAST_UPDATE_DESC:
        query = getSession().getNamedQuery("findAllProcessInstancesOrderByLastUpdateDesc");
        break;
      case STARTED_DATE_DESC:
        query = getSession().getNamedQuery("findAllProcessInstancesOrderByStartedDateDesc");
        break;
      case ENDED_DATE_DESC:
        query = getSession().getNamedQuery("findAllProcessInstancesOrderByEndedDateDesc");
        break;
      case INSTANCE_NUMBER_DESC:
        query = getSession().getNamedQuery("findAllProcessInstancesOrderByInstanceNumberDesc");
        break;
      case INSTANCE_UUID_DESC:
        query = getSession().getNamedQuery("findAllProcessInstancesOrderByInstanceUUIDDesc");
        break;
      case DEFAULT:
        query = getSession().getNamedQuery("findAllProcessInstances");
        break;
    }

    query.setFirstResult(fromIndex);
    query.setMaxResults(pageSize);
    final List results = query.list();
    if (results == null) {
      return Collections.emptyList();
    }
    return results;
  }

  @Override
  @SuppressWarnings("unchecked")
  public List getMostRecentProcessInstances(final int maxResults, final long time) {
    final Query query = getSession().getNamedQuery("getMostRecentProcessInstances");

    query.setFirstResult(0);
    query.setLong("time", time);
    query.setMaxResults(maxResults);
    final List results = query.list();
    if (results == null) {
      return Collections.emptyList();
    }
    return results;
  }

  @Override
  @SuppressWarnings("unchecked")
  public List getMostRecentProcessInstances(final int maxResults, final long time,
      final ProcessInstanceCriterion pagingCriterion) {
    Query query = null;
    switch (pagingCriterion) {
      case LAST_UPDATE_ASC:
        query = getSession().getNamedQuery("getMostRecentProcessInstancesOrderByLastUpdateAsc");
        break;
      case STARTED_DATE_ASC:
        query = getSession().getNamedQuery("getMostRecentProcessInstancesOrderByStartedDateAsc");
        break;
      case ENDED_DATE_ASC:
        query = getSession().getNamedQuery("getMostRecentProcessInstancesOrderByEndedDateAsc");
        break;
      case INSTANCE_NUMBER_ASC:
        query = getSession().getNamedQuery("getMostRecentProcessInstancesOrderByInstanceNumberAsc");
        break;
      case INSTANCE_UUID_ASC:
        query = getSession().getNamedQuery("getMostRecentProcessInstancesOrderByInstanceUUIDAsc");
        break;
      case LAST_UPDATE_DESC:
        query = getSession().getNamedQuery("getMostRecentProcessInstancesOrderByLastUpdateDesc");
        break;
      case STARTED_DATE_DESC:
        query = getSession().getNamedQuery("getMostRecentProcessInstancesOrderByStartedDateDesc");
        break;
      case ENDED_DATE_DESC:
        query = getSession().getNamedQuery("getMostRecentProcessInstancesOrderByEndedDateDesc");
        break;
      case INSTANCE_NUMBER_DESC:
        query = getSession().getNamedQuery("getMostRecentProcessInstancesOrderByInstanceNumberDesc");
        break;
      case INSTANCE_UUID_DESC:
        query = getSession().getNamedQuery("getMostRecentProcessInstancesOrderByInstanceUUIDDesc");
        break;
      case DEFAULT:
        query = getSession().getNamedQuery("getMostRecentProcessInstances");
        break;
    }

    query.setFirstResult(0);
    query.setLong("time", time);
    query.setMaxResults(maxResults);
    final List results = query.list();
    if (results == null) {
      return Collections.emptyList();
    }
    return results;
  }

  @Override
  @SuppressWarnings("unchecked")
  public List getMostRecentParentProcessInstances(final int maxResults, final long time) {
    final Query query = getSession().getNamedQuery("getMostRecentParentProcessInstances");

    query.setFirstResult(0);
    query.setLong("time", time);
    query.setMaxResults(maxResults);
    final List results = query.list();
    if (results == null) {
      return Collections.emptyList();
    }
    return results;
  }

  @Override
  @SuppressWarnings("unchecked")
  public List getMostRecentParentProcessInstances(final int maxResults, final long time,
      final ProcessInstanceCriterion pagingCriterion) {
    Query query = null;
    switch (pagingCriterion) {
      case LAST_UPDATE_ASC:
        query = getSession().getNamedQuery("getMostRecentParentProcessInstancesOrderByLastUpdateAsc");
        break;
      case STARTED_DATE_ASC:
        query = getSession().getNamedQuery("getMostRecentParentProcessInstancesOrderByStartedDateAsc");
        break;
      case ENDED_DATE_ASC:
        query = getSession().getNamedQuery("getMostRecentParentProcessInstancesOrderByEndedDateAsc");
        break;
      case INSTANCE_NUMBER_ASC:
        query = getSession().getNamedQuery("getMostRecentParentProcessInstancesOrderByInstanceNumberAsc");
        break;
      case INSTANCE_UUID_ASC:
        query = getSession().getNamedQuery("getMostRecentParentProcessInstancesOrderByInstanceUUIDAsc");
        break;
      case LAST_UPDATE_DESC:
        query = getSession().getNamedQuery("getMostRecentParentProcessInstancesOrderByLastUpdateDesc");
        break;
      case STARTED_DATE_DESC:
        query = getSession().getNamedQuery("getMostRecentParentProcessInstancesOrderByStartedDateDesc");
        break;
      case ENDED_DATE_DESC:
        query = getSession().getNamedQuery("getMostRecentParentProcessInstancesOrderByEndedDateDesc");
        break;
      case INSTANCE_NUMBER_DESC:
        query = getSession().getNamedQuery("getMostRecentParentProcessInstancesOrderByInstanceNumberDesc");
        break;
      case INSTANCE_UUID_DESC:
        query = getSession().getNamedQuery("getMostRecentParentProcessInstancesOrderByInstanceUUIDDesc");
        break;
      case DEFAULT:
        query = getSession().getNamedQuery("getMostRecentParentProcessInstances");
        break;
    }

    query.setFirstResult(0);
    query.setLong("time", time);
    query.setMaxResults(maxResults);
    final List results = query.list();
    if (results == null) {
      return Collections.emptyList();
    }
    return results;
  }

  @Override
  public List getMostRecentMatchingProcessInstances(
      final Collection instanceUUIDs, final int maxResults, final long time) {
    final Query query = getSession().getNamedQuery("getMostRecentMatchingProcessInstances");

    query.setFirstResult(0);
    query.setLong("time", time);
    query.setMaxResults(maxResults);

    final Set uuids = new HashSet();
    for (final ProcessInstanceUUID uuid : instanceUUIDs) {
      uuids.add(uuid.toString());
    }

    final List allInstances = new ArrayList();
    allInstances.addAll(executeSplittedQuery(InternalProcessInstance.class, query, "instanceUUIDs", uuids));
    Collections.sort(allInstances, new ProcessInstanceLastUpdateComparator());
    final List results = Misc.subList(InternalProcessInstance.class, allInstances, 0,
        maxResults);
    if (results == null) {
      return Collections.emptyList();
    }
    return results;
  }

  @Override
  public List getMostRecentMatchingProcessInstances(
      final Set instanceUUIDs, final int maxResults, final long time,
      final ProcessInstanceCriterion pagingCriterion) {
    Query query = null;
    Comparator comparator = null;
    switch (pagingCriterion) {
      case LAST_UPDATE_ASC:
        comparator = new ProcessInstanceLastUpdateComparatorAsc();
        query = getSession().getNamedQuery("getMostRecentMatchingProcessInstancesOrderByLastUpdateAsc");
        break;
      case STARTED_DATE_ASC:
        comparator = new ProcessInstanceStartedDateComparatorAsc();
        query = getSession().getNamedQuery("getMostRecentMatchingProcessInstancesOrderByStartedDateAsc");
        break;
      case ENDED_DATE_ASC:
        comparator = new ProcessInstanceEndedDateComparatorAsc();
        query = getSession().getNamedQuery("getMostRecentMatchingProcessInstancesOrderByEndedDateAsc");
        break;
      case INSTANCE_NUMBER_ASC:
        comparator = new ProcessInstanceNbComparatorAsc();
        query = getSession().getNamedQuery("getMostRecentMatchingProcessInstancesOrderByInstanceNumberAsc");
        break;
      case INSTANCE_UUID_ASC:
        comparator = new ProcessInstanceUUIDComparatorAsc();
        query = getSession().getNamedQuery("getMostRecentMatchingProcessInstancesOrderByInstanceUUIDAsc");
        break;
      case LAST_UPDATE_DESC:
        comparator = new ProcessInstanceLastUpdateComparator();
        query = getSession().getNamedQuery("getMostRecentMatchingProcessInstancesOrderByLastUpdateDesc");
        break;
      case STARTED_DATE_DESC:
        comparator = new ProcessInstanceStartedDateComparatorDesc();
        query = getSession().getNamedQuery("getMostRecentMatchingProcessInstancesOrderByStartedDateDesc");
        break;
      case ENDED_DATE_DESC:
        comparator = new ProcessInstanceEndedDateComparatorDesc();
        query = getSession().getNamedQuery("getMostRecentMatchingProcessInstancesOrderByEndedDateDesc");
        break;
      case INSTANCE_NUMBER_DESC:
        comparator = new ProcessInstanceNbComparatorDesc();
        query = getSession().getNamedQuery("getMostRecentMatchingProcessInstancesOrderByInstanceNumberDesc");
        break;
      case INSTANCE_UUID_DESC:
        comparator = new ProcessInstanceUUIDComparatorDesc();
        query = getSession().getNamedQuery("getMostRecentMatchingProcessInstancesOrderByInstanceUUIDDesc");
        break;
      case DEFAULT:
        comparator = new ProcessInstanceLastUpdateComparator();
        query = getSession().getNamedQuery("getMostRecentMatchingProcessInstances");
        break;
    }

    query.setFirstResult(0);
    query.setLong("time", time);
    query.setMaxResults(maxResults);

    final Set uuids = new HashSet();
    for (final ProcessInstanceUUID uuid : instanceUUIDs) {
      uuids.add(uuid.toString());
    }

    final List allInstances = new ArrayList();
    allInstances.addAll(executeSplittedQuery(InternalProcessInstance.class, query, "instanceUUIDs", uuids));
    Collections.sort(allInstances, comparator);
    final List results = Misc.subList(InternalProcessInstance.class, allInstances, 0,
        maxResults);
    if (results == null) {
      return Collections.emptyList();
    }
    return results;
  }

  @Override
  public List getMostRecentProcessesProcessInstances(
      final Collection definitionUUIDs, final int maxResults, final long time,
      final ProcessInstanceCriterion pagingCriterion) {
    Query query = null;
    Comparator comparator = null;
    switch (pagingCriterion) {
      case LAST_UPDATE_ASC:
        comparator = new ProcessInstanceLastUpdateComparatorAsc();
        query = getSession().getNamedQuery("getMostRecentProcessesProcessInstancesOrderByLastUpdateAsc");
        break;
      case STARTED_DATE_ASC:
        comparator = new ProcessInstanceStartedDateComparatorAsc();
        query = getSession().getNamedQuery("getMostRecentProcessesProcessInstancesOrderByStartedDateAsc");
        break;
      case ENDED_DATE_ASC:
        comparator = new ProcessInstanceEndedDateComparatorAsc();
        query = getSession().getNamedQuery("getMostRecentProcessesProcessInstancesOrderByEndedDateAsc");
        break;
      case INSTANCE_NUMBER_ASC:
        comparator = new ProcessInstanceNbComparatorAsc();
        query = getSession().getNamedQuery("getMostRecentProcessesProcessInstancesOrderByInstanceNumberAsc");
        break;
      case INSTANCE_UUID_ASC:
        comparator = new ProcessInstanceUUIDComparatorAsc();
        query = getSession().getNamedQuery("getMostRecentProcessesProcessInstancesOrderByInstanceUUIDAsc");
        break;
      case LAST_UPDATE_DESC:
        comparator = new ProcessInstanceLastUpdateComparator();
        query = getSession().getNamedQuery("getMostRecentProcessesProcessInstancesOrderByLastUpdateDesc");
        break;
      case STARTED_DATE_DESC:
        comparator = new ProcessInstanceStartedDateComparatorDesc();
        query = getSession().getNamedQuery("getMostRecentProcessesProcessInstancesOrderByStartedDateDesc");
        break;
      case ENDED_DATE_DESC:
        comparator = new ProcessInstanceEndedDateComparatorDesc();
        query = getSession().getNamedQuery("getMostRecentProcessesProcessInstancesOrderByEndedDateDesc");
        break;
      case INSTANCE_NUMBER_DESC:
        comparator = new ProcessInstanceNbComparatorDesc();
        query = getSession().getNamedQuery("getMostRecentProcessesProcessInstancesOrderByInstanceNumberDesc");
        break;
      case INSTANCE_UUID_DESC:
        comparator = new ProcessInstanceUUIDComparatorDesc();
        query = getSession().getNamedQuery("getMostRecentProcessesProcessInstancesOrderByInstanceUUIDDesc");
        break;
      case DEFAULT:
        comparator = new ProcessInstanceLastUpdateComparator();
        query = getSession().getNamedQuery("getMostRecentProcessesProcessInstances");
        break;
    }

    query.setFirstResult(0);
    query.setLong("time", time);
    query.setMaxResults(maxResults);

    final Set uuids = new HashSet();
    if (definitionUUIDs != null) {
      for (final ProcessDefinitionUUID uuid : definitionUUIDs) {
        uuids.add(uuid.toString());
      }
    }

    final List allInstances = new ArrayList();
    allInstances.addAll(executeSplittedQuery(InternalProcessInstance.class, query, "processUUIDs", uuids));
    Collections.sort(allInstances, comparator);
    final List results = Misc.subList(InternalProcessInstance.class, allInstances, 0,
        maxResults);
    if (results == null) {
      return Collections.emptyList();
    }
    return results;
  }

  @Override
  public List getMostRecentProcessesProcessInstances(
      final Collection definitionUUIDs, final int maxResults, final long time) {
    final Query query = getSession().getNamedQuery("getMostRecentProcessesProcessInstances");

    query.setFirstResult(0);
    query.setLong("time", time);
    query.setMaxResults(maxResults);

    final Set uuids = new HashSet();
    if (definitionUUIDs != null) {
      for (final ProcessDefinitionUUID uuid : definitionUUIDs) {
        uuids.add(uuid.toString());
      }
    }

    final List allInstances = new ArrayList();
    allInstances.addAll(executeSplittedQuery(InternalProcessInstance.class, query, "processUUIDs", uuids));
    Collections.sort(allInstances, new ProcessInstanceLastUpdateComparator());
    final List results = Misc.subList(InternalProcessInstance.class, allInstances, 0,
        maxResults);
    if (results == null) {
      return Collections.emptyList();
    }
    return results;
  }

  @Override
  public List getParentProcessInstances(final ProcessDefinitionUUID definitionUUID,
      final int fromIndex, final int pageSize) {
    final Query query = getSession().getNamedQuery("getParentInstancesOfProcessDefinition");
    query.setString("definitionUUID", definitionUUID.getValue());
    query.setFirstResult(fromIndex);
    query.setMaxResults(pageSize);
    return formatList(query.list());
  }

  @Override
  @SuppressWarnings("unchecked")
  public List getParentProcessInstances(final int fromIndex, final int pageSize) {
    final Query query = getSession().getNamedQuery("getParentInstances");
    query.setFirstResult(fromIndex);
    query.setMaxResults(pageSize);
    return formatList(query.list());
  }

  @Override
  @SuppressWarnings("unchecked")
  public List getParentProcessInstances(final int fromIndex, final int pageSize,
      final ProcessInstanceCriterion pagingCriterion) {
    Query query = null;
    switch (pagingCriterion) {
      case LAST_UPDATE_ASC:
        query = getSession().getNamedQuery("getParentInstancesOrderByLastUpdateAsc");
        break;
      case STARTED_DATE_ASC:
        query = getSession().getNamedQuery("getParentInstancesOrderByStartedDateAsc");
        break;
      case ENDED_DATE_ASC:
        query = getSession().getNamedQuery("getParentInstancesOrderByEndedDateAsc");
        break;
      case INSTANCE_NUMBER_ASC:
        query = getSession().getNamedQuery("getParentInstancesOrderByInstanceNumberAsc");
        break;
      case INSTANCE_UUID_ASC:
        query = getSession().getNamedQuery("getParentInstancesOrderByInstanceUUIDAsc");
        break;
      case LAST_UPDATE_DESC:
        query = getSession().getNamedQuery("getParentInstancesOrderByLastUpdateDesc");
        break;
      case STARTED_DATE_DESC:
        query = getSession().getNamedQuery("getParentInstancesOrderByStartedDateDesc");
        break;
      case ENDED_DATE_DESC:
        query = getSession().getNamedQuery("getParentInstancesOrderByEndedDateDesc");
        break;
      case INSTANCE_NUMBER_DESC:
        query = getSession().getNamedQuery("getParentInstancesOrderByInstanceNumberDesc");
        break;
      case INSTANCE_UUID_DESC:
        query = getSession().getNamedQuery("getParentInstancesOrderByInstanceUUIDDesc");
        break;
      case DEFAULT:
        query = getSession().getNamedQuery("getParentInstances");
        break;
    }

    query.setFirstResult(fromIndex);
    query.setMaxResults(pageSize);
    return formatList(query.list());
  }

  @Override
  public List getParentProcessInstances(final Set processUUIDs,
      final int fromIndex, final int pageSize, final ProcessInstanceCriterion pagingCriterion) {
    Query query = null;
    switch (pagingCriterion) {
      case LAST_UPDATE_ASC:
        query = getSession().getNamedQuery("getParentInstancesFromProcessUUIDsOrderByLastUpdateAsc");
        break;
      case STARTED_DATE_ASC:
        query = getSession().getNamedQuery("getParentInstancesFromProcessUUIDsOrderByStartedDateAsc");
        break;
      case ENDED_DATE_ASC:
        query = getSession().getNamedQuery("getParentInstancesFromProcessUUIDsOrderByEndedDateAsc");
        break;
      case INSTANCE_NUMBER_ASC:
        query = getSession().getNamedQuery("getParentInstancesFromProcessUUIDsOrderByInstanceNumberAsc");
        break;
      case INSTANCE_UUID_ASC:
        query = getSession().getNamedQuery("getParentInstancesFromProcessUUIDsOrderByInstanceUUIDAsc");
        break;
      case LAST_UPDATE_DESC:
        query = getSession().getNamedQuery("getParentInstancesFromProcessUUIDsOrderByLastUpdateDesc");
        break;
      case STARTED_DATE_DESC:
        query = getSession().getNamedQuery("getParentInstancesFromProcessUUIDsOrderByStartedDateDesc");
        break;
      case ENDED_DATE_DESC:
        query = getSession().getNamedQuery("getParentInstancesFromProcessUUIDsOrderByEndedDateDesc");
        break;
      case INSTANCE_NUMBER_DESC:
        query = getSession().getNamedQuery("getParentInstancesFromProcessUUIDsOrderByInstanceNumberDesc");
        break;
      case INSTANCE_UUID_DESC:
        query = getSession().getNamedQuery("getParentInstancesFromProcessUUIDsOrderByInstanceUUIDDesc");
        break;
      case DEFAULT:
        query = getSession().getNamedQuery("getParentInstancesFromProcessUUIDsOrderByLastUpdateDesc");
        break;
    }

    query.setFirstResult(fromIndex);
    query.setMaxResults(pageSize);
    final List uuids = new ArrayList();
    for (final ProcessDefinitionUUID uuid : processUUIDs) {
      uuids.add(uuid.toString());
    }

    final List results = executeSplittedQueryList(InternalProcessInstance.class, query,
        "processUUIDs", uuids);
    if (results == null) {
      return Collections.emptyList();
    }
    return results;
  }

  @Override
  public List getParentProcessInstancesExcept(final Set exceptions,
      final int fromIndex, final int pageSize, final ProcessInstanceCriterion pagingCriterion) {
    Query query = null;
    switch (pagingCriterion) {
      case LAST_UPDATE_ASC:
        query = getSession().getNamedQuery("getParentInstancesExceptOrderByLastUpdateAsc");
        break;
      case STARTED_DATE_ASC:
        query = getSession().getNamedQuery("getParentInstancesExceptOrderByStartedDateAsc");
        break;
      case ENDED_DATE_ASC:
        query = getSession().getNamedQuery("getParentInstancesExceptOrderByEndedDateAsc");
        break;
      case INSTANCE_NUMBER_ASC:
        query = getSession().getNamedQuery("getParentInstancesExceptOrderByInstanceNumberAsc");
        break;
      case INSTANCE_UUID_ASC:
        query = getSession().getNamedQuery("getParentInstancesExceptOrderByInstanceUUIDAsc");
        break;
      case LAST_UPDATE_DESC:
        query = getSession().getNamedQuery("getParentInstancesExceptOrderByLastUpdateDesc");
        break;
      case STARTED_DATE_DESC:
        query = getSession().getNamedQuery("getParentInstancesExceptOrderByStartedDateDesc");
        break;
      case ENDED_DATE_DESC:
        query = getSession().getNamedQuery("getParentInstancesExceptOrderByEndedDateDesc");
        break;
      case INSTANCE_NUMBER_DESC:
        query = getSession().getNamedQuery("getParentInstancesExceptOrderByInstanceNumberDesc");
        break;
      case INSTANCE_UUID_DESC:
        query = getSession().getNamedQuery("getParentInstancesExceptOrderByInstanceUUIDDesc");
        break;
      case DEFAULT:
        query = getSession().getNamedQuery("getParentInstancesExceptOrderByLastUpdateDesc");
        break;
    }

    query.setFirstResult(fromIndex);
    query.setMaxResults(pageSize);
    final List uuids = new ArrayList();
    for (final ProcessDefinitionUUID uuid : exceptions) {
      uuids.add(uuid.toString());
    }

    final List results = executeSplittedQueryList(InternalProcessInstance.class, query,
        "processUUIDs", uuids);
    if (results == null) {
      return Collections.emptyList();
    }
    return results;
  }

  @Override
  @SuppressWarnings("unchecked")
  public List getProcesses(final int fromIndex, final int pageSize) {
    final Query query = getSession().getNamedQuery("getAllProcesses");
    query.setFirstResult(fromIndex);
    query.setMaxResults(pageSize);
    return formatList(query.list());
  }

  @Override
  @SuppressWarnings("unchecked")
  public List getProcesses(final int fromIndex, final int pageSize,
      final ProcessDefinitionCriterion pagingCriterion) {
    Query query = null;
    switch (pagingCriterion) {
      case NAME_ASC:
        query = getSession().getNamedQuery("getAllProcessesOrderByNameAsc");
        break;

      case LABEL_ASC:
        query = getSession().getNamedQuery("getAllProcessesOrderByLabelAsc");
        break;

      case VERSION_ASC:
        query = getSession().getNamedQuery("getAllProcessesOrderByVersionAsc");
        break;

      case STATE_ASC:
        query = getSession().getNamedQuery("getAllProcessesOrderByStateAsc");
        break;

      case NAME_DESC:
        query = getSession().getNamedQuery("getAllProcessesOrderByNameDesc");
        break;

      case LABEL_DESC:
        query = getSession().getNamedQuery("getAllProcessesOrderByLabelDesc");
        break;

      case VERSION_DESC:
        query = getSession().getNamedQuery("getAllProcessesOrderByVersionDesc");
        break;

      case STATE_DESC:
        query = getSession().getNamedQuery("getAllProcessesOrderByStateDesc");
        break;

      case DEFAULT:
        query = getSession().getNamedQuery("getAllProcesses");
        break;
    }

    query.setFirstResult(fromIndex);
    query.setMaxResults(pageSize);
    return formatList(query.list());
  }

  @Override
  public List getProcessInstances(final Collection instanceUUIDs,
      final int fromIndex, final int pageSize) {
    final Query query = getSession().getNamedQuery("findMatchingProcessInstances");

    query.setFirstResult(fromIndex);
    query.setMaxResults(pageSize);
    final Set uuids = new HashSet();
    if (instanceUUIDs != null) {
      for (final ProcessInstanceUUID uuid : instanceUUIDs) {
        uuids.add(uuid.toString());
      }
    }

    final List allInstances = new ArrayList();
    allInstances.addAll(executeSplittedQuery(InternalProcessInstance.class, query, "instanceUUIDs", uuids));
    Collections.sort(allInstances, new ProcessInstanceLastUpdateComparator());
    final List results = Misc
        .subList(InternalProcessInstance.class, allInstances, 0, pageSize);
    if (results == null) {
      return Collections.emptyList();
    }
    return results;
  }

  @Override
  public List getProcessInstancesWithInstanceUUIDs(
      final Set instanceUUIDs, final int fromIndex, final int pageSize,
      final ProcessInstanceCriterion pagingCriterion) {
    Query query = null;
    Comparator comparator = null;
    switch (pagingCriterion) {
      case LAST_UPDATE_ASC:
        comparator = new ProcessInstanceLastUpdateComparatorAsc();
        query = getSession().getNamedQuery("findMatchingProcessInstancesOrderByLastUpdateAsc");
        break;
      case STARTED_DATE_ASC:
        comparator = new ProcessInstanceStartedDateComparatorAsc();
        query = getSession().getNamedQuery("findMatchingProcessInstancesOrderByStartedDateAsc");
        break;
      case ENDED_DATE_ASC:
        comparator = new ProcessInstanceEndedDateComparatorAsc();
        query = getSession().getNamedQuery("findMatchingProcessInstancesOrderByEndedDateAsc");
        break;
      case INSTANCE_NUMBER_ASC:
        comparator = new ProcessInstanceNbComparatorAsc();
        query = getSession().getNamedQuery("findMatchingProcessInstancesOrderByInstanceNumberAsc");
        break;
      case INSTANCE_UUID_ASC:
        comparator = new ProcessInstanceUUIDComparatorAsc();
        query = getSession().getNamedQuery("findMatchingProcessInstancesOrderByIntanceUUIDAsc");
        break;
      case LAST_UPDATE_DESC:
        comparator = new ProcessInstanceLastUpdateComparator();
        query = getSession().getNamedQuery("findMatchingProcessInstancesOrderByLastUpdateDesc");
        break;
      case STARTED_DATE_DESC:
        comparator = new ProcessInstanceStartedDateComparatorDesc();
        query = getSession().getNamedQuery("findMatchingProcessInstancesOrderByStartedDateDesc");
        break;
      case ENDED_DATE_DESC:
        comparator = new ProcessInstanceEndedDateComparatorDesc();
        query = getSession().getNamedQuery("findMatchingProcessInstancesOrderByEndedDateDesc");
        break;
      case INSTANCE_NUMBER_DESC:
        comparator = new ProcessInstanceNbComparatorDesc();
        query = getSession().getNamedQuery("findMatchingProcessInstancesOrderByInstanceNumberDesc");
        break;
      case INSTANCE_UUID_DESC:
        comparator = new ProcessInstanceUUIDComparatorDesc();
        query = getSession().getNamedQuery("findMatchingProcessInstancesOrderByIntanceUUIDDesc");
        break;
      case DEFAULT:
        comparator = new ProcessInstanceLastUpdateComparator();
        query = getSession().getNamedQuery("findMatchingProcessInstances");
        break;
    }

    query.setFirstResult(fromIndex);
    query.setMaxResults(pageSize);
    final Set uuids = new HashSet();
    if (instanceUUIDs != null) {
      for (final ProcessInstanceUUID uuid : instanceUUIDs) {
        uuids.add(uuid.toString());
      }
    }

    final List allInstances = new ArrayList();
    allInstances.addAll(executeSplittedQuery(InternalProcessInstance.class, query, "instanceUUIDs", uuids));
    Collections.sort(allInstances, comparator);
    final List results = Misc
        .subList(InternalProcessInstance.class, allInstances, 0, pageSize);
    if (results == null) {
      return Collections.emptyList();
    }
    return results;
  }

  @Override
  @SuppressWarnings("unchecked")
  public List getLabelsCaseUUIDs(final String ownerName, final Set labelNames,
      final int fromIndex, final int pageSize) {
    final Query query = getSession().getNamedQuery("getLabelsCaseUUIDs");

    query.setFirstResult(fromIndex);
    query.setMaxResults(pageSize);
    query.setString("ownerName", ownerName);
    query.setParameterList("labelNames", labelNames);
    return query.list();
  }

  @Override
  @SuppressWarnings("unchecked")
  public Set getParentInstances() {
    final Set processInsts = new HashSet();
    final Query query = getSession().getNamedQuery("getParentInstances");

    final List results = query.list();
    if (results != null) {
      processInsts.addAll(results);
    }
    return processInsts;
  }

  @Override
  @SuppressWarnings("unchecked")
  public Set getParentInstancesUUIDs() {
    final Set processInsts = new HashSet();
    final Query query = getSession().getNamedQuery("getParentInstancesUUIDs");
    final List results = query.list();
    if (results != null) {
      processInsts.addAll(results);
    }
    return processInsts;
  }

  @Override
  public Set getProcessInstances(final Collection instanceUUIDs) {
    final Query query = getSession().getNamedQuery("findMatchingProcessInstances");
    final Set uuids = new HashSet();
    for (final ProcessInstanceUUID uuid : instanceUUIDs) {
      uuids.add(uuid.toString());
    }
    return executeSplittedQuery(InternalProcessInstance.class, query, "instanceUUIDs", uuids);
  }

  @Override
  @SuppressWarnings("unchecked")
  public Set getProcessInstancesWithTaskState(final Collection activityStates) {
    final Query getActivitiesQuery = getSession().getNamedQuery("findActivityInstancesWithTaskState");
    getActivitiesQuery.setParameterList("activityStates", activityStates, ACTIVITY_STATE_USER_TYPE);
    final List uuids = getActivitiesQuery.list();
    final Set processInsts = new HashSet();
    if (uuids.isEmpty()) {
      return processInsts;
    }
    final Query query = getSession().getNamedQuery("findMatchingProcessInstances");
    return executeSplittedQuery(InternalProcessInstance.class, query, "instanceUUIDs", uuids);
  }

  @Override
  @SuppressWarnings("unchecked")
  public Set getProcessInstancesWithInstanceStates(
      final Collection instanceStates) {
    final Query getProcessInstancesQuery = getSession().getNamedQuery("findProcessInstancesWithInstanceStates");
    getProcessInstancesQuery.setParameterList("instanceStates", instanceStates, DEFINITION_STATE_USER_TYPE);
    final List uuids = getProcessInstancesQuery.list();
    final Set processInsts = new HashSet();
    if (uuids.isEmpty()) {
      return processInsts;
    }
    final Query query = getSession().getNamedQuery("findMatchingProcessInstances");
    return executeSplittedQuery(InternalProcessInstance.class, query, "instanceUUIDs", uuids);
  }

  @Override
  @SuppressWarnings("unchecked")
  public Set getProcessInstances(final ProcessDefinitionUUID processUUID) {
    final Set processInsts = new HashSet();
    final Query query = getSession().getNamedQuery("findProcessInstances");
    query.setString("processUUID", processUUID.toString());
    final List results = query.list();
    if (results != null) {
      processInsts.addAll(results);
    }
    return processInsts;
  }

  @Override
  @SuppressWarnings("unchecked")
  public Set getProcessInstances(final ProcessDefinitionUUID processUUID,
      final InstanceState instanceState) {
    final Set processInsts = new HashSet();
    final Query query = getSession().getNamedQuery("findProcessInstancesWithState");
    query.setString("processUUID", processUUID.toString());
    query.setParameter("state", instanceState, INSTANCE_STATE_USER_TYPE);
    final List results = query.list();
    if (results != null) {
      processInsts.addAll(results);
    }
    return processInsts;
  }

  @Override
  public TaskInstance getTaskInstance(final ActivityInstanceUUID taskUUID) {
    final Query query = getSession().getNamedQuery("findTaskInstance");
    query.setString("taskUUID", taskUUID.toString());
    query.setMaxResults(1);
    return (TaskInstance) query.uniqueResult();
  }

  @Override
  @SuppressWarnings("unchecked")
  public Set getTaskInstances(final ProcessInstanceUUID instanceUUID) {
    final Query query = getSession().getNamedQuery("findTaskInstances");
    query.setString("instanceUUID", instanceUUID.toString());
    final Set taskInstances = new HashSet();
    final List results = query.list();
    if (results != null) {
      taskInstances.addAll(results);
    }
    return taskInstances;
  }

  @Override
  @SuppressWarnings("unchecked")
  public Set getTaskInstances(final ProcessInstanceUUID instanceUUID, final Set taskNames) {
    final Query query = getSession().getNamedQuery("getTasksFromNames");
    query.setString("instanceUUID", instanceUUID.getValue());
    query.setParameterList("taskNames", taskNames);
    final Set taskInstances = new HashSet();
    final List results = query.list();
    if (results != null) {
      taskInstances.addAll(results);
    }
    return taskInstances;
  }

  /*
   * DEFINITION
   */
  @SuppressWarnings("unchecked")
  private Set getProcessSet(final Query query) {
    final List results = query.list();
    if (results != null) {
      return new HashSet(results);
    }
    return null;
  }

  @Override
  public Set getProcesses() {
    final Query query = getSession().getNamedQuery("getAllProcesses");

    return getProcessSet(query);
  }

  @Override
  public Set getProcesses(final String processId) {
    final Query query = getSession().getNamedQuery("getProcesses2");

    query.setString("processId", processId);
    return getProcessSet(query);
  }

  @Override
  public InternalProcessDefinition getProcess(final ProcessDefinitionUUID processUUID) {
    final Query query = getSession().getNamedQuery("getProcess");

    query.setString("processUUID", processUUID.toString());
    query.setMaxResults(1);
    return (InternalProcessDefinition) query.uniqueResult();
  }

  @Override
  public InternalProcessDefinition getProcess(final String processId, final String version) {
    final Query query = getSession().getNamedQuery("getProcessFromIdAndVersion");

    query.setString("processId", processId);
    query.setString("version", version);
    return (InternalProcessDefinition) query.uniqueResult();
  }

  @Override
  public Set getProcesses(final ProcessState processState) {
    final Query query = getSession().getNamedQuery("getProcessesFromState");
    query.setParameter("state", processState, DEFINITION_STATE_USER_TYPE);

    return getProcessSet(query);
  }

  @Override
  public Set getProcesses(final String processId, final ProcessState processState) {
    final Query query = getSession().getNamedQuery("getProcessesFromProcessIdAndState");
    query.setParameter("state", processState, DEFINITION_STATE_USER_TYPE);

    query.setString("processId", processId);
    return getProcessSet(query);
  }

  @Override
  public String getLastProcessVersion(final String processName) {
    final Query query = getSession().getNamedQuery("getLastProcessVersion");

    query.setString("name", processName);
    query.setMaxResults(1);
    return (String) query.uniqueResult();
  }

  @Override
  public InternalProcessDefinition getLastProcess(final String processId, final ProcessState processState) {
    final Query query = getSession().getNamedQuery("getLastProcessFromProcessIdAndState");
    query.setParameter("state", processState, DEFINITION_STATE_USER_TYPE);

    query.setString("processId", processId);
    query.setMaxResults(1);
    return (InternalProcessDefinition) query.uniqueResult();
  }

  @Override
  public InternalActivityInstance getActivityInstance(final ProcessInstanceUUID instanceUUID, final String activityId,
      final String iterationId, final String activityInstanceId, final String loopId) {
    final Query query = getSession().getNamedQuery("getActivityInstance");

    query.setString("instanceUUID", instanceUUID.toString());
    query.setString("activityId", activityId);
    query.setString("iterationId", iterationId);
    query.setString("activityInstanceId", activityInstanceId);
    query.setString("loopId", loopId);
    return (InternalActivityInstance) query.uniqueResult();
  }

  @Override
  public InternalActivityInstance getActivityInstance(final ActivityInstanceUUID activityInstanceUUID) {
    final Query query = getSession().getNamedQuery("getActivityInstanceFromUUID");

    query.setString("activityUUID", activityInstanceUUID.toString());
    return (InternalActivityInstance) query.uniqueResult();
  }

  @Override
  public ActivityState getActivityInstanceState(final ActivityInstanceUUID activityInstanceUUID) {
    final Query query = getSession().getNamedQuery("getActivityInstanceStateFromUUID");

    query.setString("activityUUID", activityInstanceUUID.toString());
    return (ActivityState) query.uniqueResult();
  }

  @Override
  public InternalActivityDefinition getActivityDefinition(final ActivityDefinitionUUID activityDefinitionUUID) {
    final Query query = getSession().getNamedQuery("getActivityDefinition");

    query.setString("activityUUID", activityDefinitionUUID.toString());
    query.setMaxResults(1);
    return (InternalActivityDefinition) query.uniqueResult();
  }

  @Override
  public Execution getExecutionWithEventUUID(final String eventUUID) {
    final Query query = getSession().getNamedQuery("getExecutionWithEventUUID");

    query.setString("eventUUID", eventUUID);
    return (Execution) query.uniqueResult();
  }

  @Override
  public Set getExecutions(final ProcessInstanceUUID instanceUUID) {
    final Query query = getSession().getNamedQuery("getInstanceExecutions");

    query.setString("instanceUUID", instanceUUID.getValue());
    final Set executions = new HashSet();
    CollectionUtils.addAll(executions, query.iterate());
    return executions;
  }

  @Override
  public Execution getExecutionPointingOnNode(final ActivityInstanceUUID activityUUID) {
    final Query query = getSession().getNamedQuery("findInstanceExecutionPointingOnNode");

    query.setString("activityUUID", activityUUID.toString());
    return (Execution) query.uniqueResult();
  }

  /*
   * RUNTIME
   */
  @Override
  public MetaDataImpl getMetaData(final String key) {
    final Query query = getSession().getNamedQuery("getMetaData");

    query.setString("key", key);
    return (MetaDataImpl) query.uniqueResult();
  }

  @Override
  public Set getAllCases() {
    final Set result = new HashSet();
    final Query query = getSession().getNamedQuery("getAllCases");

    CollectionUtils.addAll(result, query.iterate());
    return result;
  }

  @Override
  public Set getCases(final Set caseUUIDs) {
    final Collection uuids = new HashSet();
    if (caseUUIDs != null) {
      for (final ProcessInstanceUUID processInstanceUUID : caseUUIDs) {
        uuids.add(processInstanceUUID.getValue());
      }
    }
    final Query query = getSession().getNamedQuery("getMatchingCases");

    return executeSplittedQuery(CaseImpl.class, query, "uuids", uuids);
  }

  @Override
  public List getUserCustomLabels(final String ownerName) {
    final List result = new ArrayList();
    final Query query = getSession().getNamedQuery("getUserCustomLabels");
    query.setString("ownerName", ownerName);
    CollectionUtils.addAll(result, query.iterate());
    return result;
  }

  @Override
  public List getSystemLabels(final String ownerName) {

    final List result = new ArrayList();
    final Query query = getSession().getNamedQuery("getSystemLabels");
    query.setString("ownerName", ownerName);
    CollectionUtils.addAll(result, query.iterate());

    return result;
  }

  @Override
  public LabelImpl getLabel(final String ownerName, final String labelName) {
    final Query query = getSession().getNamedQuery("getLabelByID");
    query.setString("ownerName", ownerName);
    query.setString("labelName", labelName);

    query.setMaxResults(1);
    final LabelImpl theResult = (LabelImpl) query.uniqueResult();

    return theResult;
  }

  @Override
  public Set getLabels(final String ownerName) {
    final Set result = new HashSet();
    final Query query = getSession().getNamedQuery("getAllLabels");
    query.setString("ownerName", ownerName);
    CollectionUtils.addAll(result, query.iterate());

    return result;
  }

  @Override
  @SuppressWarnings("unchecked")
  public Set getCaseLabels(final String ownerName, final ProcessInstanceUUID case_) {
    final Query getUserCases = getSession().getNamedQuery("getUserCases");
    getUserCases.setString("ownerName", ownerName);
    getUserCases.setString("caseId", case_.getValue());
    final List caseLabelsNames = getUserCases.list();
    Set result = new HashSet();
    if (!caseLabelsNames.isEmpty()) {
      final Query query = getSession().getNamedQuery("getLabels");
      query.setString("ownerName", ownerName);

      result = executeSplittedQuery(LabelImpl.class, query, "labelNames", caseLabelsNames);
    }
    return result;
  }

  private  Set executeSplittedQuery(final Class clazz, final Query query, final String parameterName,
      final Collection values) {
    if (values == null || values.isEmpty()) {
      return Collections.emptySet();
    }
    final Set result = new HashSet();
    if (values.size() <= BonitaConstants.MAX_QUERY_SIZE) {
      query.setParameterList(parameterName, values);
      CollectionUtils.addAll(result, query.iterate());
      return result;
    }

    final List> newValues = Misc.splitCollection(values, BonitaConstants.MAX_QUERY_SIZE);
    for (final Collection