Changes for bulk insert queries.

Changes for multiple VariableInstance insertions in one query

Remove an extra statement

Added bulk insert for UserEntity

Changes in all entities for bulk insert

Added Oracle specific bulk insert queries

Resolve Test Issues

ACT-4014 Changes for maintaining dependency ordering for entities while inserting

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

@@ -28,6 +28,7 @@
 import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
+import java.util.LinkedHashMap;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 
@@ -56,10 +57,14 @@
 import org.activiti.engine.impl.UserQueryImpl;
 import org.activiti.engine.impl.cfg.ProcessEngineConfigurationImpl;
 import org.activiti.engine.impl.context.Context;
+import org.activiti.engine.impl.db.PersistentObject;
 import org.activiti.engine.impl.db.upgrade.DbUpgradeStep;
 import org.activiti.engine.impl.history.HistoryLevel;
 import org.activiti.engine.impl.interceptor.Session;
+import org.activiti.engine.impl.persistence.entity.IdentityLinkEntity;
 import org.activiti.engine.impl.persistence.entity.PropertyEntity;
+import org.activiti.engine.impl.persistence.entity.ResourceEntity;
+import org.activiti.engine.impl.persistence.entity.UserEntity;
 import org.activiti.engine.impl.persistence.entity.VariableInstanceEntity;
 import org.activiti.engine.impl.util.IoUtil;
 import org.activiti.engine.impl.util.ReflectUtil;
