Examples with Entity org.activiti.engine.impl.persistence.entity.Entity used on opensource projects

Example 6 with Entity

use of org.activiti.engine.impl.persistence.entity.Entity in project Activiti by Activiti.

the class DbSqlSession method selectOne.

public Object selectOne(String statement, Object parameter) {
    statement = dbSqlSessionFactory.mapStatement(statement);
    Object result = sqlSession.selectOne(statement, parameter);
    if (result instanceof Entity) {
        Entity loadedObject = (Entity) result;
        result = cacheLoadOrStore(loadedObject);
    }
    return result;
}

Example 7 with Entity

use of org.activiti.engine.impl.persistence.entity.Entity in project Activiti by Activiti.

the class DbSqlSession method debugFlush.

protected void debugFlush() {
    log.debug("Flushing dbSqlSession");
    int nrOfInserts = 0, nrOfUpdates = 0, nrOfDeletes = 0;
    for (Map<String, Entity> insertedObjectMap : insertedObjects.values()) {
        for (Entity insertedObject : insertedObjectMap.values()) {
            log.debug("  insert {}", insertedObject);
            nrOfInserts++;
        }
    }
    for (Entity updatedObject : updatedObjects) {
        log.debug("  update {}", updatedObject);
        nrOfUpdates++;
    }
    for (Map<String, Entity> deletedObjectMap : deletedObjects.values()) {
        for (Entity deletedObject : deletedObjectMap.values()) {
            log.debug("  delete {} with id {}", deletedObject, deletedObject.getId());
            nrOfDeletes++;
        }
    }
    for (Collection<BulkDeleteOperation> bulkDeleteOperationList : bulkDeleteOperations.values()) {
        for (BulkDeleteOperation bulkDeleteOperation : bulkDeleteOperationList) {
            log.debug("  {}", bulkDeleteOperation);
            nrOfDeletes++;
        }
    }
    log.debug("flush summary: {} insert, {} update, {} delete.", nrOfInserts, nrOfUpdates, nrOfDeletes);
    log.debug("now executing flush...");
}

Example 8 with Entity

use of org.activiti.engine.impl.persistence.entity.Entity in project Activiti by Activiti.

the class DbSqlSession method flushDeleteEntities.

protected void flushDeleteEntities(Class<? extends Entity> entityClass, Collection<Entity> entitiesToDelete) {
    for (Entity entity : entitiesToDelete) {
        String deleteStatement = dbSqlSessionFactory.getDeleteStatement(entity.getClass());
        deleteStatement = dbSqlSessionFactory.mapStatement(deleteStatement);
        if (deleteStatement == null) {
            throw new ActivitiException("no delete statement for " + entity.getClass() + " in the ibatis mapping files");
        }
        // for objects that actually have a revision
        if (entity instanceof HasRevision) {
            int nrOfRowsDeleted = sqlSession.delete(deleteStatement, entity);
            if (nrOfRowsDeleted == 0) {
                throw new ActivitiOptimisticLockingException(entity + " was updated by another transaction concurrently");
            }
        } else {
            sqlSession.delete(deleteStatement, entity);
        }
    }
}

Example 9 with Entity

use of org.activiti.engine.impl.persistence.entity.Entity in project Activiti by Activiti.

the class DbSqlSession method determineUpdatedObjects.

public void determineUpdatedObjects() {
    updatedObjects = new ArrayList<Entity>();
    Map<Class<?>, Map<String, CachedEntity>> cachedObjects = entityCache.getAllCachedEntities();
    for (Class<?> clazz : cachedObjects.keySet()) {
        Map<String, CachedEntity> classCache = cachedObjects.get(clazz);
        for (CachedEntity cachedObject : classCache.values()) {
            Entity cachedEntity = cachedObject.getEntity();
            if (!isEntityInserted(cachedEntity) && (ExecutionEntity.class.isAssignableFrom(cachedEntity.getClass()) || !isEntityToBeDeleted(cachedEntity)) && cachedObject.hasChanged()) {
                updatedObjects.add(cachedEntity);
            }
        }
    }
}

Example 10 with Entity

use of org.activiti.engine.impl.persistence.entity.Entity in project Activiti by Activiti.

the class DbSqlSession method removeUnnecessaryOperations.

/**
 * Clears all deleted and inserted objects from the cache,
 * and removes inserts and deletes that cancel each other.
 * <p>
 * Also removes deletes with duplicate ids.
 */
protected void removeUnnecessaryOperations() {
    for (Class<? extends Entity> entityClass : deletedObjects.keySet()) {
        // Collect ids of deleted entities + remove duplicates
        Set<String> ids = new HashSet<String>();
        Iterator<Entity> entitiesToDeleteIterator = deletedObjects.get(entityClass).values().iterator();
        while (entitiesToDeleteIterator.hasNext()) {
            Entity entityToDelete = entitiesToDeleteIterator.next();
            if (!ids.contains(entityToDelete.getId())) {
                ids.add(entityToDelete.getId());
            } else {
                // Removing duplicate deletes
                entitiesToDeleteIterator.remove();
            }
        }
        // Now we have the deleted ids, we can remove the inserted objects (as they cancel each other)
        for (String id : ids) {
            if (insertedObjects.containsKey(entityClass) && insertedObjects.get(entityClass).containsKey(id)) {
                insertedObjects.get(entityClass).remove(id);
                deletedObjects.get(entityClass).remove(id);
            }
        }
    }
}