import org.camunda.bpm.engine.impl.db.DbEntity; //导入依赖的package包/类
public Object selectOne(String statement, Object parameter) {
  LOG.log(Level.FINE, "selectOne for statement '"+statement+"' parameter: "+parameter.toString());

  SingleResultQueryHandler<?> queryHandler = singleResultQueryHandlers.get(statement);
  if(queryHandler != null) {
    DbEntity result = queryHandler.executeQuery(this, parameter);
    fireEntityLoaded(result);
    return result;
  }
  else if ("selectTableCount".equals(statement)) {
    @SuppressWarnings("unchecked")
    String tableName = ((Map<String, String>) parameter).get("tableName");
    return cassandraSession.execute(QueryBuilder.select().countAll().from(tableName)).one().getLong(0);
  }
  else {
    LOG.warning("unknown query "+statement);
    return null;
  }

}
 

import org.camunda.bpm.engine.impl.db.DbEntity; //导入依赖的package包/类
public String getTableName(Class<?> entityClass, boolean withPrefix) {
  String databaseTablePrefix = getDbSqlSession().getDbSqlSessionFactory().getDatabaseTablePrefix();
  String tableName = null;

  if (DbEntity.class.isAssignableFrom(entityClass)) {
    tableName = persistentObjectToTableNameMap.get(entityClass);
  }
  else {
    tableName = apiTypeToTableNameMap.get(entityClass);
  }
  if (withPrefix) {
    return databaseTablePrefix + tableName;
  }
  else {
    return tableName;
  }
}
 

import org.camunda.bpm.engine.impl.db.DbEntity; //导入依赖的package包/类
/**
 * get an object from the cache
 *
 * @param type the type of the object
 * @param id the id of the object
 * @return the object or 'null' if the object is not in the cache
 * @throws ProcessEngineException if an object for the given id can be found but is of the wrong type.
 */
@SuppressWarnings("unchecked")
public <T extends DbEntity> T get(Class<T> type, String id) {
  Class<?> cacheKey = cacheKeyMapping.getEntityCacheKey(type);
  CachedDbEntity cachedDbEntity = getCachedEntity(cacheKey, id);
  if(cachedDbEntity != null) {
    DbEntity dbEntity = cachedDbEntity.getEntity();
    try {
      return (T) dbEntity;
    } catch(ClassCastException e) {
      throw LOG.entityCacheLookupException(type, id, dbEntity.getClass(), e);
    }
  } else {
    return null;
  }
}
 

import org.camunda.bpm.engine.impl.db.DbEntity; //导入依赖的package包/类
@SuppressWarnings("unchecked")
public <T extends DbEntity> List<T> getEntitiesByType(Class<T> type) {
  Class<?> cacheKey = cacheKeyMapping.getEntityCacheKey(type);
  Map<String, CachedDbEntity> entities = cachedEntites.get(cacheKey);
  List<T> result = new ArrayList<T>();
  if(entities == null) {
    return Collections.emptyList();
  } else {
    for (CachedDbEntity cachedEntity : entities.values()) {
      if (type != cacheKey) {
        // if the cacheKey of this type differs from the actual type,
        // not all cached entites with the key should be returned.
        // Then we only add those entities whose type matches the argument type.
        if (type.isAssignableFrom(cachedEntity.getClass())) {
          result.add((T) cachedEntity.getEntity());
        }
      } else {
        result.add((T) cachedEntity.getEntity());
      }

    }
    return result;
  }
}
 

import org.camunda.bpm.engine.impl.db.DbEntity; //导入依赖的package包/类
/**
 * Sets an object to a deleted state. It will not be removed from the cache but
 * transition to one of the DELETED states, depending on it's current state.
 *
 * @param dbEntity the object to mark deleted.
 */
public void setDeleted(DbEntity dbEntity) {
  CachedDbEntity cachedEntity = getCachedEntity(dbEntity);
  if(cachedEntity != null) {
    if(cachedEntity.getEntityState() == TRANSIENT) {
      cachedEntity.setEntityState(DELETED_TRANSIENT);

    } else if(cachedEntity.getEntityState() == PERSISTENT){
      cachedEntity.setEntityState(DELETED_PERSISTENT);

    } else if(cachedEntity.getEntityState() == MERGED){
      cachedEntity.setEntityState(DELETED_MERGED);
    }
  } else {
    // put a deleted merged into the cache
    CachedDbEntity cachedDbEntity = new CachedDbEntity();
    cachedDbEntity.setEntity(dbEntity);
    cachedDbEntity.setEntityState(DELETED_MERGED);
    putInternal(cachedDbEntity);

  }
}
 

