ACT-30 second piece of the historic activity instances

modules/activiti-engine/src/main/java/org/activiti/engine/impl/HistoricActivityInstanceQueryImpl.java

@@ -21,7 +21,7 @@ import org.activiti.engine.history.HistoricActivityInstance;
 import org.activiti.engine.history.HistoricActivityInstanceQuery;
 import org.activiti.engine.history.HistoricActivityInstanceQueryProperty;
 import org.activiti.engine.impl.interceptor.CommandContext;
-import org.activiti.engine.runtime.ProcessInstance;
+import org.activiti.engine.impl.interceptor.CommandExecutor;
 
 
 /**
@@ -29,11 +29,22 @@ import org.activiti.engine.runtime.ProcessInstance;
  */
 public class HistoricActivityInstanceQueryImpl extends AbstractQuery<HistoricActivityInstance> implements HistoricActivityInstanceQuery {
   
-  protected String processDefinitionId;
   protected String processInstanceId;
+  protected String executionId;
+  protected String processDefinitionId;
+  protected String activityId;
+  protected String activityName;
+  protected String activityType;
+  protected boolean onlyOpen;
   protected HistoricActivityInstanceQueryProperty orderProperty;
   protected String orderBy;
 
+  public HistoricActivityInstanceQueryImpl() {
+  }
+  
+  public HistoricActivityInstanceQueryImpl(CommandExecutor commandExecutor) {
+    super(commandExecutor);
+  }
 
   @Override
   public long executeCount(CommandContext commandContext) {
@@ -44,33 +55,59 @@ public class HistoricActivityInstanceQueryImpl extends AbstractQuery<HistoricAct
 
   @Override
   public List<HistoricActivityInstance> executeList(CommandContext commandContext, Page page) {
-    return (List) commandContext
+    return commandContext
       .getHistorySession()
       .findHistoricActivityInstancesByQueryCriteria(this, page);
   }
   
 
-  public HistoricActivityInstanceQuery processDefinitionId(String processDefinitionId) {
+  public HistoricActivityInstanceQueryImpl processInstanceId(String processInstanceId) {
+    this.processInstanceId = processInstanceId;
+    return this;
+  }
+
+  public HistoricActivityInstanceQueryImpl executionId(String executionId) {
+    this.executionId = executionId;
+    return this;
+  }
+
+  public HistoricActivityInstanceQueryImpl processDefinitionId(String processDefinitionId) {
     this.processDefinitionId = processDefinitionId;
     return this;
   }
 
-  public HistoricActivityInstanceQuery processInstanceId(String processInstanceId) {
-    this.processInstanceId = processInstanceId;
+  public HistoricActivityInstanceQueryImpl activityId(String activityId) {
+    this.activityId = activityId;
+    return this;
+  }
+
+  public HistoricActivityInstanceQueryImpl activityName(String activityName) {
+    this.activityName = activityName;
     return this;
   }
 
+  public HistoricActivityInstanceQueryImpl activityType(String activityType) {
+    this.activityType = activityType;
+    return this;
+  }
+  
+  public HistoricActivityInstanceQueryImpl onlyOpen() {
+    this.onlyOpen = true;
+    return this;
+  }
+
+
   // ordering /////////////////////////////////////////////////////////////////
 
-  public HistoricActivityInstanceQuery asc() {
+  public HistoricActivityInstanceQueryImpl asc() {
     return direction(Direction.ASCENDING);
   }
 
-  public HistoricActivityInstanceQuery desc() {
+  public HistoricActivityInstanceQueryImpl desc() {
     return direction(Direction.DESCENDING);
   }
 
-  public HistoricActivityInstanceQuery direction(Direction direction) {
+  public HistoricActivityInstanceQueryImpl direction(Direction direction) {
     if (orderProperty==null) {
       throw new ActivitiException("you should call any of the orderBy methods first before specifying a direction");
     }
@@ -79,43 +116,70 @@ public class HistoricActivityInstanceQueryImpl extends AbstractQuery<HistoricAct
     return this;
   }
 
-  public HistoricActivityInstanceQuery orderBy(HistoricActivityInstanceQueryProperty property) {
+  public HistoricActivityInstanceQueryImpl orderBy(HistoricActivityInstanceQueryProperty property) {
     this.orderProperty = property;
     return this;
   }
 
-  public HistoricActivityInstanceQuery orderByDuration() {
+  public HistoricActivityInstanceQueryImpl orderByDuration() {
     orderBy(HistoricActivityInstanceQueryProperty.DURATION);
     return this;
   }
 
-  public HistoricActivityInstanceQuery orderByEnd() {
+  public HistoricActivityInstanceQueryImpl orderByEnd() {
     orderBy(HistoricActivityInstanceQueryProperty.END);
     return this;
   }
 
-  public HistoricActivityInstanceQuery orderByExecutionId() {
+  public HistoricActivityInstanceQueryImpl orderByExecutionId() {
     orderBy(HistoricActivityInstanceQueryProperty.EXECUTION_ID);
     return this;
   }
 
-  public HistoricActivityInstanceQuery orderById() {
+  public HistoricActivityInstanceQueryImpl orderById() {
     orderBy(HistoricActivityInstanceQueryProperty.ID);
     return this;
   }
 
-  public HistoricActivityInstanceQuery orderByProcessDefinitionId() {
+  public HistoricActivityInstanceQueryImpl orderByProcessDefinitionId() {
     orderBy(HistoricActivityInstanceQueryProperty.PROCESS_DEFINITION_ID);
     return this;
   }
 
-  public HistoricActivityInstanceQuery orderByProcessInstanceId() {
+  public HistoricActivityInstanceQueryImpl orderByProcessInstanceId() {
     orderBy(HistoricActivityInstanceQueryProperty.PROCESS_INSTANCE_ID);
     return this;
   }
 
-  public HistoricActivityInstanceQuery orderByStart() {
+  public HistoricActivityInstanceQueryImpl orderByStart() {
     orderBy(HistoricActivityInstanceQueryProperty.START);
     return this;
   }
+
+  // getters and setters //////////////////////////////////////////////////////
+  
+  public String getProcessInstanceId() {
+    return processInstanceId;
+  }
+  public String getExecutionId() {
+    return executionId;
+  }
+  public String getProcessDefinitionId() {
+    return processDefinitionId;
+  }
+  public String getActivityId() {
+    return activityId;
+  }
+  public String getOrderBy() {
+    return orderBy;
+  }
+  public String getActivityName() {
+    return activityName;
+  }
+  public String getActivityType() {
+    return activityType;
+  }
+  public boolean isOnlyOpen() {
+    return onlyOpen;
+  }
 }

modules/activiti-engine/src/main/java/org/activiti/engine/impl/HistoricProcessInstanceQueryImpl.java

@@ -30,8 +30,6 @@ public class HistoricProcessInstanceQueryImpl extends AbstractQuery<HistoricProc
   protected String processDefinitionId;
   protected String processDefinitionKey;
   
-  protected CommandExecutor commandExecutor;
-  
   public HistoricProcessInstanceQueryImpl() {
   }
   

modules/activiti-engine/src/main/java/org/activiti/engine/impl/db/DbHistorySession.java

@@ -39,6 +39,7 @@ public class DbHistorySession extends AbstractDbSession implements HistorySessio
   }
 
   public void deleteHistoricProcessInstance(String historicProcessInstanceId) {
+    dbSqlSession.delete("deleteHistoricActivityInstancesByProcessInstanceId", historicProcessInstanceId);
     dbSqlSession.delete(HistoricProcessInstanceEntity.class, historicProcessInstanceId);
   }
 

modules/activiti-engine/src/main/java/org/activiti/engine/impl/db/DbSqlSession.java

@@ -14,6 +14,7 @@
 package org.activiti.engine.impl.db;
 
 import java.util.ArrayList;
+import java.util.Collections;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
@@ -234,6 +235,19 @@ public class DbSqlSession implements Session {
     }
     classCache.remove(persistentObjectId);
   }
+  
+  @SuppressWarnings("unchecked")
+  public <T> List<T> findInCache(Class<T> entityClass) {
+    Map<String, CachedObject> classCache = cachedObjects.get(entityClass);
+    if (classCache!=null) {
+      ArrayList<T> entities = new ArrayList<T>(classCache.size());
+      for (CachedObject cachedObject: classCache.values()) {
+        entities.add((T) cachedObject.getPersistentObject());
+      }
+      return entities;
+    }
+    return Collections.emptyList();
+  }
 
   public static class CachedObject {
     protected PersistentObject persistentObject;

modules/activiti-engine/src/main/java/org/activiti/engine/impl/history/HistoricActivityInstanceEntity.java

@@ -14,6 +14,8 @@
 
 package org.activiti.engine.impl.history;
 
+import java.util.Map;
+
 import org.activiti.engine.history.HistoricActivityInstance;
 
 /**
@@ -25,6 +27,13 @@ public class HistoricActivityInstanceEntity extends HistoricScopeInstanceEntity
   protected String activityName;
   protected String activityType;
   protected String executionId;
+  
+  @SuppressWarnings("unchecked")
+  public Object getPersistentState() {
+    Map<String, Object> persistentState = (Map<String, Object>) super.getPersistentState();
+    persistentState.put("executionId", executionId);
+    return persistentState;
+  }
 
   // getters and setters //////////////////////////////////////////////////////
   

modules/activiti-engine/src/main/java/org/activiti/engine/impl/history/handler/ActivityInstanceEndHandler.java

@@ -13,8 +13,18 @@
 
 package org.activiti.engine.impl.history.handler;
 
+import java.util.Date;
+import java.util.List;
+
+import org.activiti.engine.ActivitiException;
+import org.activiti.engine.history.HistoricActivityInstance;
+import org.activiti.engine.impl.HistoricActivityInstanceQueryImpl;
+import org.activiti.engine.impl.Page;
+import org.activiti.engine.impl.db.DbSqlSession;
 import org.activiti.engine.impl.history.HistoricActivityInstanceEntity;
+import org.activiti.engine.impl.interceptor.CommandContext;
 import org.activiti.engine.impl.runtime.ExecutionEntity;
+import org.activiti.engine.impl.util.ClockUtil;
 import org.activiti.pvm.event.EventListener;
 import org.activiti.pvm.event.EventListenerExecution;
 
@@ -26,21 +36,46 @@ public class ActivityInstanceEndHandler implements EventListener {
 
   public void notify(EventListenerExecution execution) {
     ExecutionEntity executionEntity = (ExecutionEntity) execution;
-//    HistoricActivityInstanceEntity historicActivityInstance = findActivityInstance(executionEntity);
-//
-//    Date endTime = ClockUtil.getCurrentTime();
-//    long durationInMillis = endTime.getTime() - historicActivityInstance.getStartTime().getTime();
-//    historicActivityInstance.setEndTime(endTime);
-//    historicActivityInstance.setDurationInMillis(durationInMillis);
+    HistoricActivityInstanceEntity historicActivityInstance = findActivityInstance(executionEntity);
+
+    Date endTime = ClockUtil.getCurrentTime();
+    long durationInMillis = endTime.getTime() - historicActivityInstance.getStartTime().getTime();
+    historicActivityInstance.setEndTime(endTime);
+    historicActivityInstance.setDurationInMillis(durationInMillis);
   }
 
   public HistoricActivityInstanceEntity findActivityInstance(ExecutionEntity execution) {
-//    CommandContext commandContext = CommandContext.getCurrent();
-//    HistoricProcessInstanceEntity historicProcessInstance = new HistoricActivityInstanceQueryImpl(commandContext)
-//      .executionId(execution.getId())
-//      .activityId(execution.getActivityId())
-//      .listPage(0, 1);
-//    
-    return null;
+    CommandContext commandContext = CommandContext.getCurrent();
+
+    String executionId = execution.getId();
+    String activityId = execution.getActivityId();
+
+    // TODO search for the historic activity instance in the dbsqlsession cache
+    DbSqlSession dbSqlSession = commandContext.getDbSqlSession();
+    List<HistoricActivityInstanceEntity> cachedHistoricActivityInstances = dbSqlSession.findInCache(HistoricActivityInstanceEntity.class);
+    for (HistoricActivityInstanceEntity cachedHistoricActivityInstance: cachedHistoricActivityInstances) {
+      if ( executionId.equals(cachedHistoricActivityInstance.getExecutionId())
+           && (activityId.equals(cachedHistoricActivityInstance.getActivityId()))
+           && (cachedHistoricActivityInstance.getEndTime()==null)
+         ) {
+        return cachedHistoricActivityInstance;
+      }
+    }
+    
+    List<HistoricActivityInstance> historicActivityInstances = new HistoricActivityInstanceQueryImpl()
+      .executionId(executionId)
+      .activityId(activityId)
+      .onlyOpen()
+      .executeList(commandContext, new Page(0, 1));
+    
+    if (!historicActivityInstances.isEmpty()) {
+      return (HistoricActivityInstanceEntity) historicActivityInstances.get(0);
+    }
+    
+    if (execution.getParentId()!=null) {
+      return findActivityInstance((ExecutionEntity) execution.getParent());
+    }
+    
+    throw new ActivitiException("no existing history activity entity found for execution "+executionId+" in activity "+activityId);
   }
 }

modules/activiti-engine/src/main/java/org/activiti/engine/impl/history/handler/ActivityInstanceStartHandler.java

@@ -13,6 +13,11 @@
 
 package org.activiti.engine.impl.history.handler;
 
+import org.activiti.engine.impl.cfg.IdGenerator;
+import org.activiti.engine.impl.history.HistoricActivityInstanceEntity;
+import org.activiti.engine.impl.interceptor.CommandContext;
+import org.activiti.engine.impl.runtime.ExecutionEntity;
+import org.activiti.engine.impl.util.ClockUtil;
 import org.activiti.pvm.event.EventListener;
 import org.activiti.pvm.event.EventListenerExecution;
 
@@ -29,5 +34,25 @@ public class ActivityInstanceStartHandler implements EventListener {
   }
 
   public void notify(EventListenerExecution execution) {
+    CommandContext commandContext = CommandContext.getCurrent();
+    IdGenerator idGenerator = commandContext.getProcessEngineConfiguration().getIdGenerator();
+    
+    ExecutionEntity executionEntity = (ExecutionEntity) execution;
+    String processDefinitionId = executionEntity.getProcessDefinitionId();
+    String processInstanceId = executionEntity.getProcessInstanceId();
+    String executionId = execution.getId();
+
+    HistoricActivityInstanceEntity historicActivityInstance = new HistoricActivityInstanceEntity();
+    historicActivityInstance.setId(Long.toString(idGenerator.getNextId()));
+    historicActivityInstance.setProcessDefinitionId(processDefinitionId);
+    historicActivityInstance.setProcessInstanceId(processInstanceId);
+    historicActivityInstance.setExecutionId(executionId);
+    historicActivityInstance.setActivityId(executionEntity.getActivityId());
+    historicActivityInstance.setActivityType((String) executionEntity.getActivity().getProperty("type"));
+    historicActivityInstance.setStartTime(ClockUtil.getCurrentTime());
+    
+    commandContext
+      .getDbSqlSession()
+      .insert(historicActivityInstance);
   }
 }

modules/activiti-engine/src/main/java/org/activiti/engine/impl/history/handler/HistoryParseListener.java

@@ -33,40 +33,46 @@ public class HistoryParseListener implements BpmnParseListener {
     processDefinition.addEventListener(EventListener.EVENTNAME_END, new ProcessInstanceEndHandler());
   }
 
-  public void parseStartEvent(Element startEventElement, ScopeImpl scope, ActivityImpl startEventActivity) {
-  }
-
-  public void parseEndEvent(Element endEventElement, ScopeImpl scope, ActivityImpl activity) {
-  }
-
   public void parseExclusiveGateway(Element exclusiveGwElement, ScopeImpl scope, ActivityImpl activity) {
     addActivityHandlers(exclusiveGwElement, activity);
   }
 
-  public void parseParallelGateway(Element parallelGwElement, ScopeImpl scope, ActivityImpl activity) {
-  }
-
   public void parseCallActivity(Element callActivityElement, ScopeImpl scope, ActivityImpl activity) {
+    addActivityHandlers(callActivityElement, activity);
   }
 
   public void parseManualTask(Element manualTaskElement, ScopeImpl scope, ActivityImpl activity) {
+    addActivityHandlers(manualTaskElement, activity);
   }
 
   public void parseScript(Element scriptTaskElement, ScopeImpl scope, ActivityImpl activity) {
+    addActivityHandlers(scriptTaskElement, activity);
   }
 
   public void parseTask(Element taskElement, ScopeImpl scope, ActivityImpl activity) {
+    addActivityHandlers(taskElement, activity);
   }
 
   public void parseUserTask(Element userTaskElement, ScopeImpl scope, ActivityImpl activity) {
+    addActivityHandlers(userTaskElement, activity);
   }
 
   public void parseServiceTask(Element serviceTaskElement, ScopeImpl scope, ActivityImpl activity) {
+    addActivityHandlers(serviceTaskElement, activity);
   }
 
   public void parseSubProcess(Element subProcessElement, ScopeImpl scope, ActivityImpl activity) {
+    addActivityHandlers(subProcessElement, activity);
   }
 
+  public void parseStartEvent(Element startEventElement, ScopeImpl scope, ActivityImpl startEventActivity) {
+  }
+
+  public void parseEndEvent(Element endEventElement, ScopeImpl scope, ActivityImpl activity) {
+  }
+
+  public void parseParallelGateway(Element parallelGwElement, ScopeImpl scope, ActivityImpl activity) {
+  }
 
   public void parseBoundaryTimerEventDefinition(Element timerEventDefinition, boolean interrupting, ActivityImpl timerActivity) {
   }

modules/activiti-engine/src/main/java/org/activiti/engine/impl/runtime/ExecutionEntity.java

@@ -22,12 +22,16 @@ import java.util.logging.Logger;
 
 import javax.el.ELContext;
 
+import org.activiti.engine.history.HistoricActivityInstance;
+import org.activiti.engine.impl.HistoricActivityInstanceQueryImpl;
 import org.activiti.engine.impl.JobQueryImpl;
 import org.activiti.engine.impl.TaskQueryImpl;
 import org.activiti.engine.impl.bpmn.parser.BpmnParse;
 import org.activiti.engine.impl.calendar.BusinessCalendar;
 import org.activiti.engine.impl.calendar.DurationBusinessCalendar;
+import org.activiti.engine.impl.db.DbSqlSession;
 import org.activiti.engine.impl.db.PersistentObject;
+import org.activiti.engine.impl.history.HistoricActivityInstanceEntity;
 import org.activiti.engine.impl.interceptor.CommandContext;
 import org.activiti.engine.impl.jobexecutor.TimerDeclarationImpl;
 import org.activiti.engine.impl.task.TaskEntity;
@@ -358,9 +362,36 @@ public class ExecutionEntity extends ExecutionImpl implements PersistentObject,
       .getDbSqlSession()
       .delete(ExecutionEntity.class, id);
   }
+  
+  @SuppressWarnings("unchecked")
+  @Override
+  public void setReplacedBy(ExecutionImpl replacedBy) {
+    super.setReplacedBy(replacedBy);
+    
+    // update the cached historic activity instances that are open
+    CommandContext commandContext = CommandContext.getCurrent();
+    DbSqlSession dbSqlSession = commandContext.getDbSqlSession();
+    List<HistoricActivityInstanceEntity> cachedHistoricActivityInstances = dbSqlSession.findInCache(HistoricActivityInstanceEntity.class);
+    for (HistoricActivityInstanceEntity cachedHistoricActivityInstance: cachedHistoricActivityInstances) {
+      if ( (cachedHistoricActivityInstance.getEndTime()==null)
+           && (id.equals(cachedHistoricActivityInstance.getExecutionId())) 
+         ) {
+        cachedHistoricActivityInstance.setExecutionId(replacedBy.getId());
+      }
+    }
+    
+    // update the persisted historic activity instances that are open
+    List<HistoricActivityInstanceEntity> historicActivityInstances = (List) new HistoricActivityInstanceQueryImpl()
+      .executionId(id)
+      .onlyOpen()
+      .executeList(commandContext, null);
+    for (HistoricActivityInstanceEntity historicActivityInstance: historicActivityInstances) {
+      historicActivityInstance.setExecutionId(replacedBy.getId());
+    }
+  }
 
   // variables ////////////////////////////////////////////////////////////////
-  
+
   @Override
   protected void ensureVariablesInitialized() {
     if (variables==null) {

modules/activiti-engine/src/main/resources/org/activiti/db/ibatis/history.mapping.xml

@@ -85,7 +85,7 @@
     </if>
   </select>
   
-  <select id="selectHistoricProcessInstanceCountByQueryCriteria" parameterType="org.activiti.engine.impl.ExecutionQueryImpl" resultType="long">
+  <select id="selectHistoricProcessInstanceCountByQueryCriteria" parameterType="org.activiti.engine.impl.HistoricProcessInstanceQueryImpl" resultType="long">
     select count(*)
     <include refid="selectHistoricProcessInstancesByQueryCriteriaSql"/>
   </select>
@@ -104,21 +104,23 @@
   <insert id="insertHistoricActivityInstance" parameterType="org.activiti.engine.impl.history.HistoricActivityInstanceEntity">
       insert into ACT_HI_ACT_INST (
         ID_,
+        PROC_DEF_ID_,
+        PROC_INST_ID_,
+        EXECUTION_ID_,
         ACT_ID_,
         ACT_NAME_,
         ACT_TYPE_,
-        PROC_INST_ID_,
-        PROC_DEF_ID_,
         START_TIME_,
         END_TIME_,
         DURATION_
       ) values (
         #{id ,jdbcType=VARCHAR},
+        #{processDefinitionId, jdbcType=VARCHAR},
+        #{processInstanceId, jdbcType=VARCHAR},
+        #{executionId, jdbcType=VARCHAR},
         #{activityId ,jdbcType=VARCHAR},
         #{activityName ,jdbcType=VARCHAR},
         #{activityType ,jdbcType=VARCHAR},
-        #{processInstanceId, jdbcType=VARCHAR},
-        #{processDefinitionId, jdbcType=VARCHAR},
         #{startTime, jdbcType=TIMESTAMP},
         #{endTime, jdbcType=TIMESTAMP},
         #{durationInMillis ,jdbcType=BIGINT}
@@ -129,12 +131,7 @@
   
   <update id="updateHistoricActivityInstance" parameterType="org.activiti.engine.impl.history.HistoricActivityInstanceEntity">
     update ACT_HI_ACT_INST set
-      ACT_ID_ = #{activityId, jdbcType=VARCHAR},
-      ACT_NAME_ = #{activityName, jdbcType=VARCHAR},
-      ACT_TYPE_ = #{activityType, jdbcType=VARCHAR},
-      PROC_INST_ID_ = #{processInstanceId, jdbcType=VARCHAR},
-      PROC_DEF_ID_ = #{processDefinitionId, jdbcType=VARCHAR},
-      START_TIME_ = #{startTime, jdbcType=TIMESTAMP},
+      EXECUTION_ID_ = #{executionId, jdbcType=VARCHAR},
       END_TIME_ = #{endTime, jdbcType=TIMESTAMP},
       DURATION_ = #{durationInMillis ,jdbcType=BIGINT}
     where ID_ = #{id}
@@ -142,19 +139,20 @@
 
   <!-- HISTORIC ACTIVITY INSTANCE DELETE -->
   
-  <delete id="deleteHistoricActivityInstance">
-    delete from ACT_HI_ACT_INST where ACT_ID_ = #{activityId} and PROC_INST_ID_ = #{processInstanceId}
+  <delete id="deleteHistoricActivityInstancesByProcessInstanceId">
+    delete from ACT_HI_ACT_INST where PROC_INST_ID_ = #{processInstanceId}
   </delete>
 
   <!-- HISTORIC ACTIVITY INSTANCE RESULT MAP -->
 
   <resultMap id="historicActivityInstanceResultMap" type="org.activiti.engine.impl.history.HistoricActivityInstanceEntity">
     <id property="id" column="ID_" jdbcType="VARCHAR" />
+    <result property="processDefinitionId" column="PROC_DEF_ID_" jdbcType="VARCHAR" />
+    <result property="processInstanceId" column="PROC_INST_ID_" jdbcType="VARCHAR" />
+    <result property="executionId" column="EXECUTION_ID_" jdbcType="VARCHAR" />
     <result property="activityId" column="ACT_ID_" jdbcType="VARCHAR" />
     <result property="activityName" column="ACT_NAME_" jdbcType="VARCHAR" />
     <result property="activityType" column="ACT_TYPE_" jdbcType="VARCHAR" />
-    <result property="processInstanceId" column="PROC_INST_ID_" jdbcType="VARCHAR" />
-    <result property="processDefinitionId" column="PROC_DEF_ID_" jdbcType="VARCHAR" />
     <result property="startTime" column="START_TIME_" jdbcType="TIMESTAMP" />
     <result property="endTime" column="END_TIME_" jdbcType="TIMESTAMP" />
     <result property="durationInMillis" column="DURATION_" jdbcType="BIGINT" />
@@ -166,4 +164,44 @@
     select * from ACT_HI_ACT_INST where ACT_ID_ = #{activityId} and PROC_INST_ID_ = #{processInstanceId}
   </select>
 
+  <select id="selectHistoricActivityInstancesByQueryCriteria" parameterType="org.activiti.engine.impl.HistoricActivityInstanceQueryImpl" resultMap="historicActivityInstanceResultMap">
+    select *
+    <include refid="selectHistoricActivityInstancesByQueryCriteriaSql"/>
+    <if test="orderBy != null">
+      order by ${orderBy}
+    </if>
+  </select>
+  
+  <select id="selectHistoricActivityInstanceCountByQueryCriteria" parameterType="org.activiti.engine.impl.HistoricActivityInstanceQueryImpl" resultType="long">
+    select count(*)
+    <include refid="selectHistoricActivityInstancesByQueryCriteriaSql"/>
+  </select>
+  
+  <sql id="selectHistoricActivityInstancesByQueryCriteriaSql">
+    from ACT_HI_ACT_INST HAI
+    <where>
+      <if test="processInstanceId != null">
+        HAI.PROC_INST_ID_ = #{processInstanceId}
+      </if>
+      <if test="executionId != null">
+        and HAI.EXECUTION_ID_ = #{executionId}
+      </if>
+      <if test="processDefinitionId != null">
+        and HAI.PROC_DEF_ID_ = #{processDefinitionId}
+      </if>
+      <if test="activityId != null">
+        and HAI.ACT_ID_ = #{activityId}
+      </if>
+      <if test="activityName != null">
+        and HAI.ACT_NAME_ = #{activityName}
+      </if>
+      <if test="activityType != null">
+        and HAI.ACT_TYPE_ = #{activityType}
+      </if>
+      <if test="onlyOpen">
+        and HAI.END_TIME_ is null
+      </if>
+    </where>
+  </sql>
+  
 </mapper>