@@ -68,7 +73,6 @@
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
-
 /** responsibilities:
  *   - delayed flushing of inserts updates and deletes
  *   - optional dirty checking
@@ -273,6 +277,7 @@ public void clearCache() {
       cacheRemove(persistentObject.getClass(), persistentObject.getId());
     }
 
+    @Override
     public void execute() {
       String deleteStatement = dbSqlSessionFactory.getDeleteStatement(persistentObject.getClass());
       deleteStatement = dbSqlSessionFactory.mapStatement(deleteStatement);
@@ -335,6 +340,7 @@ public void clearCache() {
     	}
     }
 
+    @Override
     public void execute() {
 
     	if (persistentObjects.isEmpty()) {
@@ -571,6 +577,7 @@ public void addDeserializedObject(DeserializedObject deserializedObject) {
 
   // flush ////////////////////////////////////////////////////////////////////
 
+  @Override
   public void flush() {
     List<DeleteOperation> removedOperations = removeUnnecessaryOperations();
 
@@ -735,7 +742,7 @@ protected boolean isPersistentObjectDeleted(PersistentObject persistentObject) {
     return false;
   }
 
-  public <T extends PersistentObject> List<T> pruneDeletedEntities(List<T> listToPrune) {   
+  public <T extends PersistentObject> List<T> pruneDeletedEntities(List<T> listToPrune) {
     List<T> prunedList = new ArrayList<T>(listToPrune);
     for (T potentiallyDeleted : listToPrune) {
       for (DeleteOperation deleteOperation: deleteOperations) {
@@ -750,25 +757,49 @@ protected boolean isPersistentObjectDeleted(PersistentObject persistentObject) {
   }
 
   protected void flushInserts() {
+    LinkedHashMap<Class<? extends PersistentObject>, List<PersistentObject>> bulkInsertHandledMap =
+        new LinkedHashMap<Class<? extends PersistentObject>, List<PersistentObject>>();
     for (PersistentObject insertedObject: insertedObjects) {
-      String insertStatement = dbSqlSessionFactory.getInsertStatement(insertedObject);
-      insertStatement = dbSqlSessionFactory.mapStatement(insertStatement);
-
-      if (insertStatement==null) {
-        throw new ActivitiException("no insert statement for "+insertedObject.getClass()+" in the ibatis mapping files");
+      if (!bulkInsertHandledMap.containsKey(insertedObject.getClass())) {
+        bulkInsertHandledMap.put(insertedObject.getClass(), new ArrayList<PersistentObject>());
       }
-
-      log.debug("inserting: {}", insertedObject);
-      sqlSession.insert(insertStatement, insertedObject);
-      
-      // See http://jira.codehaus.org/browse/ACT-1290
-      if (insertedObject instanceof HasRevision) {
-        ((HasRevision) insertedObject).setRevision(((HasRevision) insertedObject).getRevisionNext());
+      bulkInsertHandledMap.get(insertedObject.getClass()).add(insertedObject);
+    }
+    log.info("Insert queries collection formed: " + bulkInsertHandledMap);
+    // First process for entities in order of dependency requirement
+    for (EntityDependencyOrder entityName : EntityDependencyOrder.values()) {
+      if (!bulkInsertHandledMap.containsKey(entityName.getClazz())) {
+        continue;
       }
+      flushBulkInserts(bulkInsertHandledMap.get(entityName.getClazz()), entityName.getClazz());
+      bulkInsertHandledMap.remove(entityName.getClazz());
+    }
+    // Next, process for all remaining entities
+    for (Class<? extends PersistentObject> clazz : bulkInsertHandledMap.keySet()) {
+      flushBulkInserts(bulkInsertHandledMap.get(clazz), clazz);
     }
     insertedObjects.clear();
   }
 
+  private void flushBulkInserts(List<PersistentObject> variableList, Class<? extends PersistentObject> clazz) {
+    String insertStatement = dbSqlSessionFactory.getBulkInsertStatement(clazz);
+    insertStatement = dbSqlSessionFactory.mapStatement(insertStatement);
+    log.info("Insert statement to be executed:" + insertStatement);
+
+    if (insertStatement==null) {
+      throw new ActivitiException("no insert statement for "+variableList.get(0).getClass()+" in the ibatis mapping files");
+    }
+
+    log.info("inserting: {}", variableList);
+    sqlSession.insert(insertStatement, variableList);
+
+    if (variableList.get(0) instanceof HasRevision) {
+      for (PersistentObject insertedObject: variableList) {
+        ((HasRevision) insertedObject).setRevision(((HasRevision) insertedObject).getRevisionNext());
+      }
+    }
+  }
+
   protected void flushUpdates(List<PersistentObject> updatedObjects) {
     for (PersistentObject updatedObject: updatedObjects) {
       String updateStatement = dbSqlSessionFactory.getUpdateStatement(updatedObject);
@@ -861,6 +892,7 @@ protected void flushRegularDeletes(boolean dispatchEvent) {
     }
   }
 
+  @Override
   public void close() {
     sqlSession.close();
   }

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

@@ -40,7 +40,7 @@
   static {
 
     String defaultOrderBy = " order by ${orderBy} ";
-
+    
     // h2
     databaseSpecificLimitBeforeStatements.put("h2", "");
     databaseSpecificLimitAfterStatements.put("h2", "LIMIT #{maxResults} OFFSET #{firstResult}");
@@ -55,6 +55,7 @@
     databaseOuterJoinLimitBetweenStatements.put("hsql", "");
     databaseSpecificOrderByStatements.put("hsql", defaultOrderBy);
 
+
 	  //mysql specific
     databaseSpecificLimitBeforeStatements.put("mysql", "");
     databaseSpecificLimitAfterStatements.put("mysql", "LIMIT #{maxResults} OFFSET #{firstResult}");
@@ -77,17 +78,20 @@
     databaseOuterJoinLimitBetweenStatements.put("postgres", "");
     databaseSpecificOrderByStatements.put("postgres", defaultOrderBy);
     addDatabaseSpecificStatement("postgres", "insertByteArray", "insertByteArray_postgres");
+    addDatabaseSpecificStatement("postgres", "bulkInsertByteArray", "bulkInsertByteArray_postgres");
     addDatabaseSpecificStatement("postgres", "updateByteArray", "updateByteArray_postgres");
     addDatabaseSpecificStatement("postgres", "selectByteArray", "selectByteArray_postgres");
     addDatabaseSpecificStatement("postgres", "selectResourceByDeploymentIdAndResourceName", "selectResourceByDeploymentIdAndResourceName_postgres");
     addDatabaseSpecificStatement("postgres", "selectResourcesByDeploymentId", "selectResourcesByDeploymentId_postgres");
     addDatabaseSpecificStatement("postgres", "insertIdentityInfo", "insertIdentityInfo_postgres");
+    addDatabaseSpecificStatement("postgres", "bulkInsertIdentityInfo", "bulkInsertIdentityInfo_postgres");
     addDatabaseSpecificStatement("postgres", "updateIdentityInfo", "updateIdentityInfo_postgres");
     addDatabaseSpecificStatement("postgres", "selectIdentityInfoById", "selectIdentityInfoById_postgres");
     addDatabaseSpecificStatement("postgres", "selectIdentityInfoByUserIdAndKey", "selectIdentityInfoByUserIdAndKey_postgres");
     addDatabaseSpecificStatement("postgres", "selectIdentityInfoByUserId", "selectIdentityInfoByUserId_postgres");
     addDatabaseSpecificStatement("postgres", "selectIdentityInfoDetails", "selectIdentityInfoDetails_postgres");
     addDatabaseSpecificStatement("postgres", "insertComment", "insertComment_postgres");
+    addDatabaseSpecificStatement("postgres", "bulkInsertComment", "bulkInsertComment_postgres");
     addDatabaseSpecificStatement("postgres", "selectComment", "selectComment_postgres");
     addDatabaseSpecificStatement("postgres", "selectCommentsByTaskId", "selectCommentsByTaskId_postgres");
     addDatabaseSpecificStatement("postgres", "selectCommentsByProcessInstanceId", "selectCommentsByProcessInstanceId_postgres");
@@ -96,6 +100,7 @@
     addDatabaseSpecificStatement("postgres", "selectCommentsByTaskIdAndType", "selectCommentsByTaskIdAndType_postgres");
     addDatabaseSpecificStatement("postgres", "selectEventsByTaskId", "selectEventsByTaskId_postgres");
     addDatabaseSpecificStatement("postgres", "insertEventLogEntry", "insertEventLogEntry_postgres");
+    addDatabaseSpecificStatement("postgres", "bulkInsertEventLogEntry", "bulkInsertEventLogEntry_postgres");
     addDatabaseSpecificStatement("postgres", "selectAllEventLogEntries", "selectAllEventLogEntries_postgres");
     addDatabaseSpecificStatement("postgres", "selectEventLogEntries", "selectEventLogEntries_postgres");
     addDatabaseSpecificStatement("postgres", "selectEventLogEntriesByProcessInstanceId", "selectEventLogEntriesByProcessInstanceId_postgres");
@@ -109,6 +114,42 @@
     addDatabaseSpecificStatement("oracle", "selectExclusiveJobsToExecute", "selectExclusiveJobsToExecute_integerBoolean");
     addDatabaseSpecificStatement("oracle", "selectUnlockedTimersByDuedate", "selectUnlockedTimersByDuedate_oracle");
     addDatabaseSpecificStatement("oracle", "insertEventLogEntry", "insertEventLogEntry_oracle");
+    addDatabaseSpecificStatement("oracle", "bulkInsertVariableInstance", "bulkInsertVariableInstance_oracle");
+    addDatabaseSpecificStatement("oracle", "bulkInsertUser", "bulkInsertUser_oracle");
+    addDatabaseSpecificStatement("oracle", "bulkInsertTask", "bulkInsertTask_oracle");
+    addDatabaseSpecificStatement("oracle", "bulkInsertResource", "bulkInsertResource_oracle");
+    addDatabaseSpecificStatement("oracle", "bulkInsertProperty", "bulkInsertProperty_oracle");
+    addDatabaseSpecificStatement("oracle", "bulkInsertProcessDefinition", "bulkInsertProcessDefinition_oracle");
+    addDatabaseSpecificStatement("oracle", "bulkInsertModel", "bulkInsertModel_oracle");
+    addDatabaseSpecificStatement("oracle", "bulkInsertMembership", "bulkInsertMembership_oracle");
+    addDatabaseSpecificStatement("oracle", "bulkInsertTimer", "bulkInsertTimer_oracle");
+    addDatabaseSpecificStatement("oracle", "bulkInsertMessage", "bulkInsertMessage_oracle");
+    addDatabaseSpecificStatement("oracle", "bulkInsertIdentityInfo", "bulkInsertIdentityInfo_oracle");
+    addDatabaseSpecificStatement("oracle", "bulkInsertIdentityLink", "bulkInsertIdentityLink_oracle");
+    addDatabaseSpecificStatement("oracle", "bulkInsertMembership", "bulkInsertMembership_oracle");
+    addDatabaseSpecificStatement("oracle", "bulkInsertTimer", "bulkInsertTimer_oracle");
+    addDatabaseSpecificStatement("oracle", "bulkInsertMessage", "bulkInsertMessage_oracle");
+    addDatabaseSpecificStatement("oracle", "bulkInsertHistoricVariableInstance", "bulkInsertHistoricVariableInstance_oracle");
+    addDatabaseSpecificStatement("oracle", "bulkInsertHistoricTaskInstance", "bulkInsertHistoricTaskInstance_oracle");
+    addDatabaseSpecificStatement("oracle", "bulkInsertHistoricProcessInstance", "bulkInsertHistoricProcessInstance_oracle");
+    addDatabaseSpecificStatement("oracle", "bulkInsertHistoricIdentityLink", "bulkInsertHistoricIdentityLink_oracle");
+    addDatabaseSpecificStatement("oracle", "bulkInsertHistoricDetailVariableInstanceUpdate", "bulkInsertHistoricDetailVariableInstanceUpdate_oracle");
+    addDatabaseSpecificStatement("oracle", "bulkInsertHistoricFormProperty", "bulkInsertHistoricFormProperty_oracle");
+    addDatabaseSpecificStatement("oracle", "bulkInsertHistoricActivityInstance", "bulkInsertHistoricActivityInstance_oracle");
+    addDatabaseSpecificStatement("oracle", "bulkInsertGroup", "bulkInsertGroup_oracle");
+    addDatabaseSpecificStatement("oracle", "bulkInsertExecution", "bulkInsertExecution_oracle");
+    addDatabaseSpecificStatement("oracle", "bulkInsertMessageEventSubscription", "bulkInsertMessageEventSubscription_oracle");
+    addDatabaseSpecificStatement("oracle", "bulkInsertSignalEventSubscription", "bulkInsertSignalEventSubscription_oracle");
+    addDatabaseSpecificStatement("oracle", "bulkInsertCompensateEventSubscription", "bulkInsertCompensateEventSubscription_oracle");
+    addDatabaseSpecificStatement("oracle", "bulkInsertEventLogEntry", "bulkInsertEventLogEntry_oracle");
+    addDatabaseSpecificStatement("oracle", "bulkInsertDeployment", "bulkInsertDeployment_oracle");
+    addDatabaseSpecificStatement("oracle", "bulkInsertComment", "bulkInsertComment_oracle");
+    addDatabaseSpecificStatement("oracle", "bulkInsertByteArray", "bulkInsertByteArray_oracle");
+    addDatabaseSpecificStatement("oracle", "bulkInsertEventLogEntry", "bulkInsertEventLogEntry_oracle");
+    addDatabaseSpecificStatement("oracle", "bulkInsertDeployment", "bulkInsertDeployment_oracle");
+    addDatabaseSpecificStatement("oracle", "bulkInsertComment", "bulkInsertComment_oracle");
+    addDatabaseSpecificStatement("oracle", "bulkInsertByteArray", "bulkInsertByteArray_oracle");
+    addDatabaseSpecificStatement("oracle", "bulkInsertAttachment", "bulkInsertAttachment_oracle");
 
     // db2
     databaseSpecificLimitBeforeStatements.put("db2", "SELECT SUB.* FROM (");
@@ -177,6 +218,7 @@
   protected IdGenerator idGenerator;
   protected Map<String, String> statementMappings;
   protected Map<Class<?>,String>  insertStatements = new ConcurrentHashMap<Class<?>, String>();
+  protected Map<Class<?>,String>  bulkInsertStatements = new ConcurrentHashMap<Class<?>, String>();
   protected Map<Class<?>,String>  updateStatements = new ConcurrentHashMap<Class<?>, String>();
   protected Map<Class<?>,String>  deleteStatements = new ConcurrentHashMap<Class<?>, String>();
   protected Map<Class<?>,String>  bulkDeleteStatements = new ConcurrentHashMap<Class<?>, String>();
@@ -199,6 +241,10 @@ public Session openSession() {
   public String getInsertStatement(PersistentObject object) {
     return getStatement(object.getClass(), insertStatements, "insert");
   }
+
+  public String getBulkInsertStatement(Class clazz) {
+    return getStatement(clazz, bulkInsertStatements, "bulkInsert");
+  }
 
   public String getUpdateStatement(PersistentObject object) {
     return getStatement(object.getClass(), updateStatements, "update");
@@ -297,6 +343,16 @@ public void setInsertStatements(Map<Class< ? >, String> insertStatements) {
   }
 
 
+  public Map<Class< ? >, String> getBulkInsertStatements() {
+    return bulkInsertStatements;
+  }
+
+
+  public void setBulkInsertStatements(Map<Class< ? >, String> bulkInsertStatements) {
+    this.bulkInsertStatements = bulkInsertStatements;
+  }
+
+
   public Map<Class< ? >, String> getUpdateStatements() {
     return updateStatements;
   }

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

@@ -0,0 +1,47 @@
+package org.activiti.engine.impl.db;
+
+import org.activiti.engine.impl.persistence.entity.ByteArrayEntity;
+import org.activiti.engine.impl.persistence.entity.DeploymentEntity;
+import org.activiti.engine.impl.persistence.entity.EventSubscriptionEntity;
+import org.activiti.engine.impl.persistence.entity.ExecutionEntity;
+import org.activiti.engine.impl.persistence.entity.GroupEntity;
+import org.activiti.engine.impl.persistence.entity.IdentityLinkEntity;
+import org.activiti.engine.impl.persistence.entity.JobEntity;
+import org.activiti.engine.impl.persistence.entity.MembershipEntity;
+import org.activiti.engine.impl.persistence.entity.ModelEntity;
+import org.activiti.engine.impl.persistence.entity.ProcessDefinitionEntity;
+import org.activiti.engine.impl.persistence.entity.TaskEntity;
+import org.activiti.engine.impl.persistence.entity.UserEntity;
+import org.activiti.engine.impl.persistence.entity.VariableInstanceEntity;
+
+/**
+ * Maintains a list of all the entities in order of dependency.
+ * For eg. If ByteArray.java will appear before VariableInstance.java,
+ *      since VariableInstance has ByteArray.id as FK
+ */
+public enum EntityDependencyOrder {
+  DeploymentEntity(DeploymentEntity.class),
+  ByteArrayEntity(ByteArrayEntity.class),
+  ModelEntity(ModelEntity.class),
+  UserEntity(UserEntity.class),
+  GroupEntity(GroupEntity.class),
+  MembershipEntity(MembershipEntity.class),
+  ProcessDefinitionEntity(ProcessDefinitionEntity.class),
+  ExecutionEntity(ExecutionEntity.class),
+  EventSubscriptionEntity(EventSubscriptionEntity.class),
+  TaskEntity(TaskEntity.class),
+  IdentityLinkEntity(IdentityLinkEntity.class),
+  JobEntity(JobEntity.class),
+  VariableInstanceEntity(VariableInstanceEntity.class);
+
+  private Class<? extends PersistentObject> clazz;
+
+  private EntityDependencyOrder(Class<? extends PersistentObject> clazz) {
+    this.clazz = clazz;
+  }
+
+  public Class<? extends PersistentObject> getClazz() {
+    return clazz;
+  }
+
+}