import org.camunda.bpm.engine.impl.db.DbEntity; //导入依赖的package包/类
@Override
protected void insertEntity(DbEntityOperation operation) {

  final DbEntity dbEntity = operation.getEntity();

  // get statement
  String insertStatement = dbSqlSessionFactory.getInsertStatement(dbEntity);
  insertStatement = dbSqlSessionFactory.mapStatement(insertStatement);
  ensureNotNull("no insert statement for " + dbEntity.getClass() + " in the ibatis mapping files", "insertStatement", insertStatement);

  // execute the insert
  executeInsertEntity(insertStatement, dbEntity);

  // perform post insert actions on entity
  entityInserted(dbEntity);
}
 

import org.camunda.bpm.engine.impl.db.DbEntity; //导入依赖的package包/类
@Override
protected void deleteEntity(DbEntityOperation operation) {

  final DbEntity dbEntity = operation.getEntity();

  // get statement
  String deleteStatement = dbSqlSessionFactory.getDeleteStatement(dbEntity.getClass());
  ensureNotNull("no delete statement for " + dbEntity.getClass() + " in the ibatis mapping files", "deleteStatement", deleteStatement);

  LOG.executeDatabaseOperation("DELETE", dbEntity);

  // execute the delete
  int nrOfRowsDeleted = executeDelete(deleteStatement, dbEntity);

  // It only makes sense to check for optimistic locking exceptions for objects that actually have a revision
  if (dbEntity instanceof HasDbRevision && nrOfRowsDeleted == 0) {
    operation.setFailed(true);
    return;
  }

  // perform post delete action
  entityDeleted(dbEntity);
}
 

import org.camunda.bpm.engine.impl.db.DbEntity; //导入依赖的package包/类
private void deleteJobInDatabase() {
    CommandExecutor commandExecutor = processEngineConfiguration.getCommandExecutorTxRequired();
    commandExecutor.execute(new Command<Void>() {
      public Void execute(CommandContext commandContext) {

        timerEntity.delete();

        commandContext.getHistoricJobLogManager().deleteHistoricJobLogByJobId(timerEntity.getId());

        List<HistoricIncident> historicIncidents = Context
            .getProcessEngineConfiguration()
            .getHistoryService()
            .createHistoricIncidentQuery()
            .list();

        for (HistoricIncident historicIncident : historicIncidents) {
          commandContext
            .getDbEntityManager()
            .delete((DbEntity) historicIncident);
        }

        return null;
      }
    });
}
 

import org.camunda.bpm.engine.impl.db.DbEntity; //导入依赖的package包/类
@Override
public void onEntityLoaded(DbEntity entity) {
  if(entity instanceof JobEntity){
    CassandraSerializer<JobEntity> serializer = CassandraPersistenceSession.getSerializer(JobEntity.class);
    JobEntity copy= serializer.copy((JobEntity) entity);
    entityCache.put(entity.getId(), copy);
  }
}
 

import org.camunda.bpm.engine.impl.db.DbEntity; //导入依赖的package包/类
@SuppressWarnings("unchecked")
public <T extends DbEntity> T selectById(Class<T> type, String id) {
  LOG.log(Level.FINE, "selectById for type '"+type.getSimpleName()+"' id '" +id+"'");

  EntityOperationHandler<?> entityOperations = operations.get(type);
  if(entityOperations != null) {
    DbEntity loadedEntity = entityOperations.getEntityById(this, id);
    fireEntityLoaded(loadedEntity);
    return (T) loadedEntity;
  }

  LOG.warning("Unhandled select by id "+type +" "+id);
  return null;
}
 

import org.camunda.bpm.engine.impl.db.DbEntity; //导入依赖的package包/类
protected void processLoadedComposite(LoadedCompositeEntity composite) {
  DbEntity mainEntity = composite.getPrimaryEntity();
  boolean isMainEntityEventFired = false;
  for (Map<String, ? extends DbEntity> entities : composite.getEmbeddedEntities().values()) {
    for (DbEntity entity : entities.values()) {
      fireEntityLoaded(entity);
      if(entity == mainEntity) {
        isMainEntityEventFired = true;
      }
    }
  }
  if(!isMainEntityEventFired) {
    fireEntityLoaded(mainEntity);
  }
}
 

