package org.activiti.engine.impl.db;
|
|
import org.activiti.engine.ActivitiException;
|
import org.activiti.engine.ActivitiOptimisticLockingException;
|
import org.activiti.engine.ActivitiWrongDbException;
|
import org.activiti.engine.impl.*;
|
import org.activiti.engine.impl.cfg.ProcessEngineConfigurationImpl;
|
import org.activiti.engine.impl.context.Context;
|
import org.activiti.engine.impl.db.upgrade.DbUpgradeStep;
|
import org.activiti.engine.impl.interceptor.Session;
|
import org.activiti.engine.impl.persistence.cache.CachedEntity;
|
import org.activiti.engine.impl.persistence.cache.EntityCache;
|
import org.activiti.engine.impl.persistence.entity.Entity;
|
import org.activiti.engine.impl.persistence.entity.ExecutionEntity;
|
import org.activiti.engine.impl.persistence.entity.PropertyEntity;
|
import org.activiti.engine.impl.util.IoUtil;
|
import org.activiti.engine.impl.util.ReflectUtil;
|
import org.apache.ibatis.session.SqlSession;
|
import org.slf4j.Logger;
|
import org.slf4j.LoggerFactory;
|
|
import java.io.BufferedReader;
|
import java.io.IOException;
|
import java.io.InputStream;
|
import java.io.StringReader;
|
import java.sql.Connection;
|
import java.sql.DatabaseMetaData;
|
import java.sql.ResultSet;
|
import java.sql.Statement;
|
import java.util.*;
|
import java.util.regex.Matcher;
|
import java.util.regex.Pattern;
|
|
public class DbSqlSession implements Session {
|
private static final Logger log = LoggerFactory.getLogger(DbSqlSession.class);
|
protected static final Pattern CLEAN_VERSION_REGEX = Pattern.compile("\\d\\.\\d*");
|
protected static final String LAST_V5_VERSION = "5.99.0.0";
|
protected static final List<ActivitiVersion> ACTIVITI_VERSIONS = new ArrayList();
|
protected SqlSession sqlSession;
|
protected DbSqlSessionFactory dbSqlSessionFactory;
|
protected EntityCache entityCache;
|
protected Map<Class<? extends Entity>, Map<String, Entity>> insertedObjects = new HashMap();
|
protected Map<Class<? extends Entity>, Map<String, Entity>> deletedObjects = new HashMap();
|
protected Map<Class<? extends Entity>, List<BulkDeleteOperation>> bulkDeleteOperations = new HashMap();
|
protected List<Entity> updatedObjects = new ArrayList();
|
protected String connectionMetadataDefaultCatalog;
|
protected String connectionMetadataDefaultSchema;
|
public static String[] JDBC_METADATA_TABLE_TYPES;
|
|
public DbSqlSession(DbSqlSessionFactory dbSqlSessionFactory, EntityCache entityCache) {
|
this.dbSqlSessionFactory = dbSqlSessionFactory;
|
this.sqlSession = dbSqlSessionFactory.getSqlSessionFactory().openSession();
|
this.entityCache = entityCache;
|
this.connectionMetadataDefaultCatalog = dbSqlSessionFactory.getDatabaseCatalog();
|
this.connectionMetadataDefaultSchema = dbSqlSessionFactory.getDatabaseSchema();
|
}
|
|
public DbSqlSession(DbSqlSessionFactory dbSqlSessionFactory, EntityCache entityCache, Connection connection, String catalog, String schema) {
|
this.dbSqlSessionFactory = dbSqlSessionFactory;
|
this.sqlSession = dbSqlSessionFactory.getSqlSessionFactory().openSession(connection);
|
this.entityCache = entityCache;
|
this.connectionMetadataDefaultCatalog = catalog;
|
this.connectionMetadataDefaultSchema = schema;
|
}
|
|
public void insert(Entity entity) {
|
if (entity.getId() == null) {
|
String id = this.dbSqlSessionFactory.getIdGenerator().getNextId();
|
entity.setId(id);
|
}
|
|
Class<? extends Entity> clazz = entity.getClass();
|
if (!this.insertedObjects.containsKey(clazz)) {
|
this.insertedObjects.put(clazz, new LinkedHashMap());
|
}
|
|
((Map)this.insertedObjects.get(clazz)).put(entity.getId(), entity);
|
this.entityCache.put(entity, false);
|
entity.setInserted(true);
|
}
|
|
public void update(Entity entity) {
|
this.entityCache.put(entity, false);
|
entity.setUpdated(true);
|
}
|
|
public int update(String statement, Object parameters) {
|
String updateStatement = this.dbSqlSessionFactory.mapStatement(statement);
|
return this.getSqlSession().update(updateStatement, parameters);
|
}
|
|
public void delete(String statement, Object parameter, Class<? extends Entity> entityClass) {
|
if (!this.bulkDeleteOperations.containsKey(entityClass)) {
|
this.bulkDeleteOperations.put(entityClass, new ArrayList(1));
|
}
|
|
((List)this.bulkDeleteOperations.get(entityClass)).add(new BulkDeleteOperation(this.dbSqlSessionFactory.mapStatement(statement), parameter));
|
}
|
|
public void delete(Entity entity) {
|
Class<? extends Entity> clazz = entity.getClass();
|
if (!this.deletedObjects.containsKey(clazz)) {
|
this.deletedObjects.put(clazz, new LinkedHashMap());
|
}
|
|
((Map)this.deletedObjects.get(clazz)).put(entity.getId(), entity);
|
entity.setDeleted(true);
|
}
|
|
public List selectList(String statement) {
|
return this.selectList(statement, (Object)null, 0, Integer.MAX_VALUE);
|
}
|
|
public List selectList(String statement, Object parameter) {
|
return this.selectList(statement, parameter, 0, Integer.MAX_VALUE);
|
}
|
|
public List selectList(String statement, Object parameter, boolean useCache) {
|
return this.selectList(statement, parameter, 0, Integer.MAX_VALUE, useCache);
|
}
|
|
public List selectList(String statement, Object parameter, Page page) {
|
return this.selectList(statement, parameter, page, true);
|
}
|
|
public List selectList(String statement, Object parameter, Page page, boolean useCache) {
|
return page != null ? this.selectList(statement, parameter, page.getFirstResult(), page.getMaxResults(), useCache) : this.selectList(statement, parameter, 0, Integer.MAX_VALUE, useCache);
|
}
|
|
public List selectList(String statement, ListQueryParameterObject parameter, Page page) {
|
return this.selectList(statement, parameter, page, true);
|
}
|
|
public List selectList(String statement, ListQueryParameterObject parameter, Page page, boolean useCache) {
|
ListQueryParameterObject parameterToUse = parameter;
|
if (parameterToUse == null) {
|
parameterToUse = new ListQueryParameterObject();
|
}
|
|
if (page != null) {
|
parameterToUse.setFirstResult(page.getFirstResult());
|
parameterToUse.setMaxResults(page.getMaxResults());
|
}
|
|
return this.selectList(statement, parameterToUse, useCache);
|
}
|
|
public List selectList(String statement, Object parameter, int firstResult, int maxResults) {
|
return this.selectList(statement, parameter, firstResult, maxResults, true);
|
}
|
|
public List selectList(String statement, Object parameter, int firstResult, int maxResults, boolean useCache) {
|
return this.selectList(statement, new ListQueryParameterObject(parameter, firstResult, maxResults), useCache);
|
}
|
|
public List selectList(String statement, ListQueryParameterObject parameter) {
|
return this.selectList(statement, parameter, true);
|
}
|
|
public List selectList(String statement, ListQueryParameterObject parameter, boolean useCache) {
|
return this.selectListWithRawParameter(statement, parameter, parameter.getFirstResult(), parameter.getMaxResults(), useCache);
|
}
|
|
public List selectListWithRawParameter(String statement, Object parameter, int firstResult, int maxResults) {
|
return this.selectListWithRawParameter(statement, parameter, firstResult, maxResults, true);
|
}
|
|
public List selectListWithRawParameter(String statement, Object parameter, int firstResult, int maxResults, boolean useCache) {
|
statement = this.dbSqlSessionFactory.mapStatement(statement);
|
if (firstResult != -1 && maxResults != -1) {
|
List loadedObjects = this.sqlSession.selectList(statement, parameter);
|
return useCache ? this.cacheLoadOrStore(loadedObjects) : loadedObjects;
|
} else {
|
return Collections.EMPTY_LIST;
|
}
|
}
|
|
public List selectListWithRawParameterWithoutFilter(String statement, Object parameter, int firstResult, int maxResults) {
|
statement = this.dbSqlSessionFactory.mapStatement(statement);
|
return firstResult != -1 && maxResults != -1 ? this.sqlSession.selectList(statement, parameter) : Collections.EMPTY_LIST;
|
}
|
|
public Object selectOne(String statement, Object parameter) {
|
statement = this.dbSqlSessionFactory.mapStatement(statement);
|
Object result = this.sqlSession.selectOne(statement, parameter);
|
if (result instanceof Entity) {
|
Entity loadedObject = (Entity)result;
|
result = this.cacheLoadOrStore(loadedObject);
|
}
|
|
return result;
|
}
|
|
public <T extends Entity> T selectById(Class<T> entityClass, String id) {
|
return this.selectById(entityClass, id, true);
|
}
|
|
public <T extends Entity> T selectById(Class<T> entityClass, String id, boolean useCache) {
|
T entity = null;
|
if (useCache) {
|
entity = (T) this.entityCache.findInCache(entityClass, id);
|
if (entity != null) {
|
return entity;
|
}
|
}
|
|
String selectStatement = this.dbSqlSessionFactory.getSelectStatement(entityClass);
|
selectStatement = this.dbSqlSessionFactory.mapStatement(selectStatement);
|
entity = (T) this.sqlSession.selectOne(selectStatement, id);
|
if (entity == null) {
|
return null;
|
} else {
|
this.entityCache.put(entity, true);
|
return entity;
|
}
|
}
|
|
protected List cacheLoadOrStore(List<Object> loadedObjects) {
|
if (loadedObjects.isEmpty()) {
|
return loadedObjects;
|
} else if (!(loadedObjects.get(0) instanceof Entity)) {
|
return loadedObjects;
|
} else {
|
List<Entity> filteredObjects = new ArrayList(loadedObjects.size());
|
Iterator var3 = loadedObjects.iterator();
|
|
while(var3.hasNext()) {
|
Object loadedObject = var3.next();
|
Entity cachedEntity = this.cacheLoadOrStore((Entity)loadedObject);
|
filteredObjects.add(cachedEntity);
|
}
|
|
return filteredObjects;
|
}
|
}
|
|
protected Entity cacheLoadOrStore(Entity entity) {
|
Entity cachedEntity = (Entity)this.entityCache.findInCache(entity.getClass(), entity.getId());
|
if (cachedEntity != null) {
|
return cachedEntity;
|
} else {
|
this.entityCache.put(entity, true);
|
return entity;
|
}
|
}
|
|
public void flush() {
|
this.determineUpdatedObjects();
|
this.removeUnnecessaryOperations();
|
if (log.isDebugEnabled()) {
|
this.debugFlush();
|
}
|
|
this.flushInserts();
|
this.flushUpdates();
|
this.flushDeletes();
|
}
|
|
protected void removeUnnecessaryOperations() {
|
Iterator var1 = this.deletedObjects.keySet().iterator();
|
|
while(var1.hasNext()) {
|
Class<? extends Entity> entityClass = (Class)var1.next();
|
Set<String> ids = new HashSet();
|
Iterator<Entity> entitiesToDeleteIterator = ((Map)this.deletedObjects.get(entityClass)).values().iterator();
|
|
while(entitiesToDeleteIterator.hasNext()) {
|
Entity entityToDelete = (Entity)entitiesToDeleteIterator.next();
|
if (!ids.contains(entityToDelete.getId())) {
|
ids.add(entityToDelete.getId());
|
} else {
|
entitiesToDeleteIterator.remove();
|
}
|
}
|
|
Iterator var7 = ids.iterator();
|
|
while(var7.hasNext()) {
|
String id = (String)var7.next();
|
if (this.insertedObjects.containsKey(entityClass) && ((Map)this.insertedObjects.get(entityClass)).containsKey(id)) {
|
((Map)this.insertedObjects.get(entityClass)).remove(id);
|
((Map)this.deletedObjects.get(entityClass)).remove(id);
|
}
|
}
|
}
|
|
}
|
|
public void determineUpdatedObjects() {
|
this.updatedObjects = new ArrayList();
|
Map<Class<?>, Map<String, CachedEntity>> cachedObjects = this.entityCache.getAllCachedEntities();
|
Iterator var2 = cachedObjects.keySet().iterator();
|
|
label34:
|
while(var2.hasNext()) {
|
Class<?> clazz = (Class)var2.next();
|
Map<String, CachedEntity> classCache = (Map)cachedObjects.get(clazz);
|
Iterator var5 = classCache.values().iterator();
|
|
while(true) {
|
CachedEntity cachedObject;
|
Entity cachedEntity;
|
do {
|
do {
|
if (!var5.hasNext()) {
|
continue label34;
|
}
|
|
cachedObject = (CachedEntity)var5.next();
|
cachedEntity = cachedObject.getEntity();
|
} while(this.isEntityInserted(cachedEntity));
|
} while(!ExecutionEntity.class.isAssignableFrom(cachedEntity.getClass()) && this.isEntityToBeDeleted(cachedEntity));
|
|
if (cachedObject.hasChanged()) {
|
this.updatedObjects.add(cachedEntity);
|
}
|
}
|
}
|
|
}
|
|
protected void debugFlush() {
|
log.debug("Flushing dbSqlSession");
|
int nrOfInserts = 0;
|
int nrOfUpdates = 0;
|
int nrOfDeletes = 0;
|
Iterator var4 = this.insertedObjects.values().iterator();
|
|
Map deletedObjectMap;
|
Iterator var6;
|
Entity deletedObject;
|
while(var4.hasNext()) {
|
deletedObjectMap = (Map)var4.next();
|
|
for(var6 = deletedObjectMap.values().iterator(); var6.hasNext(); ++nrOfInserts) {
|
deletedObject = (Entity)var6.next();
|
log.debug(" insert {}", deletedObject);
|
}
|
}
|
|
for(var4 = this.updatedObjects.iterator(); var4.hasNext(); ++nrOfUpdates) {
|
Entity updatedObject = (Entity)var4.next();
|
log.debug(" update {}", updatedObject);
|
}
|
|
var4 = this.deletedObjects.values().iterator();
|
|
while(var4.hasNext()) {
|
deletedObjectMap = (Map)var4.next();
|
|
for(var6 = deletedObjectMap.values().iterator(); var6.hasNext(); ++nrOfDeletes) {
|
deletedObject = (Entity)var6.next();
|
log.debug(" delete {} with id {}", deletedObject, deletedObject.getId());
|
}
|
}
|
|
var4 = this.bulkDeleteOperations.values().iterator();
|
|
while(var4.hasNext()) {
|
Collection<BulkDeleteOperation> bulkDeleteOperationList = (Collection)var4.next();
|
|
for(var6 = bulkDeleteOperationList.iterator(); var6.hasNext(); ++nrOfDeletes) {
|
BulkDeleteOperation bulkDeleteOperation = (BulkDeleteOperation)var6.next();
|
log.debug(" {}", bulkDeleteOperation);
|
}
|
}
|
|
log.debug("flush summary: {} insert, {} update, {} delete.", new Object[]{nrOfInserts, nrOfUpdates, nrOfDeletes});
|
log.debug("now executing flush...");
|
}
|
|
public boolean isEntityInserted(Entity entity) {
|
return this.insertedObjects.containsKey(entity.getClass()) && ((Map)this.insertedObjects.get(entity.getClass())).containsKey(entity.getId());
|
}
|
|
public boolean isEntityToBeDeleted(Entity entity) {
|
return this.deletedObjects.containsKey(entity.getClass()) && ((Map)this.deletedObjects.get(entity.getClass())).containsKey(entity.getId());
|
}
|
|
protected void flushInserts() {
|
if (this.insertedObjects.size() != 0) {
|
Iterator var1 = EntityDependencyOrder.INSERT_ORDER.iterator();
|
|
Class entityClass;
|
while(var1.hasNext()) {
|
entityClass = (Class)var1.next();
|
if (this.insertedObjects.containsKey(entityClass)) {
|
this.flushInsertEntities(entityClass, ((Map)this.insertedObjects.get(entityClass)).values());
|
this.insertedObjects.remove(entityClass);
|
}
|
}
|
|
if (this.insertedObjects.size() > 0) {
|
var1 = this.insertedObjects.keySet().iterator();
|
|
while(var1.hasNext()) {
|
entityClass = (Class)var1.next();
|
this.flushInsertEntities(entityClass, ((Map)this.insertedObjects.get(entityClass)).values());
|
}
|
}
|
|
this.insertedObjects.clear();
|
}
|
}
|
|
protected void flushInsertEntities(Class<? extends Entity> entityClass, Collection<Entity> entitiesToInsert) {
|
if (entitiesToInsert.size() == 1) {
|
this.flushRegularInsert((Entity)entitiesToInsert.iterator().next(), entityClass);
|
} else if (Boolean.FALSE.equals(this.dbSqlSessionFactory.isBulkInsertable(entityClass))) {
|
Iterator var3 = entitiesToInsert.iterator();
|
|
while(var3.hasNext()) {
|
Entity entity = (Entity)var3.next();
|
this.flushRegularInsert(entity, entityClass);
|
}
|
} else {
|
this.flushBulkInsert(entitiesToInsert, entityClass);
|
}
|
|
}
|
|
protected Collection<Entity> orderExecutionEntities(Map<String, Entity> executionEntities, boolean parentBeforeChildExecution) {
|
List<Entity> result = new ArrayList(executionEntities.size());
|
Map<String, String> childToParentExecutionMapping = new HashMap();
|
Map<String, List<ExecutionEntity>> parentToChildrenMapping = new HashMap();
|
Collection<Entity> executionCollection = executionEntities.values();
|
|
Iterator executionIterator;
|
ExecutionEntity currentExecutionEntity;
|
String executionId;
|
String parentId;
|
for(executionIterator = executionCollection.iterator(); executionIterator.hasNext(); ((List)parentToChildrenMapping.get(parentId)).add(currentExecutionEntity)) {
|
currentExecutionEntity = (ExecutionEntity)executionIterator.next();
|
parentId = currentExecutionEntity.getParentId();
|
executionId = currentExecutionEntity.getSuperExecutionId();
|
parentId = parentId != null ? parentId : executionId;
|
childToParentExecutionMapping.put(currentExecutionEntity.getId(), parentId);
|
if (!parentToChildrenMapping.containsKey(parentId)) {
|
parentToChildrenMapping.put(parentId, new ArrayList());
|
}
|
}
|
|
Set<String> handledExecutionIds = new HashSet(executionEntities.size());
|
executionIterator = executionCollection.iterator();
|
|
while(true) {
|
do {
|
if (!executionIterator.hasNext()) {
|
return result;
|
}
|
|
currentExecutionEntity = (ExecutionEntity)executionIterator.next();
|
executionId = currentExecutionEntity.getId();
|
} while(handledExecutionIds.contains(executionId));
|
|
parentId = (String)childToParentExecutionMapping.get(executionId);
|
if (parentId != null) {
|
while(parentId != null) {
|
String newParentId = (String)childToParentExecutionMapping.get(parentId);
|
if (newParentId == null) {
|
break;
|
}
|
|
parentId = newParentId;
|
}
|
}
|
|
if (parentId == null) {
|
parentId = executionId;
|
}
|
|
if (executionEntities.containsKey(parentId) && !handledExecutionIds.contains(parentId)) {
|
handledExecutionIds.add(parentId);
|
if (parentBeforeChildExecution) {
|
result.add(executionEntities.get(parentId));
|
} else {
|
result.add(0, executionEntities.get(parentId));
|
}
|
}
|
|
this.collectChildExecutionsForInsertion(result, parentToChildrenMapping, handledExecutionIds, parentId, parentBeforeChildExecution);
|
}
|
}
|
|
protected void collectChildExecutionsForInsertion(List<Entity> result, Map<String, List<ExecutionEntity>> parentToChildrenMapping, Set<String> handledExecutionIds, String parentId, boolean parentBeforeChildExecution) {
|
List<ExecutionEntity> childExecutionEntities = (List)parentToChildrenMapping.get(parentId);
|
if (childExecutionEntities != null) {
|
ExecutionEntity childExecutionEntity;
|
for(Iterator var7 = childExecutionEntities.iterator(); var7.hasNext(); this.collectChildExecutionsForInsertion(result, parentToChildrenMapping, handledExecutionIds, childExecutionEntity.getId(), parentBeforeChildExecution)) {
|
childExecutionEntity = (ExecutionEntity)var7.next();
|
handledExecutionIds.add(childExecutionEntity.getId());
|
if (parentBeforeChildExecution) {
|
result.add(childExecutionEntity);
|
} else {
|
result.add(0, childExecutionEntity);
|
}
|
}
|
|
}
|
}
|
|
protected void flushRegularInsert(Entity entity, Class<? extends Entity> clazz) {
|
String insertStatement = this.dbSqlSessionFactory.getInsertStatement(entity);
|
insertStatement = this.dbSqlSessionFactory.mapStatement(insertStatement);
|
if (insertStatement == null) {
|
throw new ActivitiException("no insert statement for " + entity.getClass() + " in the ibatis mapping files");
|
} else {
|
log.debug("inserting: {}", entity);
|
this.sqlSession.insert(insertStatement, entity);
|
if (entity instanceof HasRevision) {
|
this.incrementRevision(entity);
|
}
|
|
}
|
}
|
|
protected void flushBulkInsert(Collection<Entity> entities, Class<? extends Entity> clazz) {
|
String insertStatement = this.dbSqlSessionFactory.getBulkInsertStatement(clazz);
|
insertStatement = this.dbSqlSessionFactory.mapStatement(insertStatement);
|
if (insertStatement == null) {
|
throw new ActivitiException("no insert statement for " + ((Entity)entities.iterator().next()).getClass() + " in the ibatis mapping files");
|
} else {
|
Iterator<Entity> entityIterator = entities.iterator();
|
Boolean hasRevision = null;
|
|
while(entityIterator.hasNext()) {
|
List<Entity> subList = new ArrayList();
|
|
for(int index = 0; entityIterator.hasNext() && index < this.dbSqlSessionFactory.getMaxNrOfStatementsInBulkInsert(); ++index) {
|
Entity entity = (Entity)entityIterator.next();
|
subList.add(entity);
|
if (hasRevision == null) {
|
hasRevision = entity instanceof HasRevision;
|
}
|
}
|
|
this.sqlSession.insert(insertStatement, subList);
|
}
|
|
if (hasRevision != null && hasRevision) {
|
entityIterator = entities.iterator();
|
|
while(entityIterator.hasNext()) {
|
this.incrementRevision((Entity)entityIterator.next());
|
}
|
}
|
|
}
|
}
|
|
protected void incrementRevision(Entity insertedObject) {
|
HasRevision revisionEntity = (HasRevision)insertedObject;
|
if (revisionEntity.getRevision() == 0) {
|
revisionEntity.setRevision(revisionEntity.getRevisionNext());
|
}
|
|
}
|
|
protected void flushUpdates() {
|
Iterator var1 = this.updatedObjects.iterator();
|
|
while(var1.hasNext()) {
|
Entity updatedObject = (Entity)var1.next();
|
String updateStatement = this.dbSqlSessionFactory.getUpdateStatement(updatedObject);
|
updateStatement = this.dbSqlSessionFactory.mapStatement(updateStatement);
|
if (updateStatement == null) {
|
throw new ActivitiException("no update statement for " + updatedObject.getClass() + " in the ibatis mapping files");
|
}
|
|
log.debug("updating: {}", updatedObject);
|
int updatedRecords = this.sqlSession.update(updateStatement, updatedObject);
|
if (updatedRecords == 0) {
|
throw new ActivitiOptimisticLockingException(updatedObject + " was updated by another transaction concurrently");
|
}
|
|
if (updatedObject instanceof HasRevision) {
|
((HasRevision)updatedObject).setRevision(((HasRevision)updatedObject).getRevisionNext());
|
}
|
}
|
|
this.updatedObjects.clear();
|
}
|
|
protected void flushDeletes() {
|
if (this.deletedObjects.size() != 0 || this.bulkDeleteOperations.size() != 0) {
|
Iterator var1;
|
Class entityClass;
|
for(var1 = EntityDependencyOrder.DELETE_ORDER.iterator(); var1.hasNext(); this.flushBulkDeletes(entityClass)) {
|
entityClass = (Class)var1.next();
|
if (this.deletedObjects.containsKey(entityClass)) {
|
this.flushDeleteEntities(entityClass, ((Map)this.deletedObjects.get(entityClass)).values());
|
this.deletedObjects.remove(entityClass);
|
}
|
}
|
|
if (this.deletedObjects.size() > 0) {
|
var1 = this.deletedObjects.keySet().iterator();
|
|
while(var1.hasNext()) {
|
entityClass = (Class)var1.next();
|
this.flushDeleteEntities(entityClass, ((Map)this.deletedObjects.get(entityClass)).values());
|
this.flushBulkDeletes(entityClass);
|
}
|
}
|
|
this.deletedObjects.clear();
|
}
|
}
|
|
protected void flushBulkDeletes(Class<? extends Entity> entityClass) {
|
if (this.bulkDeleteOperations.containsKey(entityClass)) {
|
Iterator var2 = ((List)this.bulkDeleteOperations.get(entityClass)).iterator();
|
|
while(var2.hasNext()) {
|
BulkDeleteOperation bulkDeleteOperation = (BulkDeleteOperation)var2.next();
|
bulkDeleteOperation.execute(this.sqlSession);
|
}
|
}
|
|
}
|
|
protected void flushDeleteEntities(Class<? extends Entity> entityClass, Collection<Entity> entitiesToDelete) {
|
Iterator var3 = entitiesToDelete.iterator();
|
|
while(var3.hasNext()) {
|
Entity entity = (Entity)var3.next();
|
String deleteStatement = this.dbSqlSessionFactory.getDeleteStatement(entity.getClass());
|
deleteStatement = this.dbSqlSessionFactory.mapStatement(deleteStatement);
|
if (deleteStatement == null) {
|
throw new ActivitiException("no delete statement for " + entity.getClass() + " in the ibatis mapping files");
|
}
|
|
if (entity instanceof HasRevision) {
|
int nrOfRowsDeleted = this.sqlSession.delete(deleteStatement, entity);
|
if (nrOfRowsDeleted == 0) {
|
throw new ActivitiOptimisticLockingException(entity + " was updated by another transaction concurrently");
|
}
|
} else {
|
this.sqlSession.delete(deleteStatement, entity);
|
}
|
}
|
|
}
|
|
public void close() {
|
this.sqlSession.close();
|
}
|
|
public void commit() {
|
this.sqlSession.commit();
|
}
|
|
public void rollback() {
|
this.sqlSession.rollback();
|
}
|
|
public void dbSchemaCheckVersion() {
|
try {
|
String dbVersion = this.getDbVersion();
|
if (!"6.0.0.4".equals(dbVersion)) {
|
throw new ActivitiWrongDbException("6.0.0.4", dbVersion);
|
}
|
|
String errorMessage = null;
|
if (!this.isEngineTablePresent()) {
|
errorMessage = this.addMissingComponent(errorMessage, "engine");
|
}
|
|
if (this.dbSqlSessionFactory.isDbHistoryUsed() && !this.isHistoryTablePresent()) {
|
errorMessage = this.addMissingComponent(errorMessage, "history");
|
}
|
|
if (this.dbSqlSessionFactory.isDbIdentityUsed() && !this.isIdentityTablePresent()) {
|
errorMessage = this.addMissingComponent(errorMessage, "identity");
|
}
|
|
if (errorMessage != null) {
|
throw new ActivitiException("Activiti database problem: " + errorMessage);
|
}
|
} catch (Exception var3) {
|
Exception e = var3;
|
if (this.isMissingTablesException(e)) {
|
throw new ActivitiException("no activiti tables in db. set <property name=\"databaseSchemaUpdate\" to value=\"true\" or value=\"create-drop\" (use create-drop for testing only!) in bean processEngineConfiguration in activiti.cfg.xml for automatic schema creation", e);
|
}
|
|
if (e instanceof RuntimeException) {
|
throw (RuntimeException)e;
|
}
|
|
throw new ActivitiException("couldn't get db schema version", e);
|
}
|
|
log.debug("activiti db schema check successful");
|
}
|
|
protected String addMissingComponent(String missingComponents, String component) {
|
return missingComponents == null ? "Tables missing for component(s) " + component : missingComponents + ", " + component;
|
}
|
|
protected String getDbVersion() {
|
String selectSchemaVersionStatement = this.dbSqlSessionFactory.mapStatement("selectDbSchemaVersion");
|
return (String)this.sqlSession.selectOne(selectSchemaVersionStatement);
|
}
|
|
public void dbSchemaCreate() {
|
if (this.isEngineTablePresent()) {
|
String dbVersion = this.getDbVersion();
|
if (!"6.0.0.4".equals(dbVersion)) {
|
throw new ActivitiWrongDbException("6.0.0.4", dbVersion);
|
}
|
} else {
|
this.dbSchemaCreateEngine();
|
}
|
|
if (this.dbSqlSessionFactory.isDbHistoryUsed()) {
|
this.dbSchemaCreateHistory();
|
}
|
|
if (this.dbSqlSessionFactory.isDbIdentityUsed()) {
|
this.dbSchemaCreateIdentity();
|
}
|
|
}
|
|
protected void dbSchemaCreateIdentity() {
|
this.executeMandatorySchemaResource("create", "identity");
|
}
|
|
protected void dbSchemaCreateHistory() {
|
this.executeMandatorySchemaResource("create", "history");
|
}
|
|
protected void dbSchemaCreateEngine() {
|
this.executeMandatorySchemaResource("create", "engine");
|
}
|
|
public void dbSchemaDrop() {
|
this.executeMandatorySchemaResource("drop", "engine");
|
if (this.dbSqlSessionFactory.isDbHistoryUsed()) {
|
this.executeMandatorySchemaResource("drop", "history");
|
}
|
|
if (this.dbSqlSessionFactory.isDbIdentityUsed()) {
|
this.executeMandatorySchemaResource("drop", "identity");
|
}
|
|
}
|
|
public void dbSchemaPrune() {
|
if (this.isHistoryTablePresent() && !this.dbSqlSessionFactory.isDbHistoryUsed()) {
|
this.executeMandatorySchemaResource("drop", "history");
|
}
|
|
if (this.isIdentityTablePresent() && this.dbSqlSessionFactory.isDbIdentityUsed()) {
|
this.executeMandatorySchemaResource("drop", "identity");
|
}
|
|
}
|
|
public void executeMandatorySchemaResource(String operation, String component) {
|
this.executeSchemaResource(operation, component, this.getResourceForDbOperation(operation, operation, component), false);
|
}
|
|
public String dbSchemaUpdate() {
|
String feedback = null;
|
boolean isUpgradeNeeded = false;
|
int matchingVersionIndex = -1;
|
if (this.isEngineTablePresent()) {
|
PropertyEntity dbVersionProperty = (PropertyEntity)this.selectById(PropertyEntity.class, "schema.version");
|
String dbVersion = dbVersionProperty.getValue();
|
matchingVersionIndex = this.findMatchingVersionIndex(dbVersion);
|
if (matchingVersionIndex < 0 && dbVersion != null && dbVersion.startsWith("5.")) {
|
matchingVersionIndex = this.findMatchingVersionIndex("5.99.0.0");
|
}
|
|
if (matchingVersionIndex < 0) {
|
throw new ActivitiException("Could not update Activiti database schema: unknown version from database: '" + dbVersion + "'");
|
}
|
|
isUpgradeNeeded = matchingVersionIndex != ACTIVITI_VERSIONS.size() - 1;
|
if (isUpgradeNeeded) {
|
dbVersionProperty.setValue("6.0.0.4");
|
PropertyEntity dbHistoryProperty;
|
if ("5.0".equals(dbVersion)) {
|
dbHistoryProperty = (PropertyEntity)Context.getCommandContext().getPropertyEntityManager().create();
|
dbHistoryProperty.setName("schema.history");
|
dbHistoryProperty.setValue("create(5.0)");
|
this.insert(dbHistoryProperty);
|
} else {
|
dbHistoryProperty = (PropertyEntity)this.selectById(PropertyEntity.class, "schema.history");
|
}
|
|
String dbHistoryValue = dbHistoryProperty.getValue() + " upgrade(" + dbVersion + "->" + "6.0.0.4" + ")";
|
dbHistoryProperty.setValue(dbHistoryValue);
|
this.dbSchemaUpgrade("engine", matchingVersionIndex);
|
feedback = "upgraded Activiti from " + dbVersion + " to " + "6.0.0.4";
|
}
|
} else {
|
this.dbSchemaCreateEngine();
|
}
|
|
if (this.isHistoryTablePresent()) {
|
if (isUpgradeNeeded) {
|
this.dbSchemaUpgrade("history", matchingVersionIndex);
|
}
|
} else if (this.dbSqlSessionFactory.isDbHistoryUsed()) {
|
this.dbSchemaCreateHistory();
|
}
|
|
if (this.isIdentityTablePresent()) {
|
if (isUpgradeNeeded) {
|
this.dbSchemaUpgrade("identity", matchingVersionIndex);
|
}
|
} else if (this.dbSqlSessionFactory.isDbIdentityUsed()) {
|
this.dbSchemaCreateIdentity();
|
}
|
|
return feedback;
|
}
|
|
protected int findMatchingVersionIndex(String dbVersion) {
|
int index = 0;
|
int matchingVersionIndex = -1;
|
|
while(matchingVersionIndex < 0 && index < ACTIVITI_VERSIONS.size()) {
|
if (((ActivitiVersion)ACTIVITI_VERSIONS.get(index)).matches(dbVersion)) {
|
matchingVersionIndex = index;
|
} else {
|
++index;
|
}
|
}
|
|
return matchingVersionIndex;
|
}
|
|
public boolean isEngineTablePresent() {
|
return this.isTablePresent("ACT_RU_EXECUTION");
|
}
|
|
public boolean isHistoryTablePresent() {
|
return this.isTablePresent("ACT_HI_PROCINST");
|
}
|
|
public boolean isIdentityTablePresent() {
|
return this.isTablePresent("ACT_ID_USER");
|
}
|
|
public boolean isTablePresent(String tableName) {
|
if (!this.dbSqlSessionFactory.isTablePrefixIsSchema()) {
|
tableName = this.prependDatabaseTablePrefix(tableName);
|
}
|
|
Connection connection = null;
|
|
try {
|
connection = this.sqlSession.getConnection();
|
DatabaseMetaData databaseMetaData = connection.getMetaData();
|
ResultSet tables = null;
|
String catalog = this.connectionMetadataDefaultCatalog;
|
if (this.dbSqlSessionFactory.getDatabaseCatalog() != null && this.dbSqlSessionFactory.getDatabaseCatalog().length() > 0) {
|
catalog = this.dbSqlSessionFactory.getDatabaseCatalog();
|
}
|
|
String schema = this.connectionMetadataDefaultSchema;
|
if (this.dbSqlSessionFactory.getDatabaseSchema() != null && this.dbSqlSessionFactory.getDatabaseSchema().length() > 0) {
|
schema = this.dbSqlSessionFactory.getDatabaseSchema();
|
}
|
|
String databaseType = this.dbSqlSessionFactory.getDatabaseType();
|
if ("postgres".equals(databaseType)) {
|
tableName = tableName.toLowerCase();
|
}
|
|
if (schema != null && "oracle".equals(databaseType)) {
|
schema = schema.toUpperCase();
|
}
|
|
if (catalog != null && catalog.length() == 0) {
|
catalog = null;
|
}
|
|
boolean var8;
|
try {
|
tables = databaseMetaData.getTables(catalog, schema, tableName, JDBC_METADATA_TABLE_TYPES);
|
var8 = tables.next();
|
} finally {
|
try {
|
tables.close();
|
} catch (Exception var16) {
|
Exception e = var16;
|
log.error("Error closing meta data tables", e);
|
}
|
|
}
|
|
return var8;
|
} catch (Exception var18) {
|
Exception e = var18;
|
throw new ActivitiException("couldn't check if tables are already present using metadata: " + e.getMessage(), e);
|
}
|
}
|
|
protected boolean isUpgradeNeeded(String versionInDatabase) {
|
if ("6.0.0.4".equals(versionInDatabase)) {
|
return false;
|
} else {
|
String cleanDbVersion = this.getCleanVersion(versionInDatabase);
|
String[] cleanDbVersionSplitted = cleanDbVersion.split("\\.");
|
int dbMajorVersion = Integer.valueOf(cleanDbVersionSplitted[0]);
|
int dbMinorVersion = Integer.valueOf(cleanDbVersionSplitted[1]);
|
String cleanEngineVersion = this.getCleanVersion("6.0.0.4");
|
String[] cleanEngineVersionSplitted = cleanEngineVersion.split("\\.");
|
int engineMajorVersion = Integer.valueOf(cleanEngineVersionSplitted[0]);
|
int engineMinorVersion = Integer.valueOf(cleanEngineVersionSplitted[1]);
|
if (dbMajorVersion <= engineMajorVersion && (dbMajorVersion > engineMajorVersion || dbMinorVersion <= engineMinorVersion)) {
|
if (cleanDbVersion.compareTo(cleanEngineVersion) == 0) {
|
log.warn("Engine-version is the same, but not an exact match: {} vs. {}. Not performing database-upgrade.", versionInDatabase, "6.0.0.4");
|
return false;
|
} else {
|
return true;
|
}
|
} else {
|
throw new ActivitiException("Version of activiti database (" + versionInDatabase + ") is more recent than the engine (" + "6.0.0.4" + ")");
|
}
|
}
|
}
|
|
protected String getCleanVersion(String versionString) {
|
Matcher matcher = CLEAN_VERSION_REGEX.matcher(versionString);
|
if (!matcher.find()) {
|
throw new ActivitiException("Illegal format for version: " + versionString);
|
} else {
|
String cleanString = matcher.group();
|
|
try {
|
Double.parseDouble(cleanString);
|
return cleanString;
|
} catch (NumberFormatException var5) {
|
throw new ActivitiException("Illegal format for version: " + versionString);
|
}
|
}
|
}
|
|
protected String prependDatabaseTablePrefix(String tableName) {
|
return this.dbSqlSessionFactory.getDatabaseTablePrefix() + tableName;
|
}
|
|
protected void dbSchemaUpgrade(String component, int currentDatabaseVersionsIndex) {
|
ActivitiVersion activitiVersion = (ActivitiVersion)ACTIVITI_VERSIONS.get(currentDatabaseVersionsIndex);
|
String dbVersion = activitiVersion.getMainVersion();
|
log.info("upgrading activiti {} schema from {} to {}", new Object[]{component, dbVersion, "6.0.0.4"});
|
|
for(int i = currentDatabaseVersionsIndex + 1; i < ACTIVITI_VERSIONS.size(); ++i) {
|
String nextVersion = ((ActivitiVersion)ACTIVITI_VERSIONS.get(i)).getMainVersion();
|
if (nextVersion.endsWith("-SNAPSHOT")) {
|
nextVersion = nextVersion.substring(0, nextVersion.length() - "-SNAPSHOT".length());
|
}
|
|
dbVersion = dbVersion.replace(".", "");
|
nextVersion = nextVersion.replace(".", "");
|
log.info("Upgrade needed: {} -> {}. Looking for schema update resource for component '{}'", new Object[]{dbVersion, nextVersion, component});
|
this.executeSchemaResource("upgrade", component, this.getResourceForDbOperation("upgrade", "upgradestep." + dbVersion + ".to." + nextVersion, component), true);
|
dbVersion = nextVersion;
|
}
|
|
}
|
|
public String getResourceForDbOperation(String directory, String operation, String component) {
|
String databaseType = this.dbSqlSessionFactory.getDatabaseType();
|
// 当databaseType 为dm时，借用oracle的sql文件来代替执行
|
if (ProcessEngineConfigurationImpl.DATABASE_TYPE_DM.equals(databaseType)) {
|
databaseType = ProcessEngineConfigurationImpl.DATABASE_TYPE_ORACLE;
|
}
|
return "org/activiti/db/" + directory + "/activiti." + databaseType + "." + operation + "." + component + ".sql";
|
}
|
|
public void executeSchemaResource(String operation, String component, String resourceName, boolean isOptional) {
|
InputStream inputStream = null;
|
|
try {
|
inputStream = ReflectUtil.getResourceAsStream(resourceName);
|
if (inputStream == null) {
|
if (!isOptional) {
|
throw new ActivitiException("resource '" + resourceName + "' is not available");
|
}
|
|
log.info("no schema resource {} for {}", resourceName, operation);
|
} else {
|
this.executeSchemaResource(operation, component, resourceName, inputStream);
|
}
|
} finally {
|
IoUtil.closeSilently(inputStream);
|
}
|
|
}
|
|
private void executeSchemaResource(String operation, String component, String resourceName, InputStream inputStream) {
|
log.info("performing {} on {} with resource {}", new Object[]{operation, component, resourceName});
|
String sqlStatement = null;
|
String exceptionSqlStatement = null;
|
|
try {
|
Connection connection = this.sqlSession.getConnection();
|
Exception exception = null;
|
byte[] bytes = IoUtil.readInputStream(inputStream, resourceName);
|
String ddlStatements = new String(bytes);
|
|
try {
|
if (this.isMysql()) {
|
DatabaseMetaData databaseMetaData = connection.getMetaData();
|
int majorVersion = databaseMetaData.getDatabaseMajorVersion();
|
int minorVersion = databaseMetaData.getDatabaseMinorVersion();
|
log.info("Found MySQL: majorVersion=" + majorVersion + " minorVersion=" + minorVersion);
|
if (majorVersion <= 5 && minorVersion < 6) {
|
ddlStatements = this.updateDdlForMySqlVersionLowerThan56(ddlStatements);
|
}
|
}
|
} catch (Exception var26) {
|
Exception e = var26;
|
log.info("Could not get database metadata", e);
|
}
|
|
BufferedReader reader = new BufferedReader(new StringReader(ddlStatements));
|
String line = this.readNextTrimmedLine(reader);
|
|
for(boolean inOraclePlsqlBlock = false; line != null; line = this.readNextTrimmedLine(reader)) {
|
if (line.startsWith("# ")) {
|
log.debug(line.substring(2));
|
} else if (line.startsWith("-- ")) {
|
log.debug(line.substring(3));
|
} else {
|
Exception e;
|
if (line.startsWith("execute java ")) {
|
String upgradestepClassName = line.substring(13).trim();
|
e = null;
|
|
DbUpgradeStep dbUpgradeStep;
|
try {
|
dbUpgradeStep = (DbUpgradeStep)ReflectUtil.instantiate(upgradestepClassName);
|
} catch (ActivitiException var25) {
|
ActivitiException ex = var25;
|
throw new ActivitiException("database update java class '" + upgradestepClassName + "' can't be instantiated: " + ex.getMessage(), ex);
|
}
|
|
try {
|
log.debug("executing upgrade step java class {}", upgradestepClassName);
|
dbUpgradeStep.execute(this);
|
} catch (Exception var24) {
|
Exception ex = var24;
|
throw new ActivitiException("error while executing database update java class '" + upgradestepClassName + "': " + ex.getMessage(), ex);
|
}
|
} else if (line.length() > 0) {
|
if (this.isOracle() && line.startsWith("begin")) {
|
inOraclePlsqlBlock = true;
|
sqlStatement = this.addSqlStatementPiece(sqlStatement, line);
|
} else if ((!line.endsWith(";") || inOraclePlsqlBlock) && (!line.startsWith("/") || !inOraclePlsqlBlock)) {
|
sqlStatement = this.addSqlStatementPiece(sqlStatement, line);
|
} else {
|
if (inOraclePlsqlBlock) {
|
inOraclePlsqlBlock = false;
|
} else {
|
sqlStatement = this.addSqlStatementPiece(sqlStatement, line.substring(0, line.length() - 1));
|
}
|
|
Statement jdbcStatement = connection.createStatement();
|
|
try {
|
log.debug("SQL: {}", sqlStatement);
|
jdbcStatement.execute(sqlStatement);
|
jdbcStatement.close();
|
} catch (Exception var27) {
|
e = var27;
|
if (exception == null) {
|
exception = e;
|
}
|
|
log.error("problem during schema {}, statement {}", new Object[]{operation, sqlStatement, e});
|
} finally {
|
sqlStatement = null;
|
}
|
}
|
}
|
}
|
}
|
|
if (exception != null) {
|
throw exception;
|
} else {
|
log.debug("activiti db schema {} for component {} successful", operation, component);
|
}
|
} catch (Exception var29) {
|
Exception e = var29;
|
throw new ActivitiException("couldn't " + operation + " db schema: " + exceptionSqlStatement, e);
|
}
|
}
|
|
protected String updateDdlForMySqlVersionLowerThan56(String ddlStatements) {
|
return ddlStatements.replace("timestamp(3)", "timestamp").replace("datetime(3)", "datetime").replace("TIMESTAMP(3)", "TIMESTAMP").replace("DATETIME(3)", "DATETIME");
|
}
|
|
protected String addSqlStatementPiece(String sqlStatement, String line) {
|
return sqlStatement == null ? line : sqlStatement + " \n" + line;
|
}
|
|
protected String readNextTrimmedLine(BufferedReader reader) throws IOException {
|
String line = reader.readLine();
|
if (line != null) {
|
line = line.trim();
|
}
|
|
return line;
|
}
|
|
protected boolean isMissingTablesException(Exception e) {
|
String exceptionMessage = e.getMessage();
|
if (e.getMessage() != null) {
|
if (exceptionMessage.indexOf("Table") != -1 && exceptionMessage.indexOf("not found") != -1) {
|
return true;
|
}
|
|
if ((exceptionMessage.indexOf("Table") != -1 || exceptionMessage.indexOf("table") != -1) && exceptionMessage.indexOf("doesn't exist") != -1) {
|
return true;
|
}
|
|
if ((exceptionMessage.indexOf("relation") != -1 || exceptionMessage.indexOf("table") != -1) && exceptionMessage.indexOf("does not exist") != -1) {
|
return true;
|
}
|
}
|
|
return false;
|
}
|
|
public void performSchemaOperationsProcessEngineBuild() {
|
String databaseSchemaUpdate = Context.getProcessEngineConfiguration().getDatabaseSchemaUpdate();
|
log.debug("Executing performSchemaOperationsProcessEngineBuild with setting " + databaseSchemaUpdate);
|
if ("drop-create".equals(databaseSchemaUpdate)) {
|
try {
|
this.dbSchemaDrop();
|
} catch (RuntimeException var3) {
|
}
|
}
|
|
if (!"create-drop".equals(databaseSchemaUpdate) && !"drop-create".equals(databaseSchemaUpdate) && !"create".equals(databaseSchemaUpdate)) {
|
if ("false".equals(databaseSchemaUpdate)) {
|
this.dbSchemaCheckVersion();
|
} else if ("true".equals(databaseSchemaUpdate)) {
|
this.dbSchemaUpdate();
|
}
|
} else {
|
this.dbSchemaCreate();
|
}
|
|
}
|
|
public void performSchemaOperationsProcessEngineClose() {
|
String databaseSchemaUpdate = Context.getProcessEngineConfiguration().getDatabaseSchemaUpdate();
|
if ("create-drop".equals(databaseSchemaUpdate)) {
|
this.dbSchemaDrop();
|
}
|
|
}
|
|
public <T> T getCustomMapper(Class<T> type) {
|
return this.sqlSession.getMapper(type);
|
}
|
|
public boolean isMysql() {
|
return this.dbSqlSessionFactory.getDatabaseType().equals("mysql");
|
}
|
|
public boolean isOracle() {
|
return this.dbSqlSessionFactory.getDatabaseType().equals("oracle");
|
}
|
|
public DeploymentQueryImpl createDeploymentQuery() {
|
return new DeploymentQueryImpl();
|
}
|
|
public ModelQueryImpl createModelQueryImpl() {
|
return new ModelQueryImpl();
|
}
|
|
public ProcessDefinitionQueryImpl createProcessDefinitionQuery() {
|
return new ProcessDefinitionQueryImpl();
|
}
|
|
public ProcessInstanceQueryImpl createProcessInstanceQuery() {
|
return new ProcessInstanceQueryImpl();
|
}
|
|
public ExecutionQueryImpl createExecutionQuery() {
|
return new ExecutionQueryImpl();
|
}
|
|
public TaskQueryImpl createTaskQuery() {
|
return new TaskQueryImpl();
|
}
|
|
public JobQueryImpl createJobQuery() {
|
return new JobQueryImpl();
|
}
|
|
public HistoricProcessInstanceQueryImpl createHistoricProcessInstanceQuery() {
|
return new HistoricProcessInstanceQueryImpl();
|
}
|
|
public HistoricActivityInstanceQueryImpl createHistoricActivityInstanceQuery() {
|
return new HistoricActivityInstanceQueryImpl();
|
}
|
|
public HistoricTaskInstanceQueryImpl createHistoricTaskInstanceQuery() {
|
return new HistoricTaskInstanceQueryImpl();
|
}
|
|
public HistoricDetailQueryImpl createHistoricDetailQuery() {
|
return new HistoricDetailQueryImpl();
|
}
|
|
public HistoricVariableInstanceQueryImpl createHistoricVariableInstanceQuery() {
|
return new HistoricVariableInstanceQueryImpl();
|
}
|
|
public UserQueryImpl createUserQuery() {
|
return new UserQueryImpl();
|
}
|
|
public GroupQueryImpl createGroupQuery() {
|
return new GroupQueryImpl();
|
}
|
|
public SqlSession getSqlSession() {
|
return this.sqlSession;
|
}
|
|
public DbSqlSessionFactory getDbSqlSessionFactory() {
|
return this.dbSqlSessionFactory;
|
}
|
|
static {
|
ACTIVITI_VERSIONS.add(new ActivitiVersion("5.7"));
|
ACTIVITI_VERSIONS.add(new ActivitiVersion("5.8"));
|
ACTIVITI_VERSIONS.add(new ActivitiVersion("5.9"));
|
ACTIVITI_VERSIONS.add(new ActivitiVersion("5.10"));
|
ACTIVITI_VERSIONS.add(new ActivitiVersion("5.11"));
|
ACTIVITI_VERSIONS.add(new ActivitiVersion("5.12", Arrays.asList("5.12.1", "5.12T")));
|
ACTIVITI_VERSIONS.add(new ActivitiVersion("5.13"));
|
ACTIVITI_VERSIONS.add(new ActivitiVersion("5.14"));
|
ACTIVITI_VERSIONS.add(new ActivitiVersion("5.15"));
|
ACTIVITI_VERSIONS.add(new ActivitiVersion("5.15.1"));
|
ACTIVITI_VERSIONS.add(new ActivitiVersion("5.16"));
|
ACTIVITI_VERSIONS.add(new ActivitiVersion("5.16.1"));
|
ACTIVITI_VERSIONS.add(new ActivitiVersion("5.16.2-SNAPSHOT"));
|
ACTIVITI_VERSIONS.add(new ActivitiVersion("5.16.2"));
|
ACTIVITI_VERSIONS.add(new ActivitiVersion("5.16.3.0"));
|
ACTIVITI_VERSIONS.add(new ActivitiVersion("5.16.4.0"));
|
ACTIVITI_VERSIONS.add(new ActivitiVersion("5.17.0.0"));
|
ACTIVITI_VERSIONS.add(new ActivitiVersion("5.17.0.1"));
|
ACTIVITI_VERSIONS.add(new ActivitiVersion("5.17.0.2"));
|
ACTIVITI_VERSIONS.add(new ActivitiVersion("5.18.0.0"));
|
ACTIVITI_VERSIONS.add(new ActivitiVersion("5.18.0.1"));
|
ACTIVITI_VERSIONS.add(new ActivitiVersion("5.20.0.0"));
|
ACTIVITI_VERSIONS.add(new ActivitiVersion("5.20.0.1"));
|
ACTIVITI_VERSIONS.add(new ActivitiVersion("5.20.0.2"));
|
ACTIVITI_VERSIONS.add(new ActivitiVersion("5.21.0.0"));
|
ACTIVITI_VERSIONS.add(new ActivitiVersion("5.22.0.0"));
|
ACTIVITI_VERSIONS.add(new ActivitiVersion("5.99.0.0"));
|
ACTIVITI_VERSIONS.add(new ActivitiVersion("6.0.0.0"));
|
ACTIVITI_VERSIONS.add(new ActivitiVersion("6.0.0.1"));
|
ACTIVITI_VERSIONS.add(new ActivitiVersion("6.0.0.2"));
|
ACTIVITI_VERSIONS.add(new ActivitiVersion("6.0.0.3"));
|
ACTIVITI_VERSIONS.add(new ActivitiVersion("6.0.0.4"));
|
JDBC_METADATA_TABLE_TYPES = new String[]{"TABLE"};
|
}
|
}
|