modules/activiti-engine/src/main/java/org/activiti/engine/impl/persistence/entity/AttachmentEntity.java

@@ -43,6 +43,9 @@
   protected String userId;
   protected Date time;
 
+  public AttachmentEntity() {
+  }
+
   public Object getPersistentState() {
     Map<String, Object> persistentState = new HashMap<String, Object>();
     persistentState.put("name", name);

modules/activiti-engine/src/main/java/org/activiti/engine/impl/persistence/entity/CompensateEventSubscriptionEntity.java

@@ -24,17 +24,17 @@
 public class CompensateEventSubscriptionEntity extends EventSubscriptionEntity {
 
   private static final long serialVersionUID = 1L;
-  
+
   private CompensateEventSubscriptionEntity() {
   }
 
   private CompensateEventSubscriptionEntity(ExecutionEntity executionEntity) {
     super(executionEntity);
-    eventType=CompensationEventHandler.EVENT_HANDLER_TYPE;    
+    eventType=CompensationEventHandler.EVENT_HANDLER_TYPE;
   }
 
   public static CompensateEventSubscriptionEntity createAndInsert(ExecutionEntity executionEntity) {
-    CompensateEventSubscriptionEntity eventSubscription = new CompensateEventSubscriptionEntity(executionEntity);    
+    CompensateEventSubscriptionEntity eventSubscription = new CompensateEventSubscriptionEntity(executionEntity);
     if (executionEntity.getTenantId() != null) {
     	eventSubscription.setTenantId(executionEntity.getTenantId());
     }

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

@@ -251,14 +251,14 @@
   protected boolean forcedUpdate;
 
   protected List<VariableInstanceEntity> queryVariables;
-
-  public ExecutionEntity() {
-  }
 
   public ExecutionEntity(ActivityImpl activityImpl) {
     this.startingExecution = new StartingExecution(activityImpl);
   }
 
+  public ExecutionEntity() {
+  }
+
   /** creates a new execution. properties processDefinition, processInstance and activity will be initialized. */  
   public ExecutionEntity createExecution() {
     // create the new child execution

modules/activiti-engine/src/main/java/org/activiti/engine/impl/persistence/entity/HistoricDetailEntity.java

@@ -35,6 +35,7 @@
   protected String taskId;
   protected String executionId;
   protected Date time;
+  protected String detailType;
 
   public Object getPersistentState() {
     // details are not updatable so we always provide the same object as the state
@@ -92,4 +93,11 @@ public Date getTime() {
   public void setTime(Date time) {
     this.time = time;
   }
+
+  public String getDetailType() {
+    return detailType;
+  }
+  public void setDetailType(String detailType) {
+    this.detailType = detailType;
+  }
 }

modules/activiti-engine/src/main/java/org/activiti/engine/impl/persistence/entity/HistoricDetailVariableInstanceUpdateEntity.java

@@ -42,6 +42,7 @@
   protected Object cachedValue;
 
   protected HistoricDetailVariableInstanceUpdateEntity() {
+    this.detailType = "VariableUpdate";
   }
 
   public static HistoricDetailVariableInstanceUpdateEntity copyAndInsert(VariableInstanceEntity variableInstance) {

modules/activiti-engine/src/main/java/org/activiti/engine/impl/persistence/entity/HistoricFormPropertyEntity.java

@@ -27,6 +27,7 @@
   protected String propertyValue;
 
   public HistoricFormPropertyEntity() {
+    this.detailType = "FormProperty";
   }
 
   public HistoricFormPropertyEntity(ExecutionEntity execution, String propertyId, String propertyValue) {
@@ -40,6 +41,7 @@ public HistoricFormPropertyEntity(ExecutionEntity execution, String propertyId,
     this.propertyId = propertyId;
     this.propertyValue = propertyValue;
     this.time = Context.getProcessEngineConfiguration().getClock().getCurrentTime();
+    this.detailType = "FormProperty";
 
     HistoricActivityInstanceEntity historicActivityInstance = Context.getCommandContext().getHistoryManager().findActivityInstance(execution);
     if (historicActivityInstance!=null) {