import org.camunda.bpm.engine.impl.db.DbEntity; //导入依赖的package包/类
public List<Class<? extends DbEntity>> getEntities(String tableName) {
  String databaseTablePrefix = getDbSqlSession().getDbSqlSessionFactory().getDatabaseTablePrefix();
  List<Class<? extends DbEntity>> entities = new ArrayList<Class<? extends DbEntity>>();

  Set<Class<? extends DbEntity>> entityClasses = persistentObjectToTableNameMap.keySet();
  for (Class<? extends DbEntity> entityClass : entityClasses) {
    String entityTableName = persistentObjectToTableNameMap.get(entityClass);
    if ((databaseTablePrefix + entityTableName).equals(tableName)) {
      entities.add(entityClass);
    }
  }
  return entities;
}
 

import org.camunda.bpm.engine.impl.db.DbEntity; //导入依赖的package包/类
public int compare(DbEntityOperation firstOperation, DbEntityOperation secondOperation) {

    if(firstOperation.equals(secondOperation)) {
      return 0;
    }

    DbEntity firstEntity = firstOperation.getEntity();
    DbEntity secondEntity = secondOperation.getEntity();

    return firstEntity.getId().compareTo(secondEntity.getId());
  }
 

import org.camunda.bpm.engine.impl.db.DbEntity; //导入依赖的package包/类
protected SortedSet<DbEntityOperation> getDeletesByType(Class<? extends DbEntity> type, boolean create) {
  SortedSet<DbEntityOperation> deletesByType = deletes.get(type);
  if(deletesByType == null && create) {
    deletesByType = new TreeSet<DbEntityOperation>(MODIFICATION_OPERATION_COMPARATOR);
    deletes.put(type, deletesByType);
  }
  return deletesByType;
}
 

import org.camunda.bpm.engine.impl.db.DbEntity; //导入依赖的package包/类
protected SortedSet<DbEntityOperation> getUpdatesByType(Class<? extends DbEntity> type, boolean create) {
  SortedSet<DbEntityOperation> updatesByType = updates.get(type);
  if(updatesByType == null && create) {
    updatesByType = new TreeSet<DbEntityOperation>(MODIFICATION_OPERATION_COMPARATOR);
    updates.put(type, updatesByType);
  }
  return updatesByType;
}
 

import org.camunda.bpm.engine.impl.db.DbEntity; //导入依赖的package包/类
protected SortedSet<DbEntityOperation> getInsertsForType(Class<? extends DbEntity> type, boolean create) {
  SortedSet<DbEntityOperation> insertsByType = inserts.get(type);
  if(insertsByType == null && create) {
    insertsByType = new TreeSet<DbEntityOperation>(INSERT_OPERATION_COMPARATOR);
    inserts.put(type, insertsByType);
  }
  return insertsByType;
}
 

import org.camunda.bpm.engine.impl.db.DbEntity; //导入依赖的package包/类
public Object selectOne(String statement, Object parameter) {
  Object result = persistenceSession.selectOne(statement, parameter);
  if (result instanceof DbEntity) {
    DbEntity loadedObject = (DbEntity) result;
    result = cacheFilter(loadedObject);
  }
  return result;
}
 

import org.camunda.bpm.engine.impl.db.DbEntity; //导入依赖的package包/类
public <T extends DbEntity> T selectById(Class<T> entityClass, String id) {
  T persistentObject = dbEntityCache.get(entityClass, id);
  if (persistentObject!=null) {
    return persistentObject;
  }

  persistentObject = persistenceSession.selectById(entityClass, id);

  if (persistentObject==null) {
    return null;
  }
  // don't have to put object into the cache now. See onEntityLoaded() callback
  return persistentObject;
}
 

import org.camunda.bpm.engine.impl.db.DbEntity; //导入依赖的package包/类
protected List filterLoadedObjects(List<Object> loadedObjects) {
  if (loadedObjects.isEmpty() || loadedObjects.get(0) == null) {
    return loadedObjects;
  }
  if (! (DbEntity.class.isAssignableFrom(loadedObjects.get(0).getClass()))) {
    return loadedObjects;
  }
  List<DbEntity> filteredObjects = new ArrayList<DbEntity>(loadedObjects.size());
  for (Object loadedObject: loadedObjects) {
    DbEntity cachedPersistentObject = cacheFilter((DbEntity) loadedObject);
    filteredObjects.add(cachedPersistentObject);
  }
  return filteredObjects;
}
 

import org.camunda.bpm.engine.impl.db.DbEntity; //导入依赖的package包/类
/** returns the object in the cache.  if this object was loaded before,
 * then the original object is returned. */
protected DbEntity cacheFilter(DbEntity persistentObject) {
  DbEntity cachedPersistentObject = dbEntityCache.get(persistentObject.getClass(), persistentObject.getId());
  if (cachedPersistentObject!=null) {
    return cachedPersistentObject;
  }
  else {
    return persistentObject;
  }

}