import net.java.ao.Entity; //导入依赖的package包/类
public static <T extends Entity> int delete(final ActiveObjects activeObjects, Class<T> entityType, Query query)
{
    long startTime = System.currentTimeMillis();
    log.debug("Deleting type {}", entityType);

    final Set<Integer> ids = new LinkedHashSet<Integer>();
    activeObjects.stream(entityType, query, new EntityStreamCallback<T, Integer>()
    {

        @Override
        public void onRowRead(T t)
        {
            ids.add(t.getID());
        }

    });

    int deleted = 0;
    Iterable<List<Integer>> windows = Iterables.partition(ids, DELETE_WINDOW_SIZE);
    for (List<Integer> window : windows)
    {
        log.debug("Deleting up to {} entities of {} remaining.", DELETE_WINDOW_SIZE, ids.size() - deleted);
        if (DELETE_WITH_SQL)
        {
            activeObjects.deleteWithSQL(entityType, renderListOperator(ID, "IN", "OR", window), window.toArray());
        } else
        {
            activeObjects.delete(activeObjects.find(entityType, renderListOperator(ID, "IN", "OR", window), window.toArray()));
        }
        deleted += window.size();
    }

    log.debug("Type {} deleted in {} ms", entityType, System.currentTimeMillis() - startTime);

    return deleted;
}
 

import net.java.ao.Entity; //导入依赖的package包/类
@Override
public Void call()
{
    try
    {
        long startTime = System.currentTimeMillis();
        log.debug("Running SmartcommitOperation ... ");

        changesetDao.forEachLatestChangesetsAvailableForSmartcommitDo(repository.getId(),
                new String[] {ID, MESSAGE, NODE, AUTHOR_EMAIL, DATE}, // the columns used in the closure below
                new ForEachChangesetClosure()
        {
            @Override
            public void execute(Entity mapping)
            {
                ChangesetMapping changesetMapping = (ChangesetMapping) mapping;
                log.debug("Processing message \n {} \n for smartcommits. Changeset id = {} node = {}.", new Object[]
                        {changesetMapping.getMessage(), changesetMapping.getID(), changesetMapping.getNode()});

                // first mark as processed
                changesetDao.markSmartcommitAvailability(changesetMapping.getID(), false);
                // parse message
                CommitCommands commands = commitMessageParser.parseCommitComment(changesetMapping.getMessage());
                commands.setCommitDate(changesetMapping.getDate());
                commands.setAuthorEmail(changesetMapping.getAuthorEmail());
                // do commands
                if (CollectionUtils.isNotEmpty(commands.getCommands()))
                {
                    final CommandsResults commandsResults = smartcommitsService.doCommands(commands);
                    if (commandsResults.hasErrors())
                    {

                        Changeset changeset = changesetDao.getByNode(repository.getId(), changesetMapping.getNode());
                        if (changeset != null)
                        {
                            final String commitUrl = changesetService.getCommitUrl(repository, changeset);

                            List<SmartCommitError> smartCommitErrors = new ArrayList<SmartCommitError>();
                            for (String error : commandsResults.getAllErrors())
                            {
                                SmartCommitError sce = new SmartCommitError(changeset.getNode(), commitUrl, error);
                                smartCommitErrors.add(sce);
                            }
                            if (progress != null)
                            {
                                progress.setSmartCommitErrors(smartCommitErrors);
                            }
                        }
                    }
                }
            }
        });

        log.debug("Smartcommits for repository {} were processed in {} ms", repository.getId(), System.currentTimeMillis() - startTime);
    }
    catch (Exception e)
    {
        log.warn("Failed to process smartcommit operation. Cause = " + e.getClass() + " : " + e.getMessage());
    }

    return null;
}
 

import net.java.ao.Entity; //导入依赖的package包/类
private <T extends Entity> void deleteAllExistingTableContent(final ActiveObjects activeObjects, Class<T> entityType)
{
    ActiveObjectsUtils.delete(activeObjects, entityType, Query.select());
}
 

import net.java.ao.Entity; //导入依赖的package包/类
private Entity createEntity(int id)
{
    Entity entity = Mockito.mock(Entity.class);
    when(entity.getID()).thenReturn(id);
    return entity;
}
 

import net.java.ao.Entity; //导入依赖的package包/类
public EntityContext(Entity entity)
{
    this.entity = entity;
    this.captor = ArgumentCaptor.forClass(Entity.class);
}
 

import net.java.ao.Entity; //导入依赖的package包/类
public Entity getEntity()
{
    return entity;
}
 

import net.java.ao.Entity; //导入依赖的package包/类
public ArgumentCaptor<Entity> getCaptor()
{
    return captor;
}
 

import net.java.ao.Entity; //导入依赖的package包/类
/**
 * Creates name of table for provided entity. The name is also sanitized.
 * 
 * @param entity
 *            for which database entity
 * @return name of table
 */
private String table(Class<? extends Entity> entity)
{
    String tableName = tableNameConverter.getName(entity);
    return databaseProvider.withSchema(tableName);
}
 

import net.java.ao.Entity; //导入依赖的package包/类
/**
 * @param changeset
 */
void execute(Entity changeset);