private void persistUpdatedIssues(IssueStatistics statistics, List<DefaultIssue> updatedIssues, IssueMapper mapper, IssueChangeMapper changeMapper) { if (updatedIssues.isEmpty()) { return; } long now = system2.now(); updatedIssues.forEach(i -> { IssueDto dto = IssueDto.toDtoForUpdate(i, now); mapper.updateIfBeforeSelectedDate(dto); statistics.updates++; }); // retrieve those of the updatedIssues which have not been updated and apply conflictResolver on them List<String> updatedIssueKeys = updatedIssues.stream().map(DefaultIssue::key).collect(toList(updatedIssues.size())); List<IssueDto> conflictIssueKeys = mapper.selectByKeysIfNotUpdatedAt(updatedIssueKeys, now); if (!conflictIssueKeys.isEmpty()) { Map<String, DefaultIssue> issuesByKeys = updatedIssues.stream().collect(uniqueIndex(DefaultIssue::key, updatedIssues.size())); conflictIssueKeys .forEach(dbIssue -> { DefaultIssue updatedIssue = issuesByKeys.get(dbIssue.getKey()); conflictResolver.resolve(updatedIssue, dbIssue, mapper); statistics.merged++; }); } updatedIssues.forEach(i -> issueStorage.insertChanges(changeMapper, i)); }
private void persistNewIssues(IssueStatistics statistics, List<DefaultIssue> addedIssues, IssueMapper mapper, IssueChangeMapper changeMapper) { if (addedIssues.isEmpty()) { return; } long now = system2.now(); addedIssues.forEach(i -> { int ruleId = ruleRepository.getByKey(i.ruleKey()).getId(); IssueDto dto = IssueDto.toDtoForComputationInsert(i, ruleId, now); mapper.insert(dto); statistics.inserts++; }); addedIssues.forEach(i -> issueStorage.insertChanges(changeMapper, i)); }
/** * @return the keys of the updated issues */ private Collection<IssueDto> update(List<DefaultIssue> issuesToUpdate, long now) { Collection<IssueDto> updated = new ArrayList<>(); if (!issuesToUpdate.isEmpty()) { try (DbSession dbSession = dbClient.openSession(false)) { IssueChangeMapper issueChangeMapper = dbSession.getMapper(IssueChangeMapper.class); for (DefaultIssue issue : issuesToUpdate) { IssueDto issueDto = doUpdate(dbSession, now, issue); updated.add(issueDto); insertChanges(issueChangeMapper, issue); } dbSession.commit(); } } return updated; }
/** * @return the keys of the inserted issues */ private Collection<IssueDto> insert(DbSession session, Iterable<DefaultIssue> issuesToInsert, long now) { List<IssueDto> inserted = newArrayList(); int count = 0; IssueChangeMapper issueChangeMapper = session.getMapper(IssueChangeMapper.class); for (DefaultIssue issue : issuesToInsert) { IssueDto issueDto = doInsert(session, now, issue); inserted.add(issueDto); insertChanges(issueChangeMapper, issue); if (count > BatchSession.MAX_BATCH_SIZE) { session.commit(); count = 0; } count++; } session.commit(); return inserted; }
@Override public void execute() { try (DbSession dbSession = dbClient.openSession(true); CloseableIterator<DefaultIssue> issues = issueCache.traverse()) { IssueMapper mapper = dbSession.getMapper(IssueMapper.class); IssueChangeMapper changeMapper = dbSession.getMapper(IssueChangeMapper.class); while (issues.hasNext()) { DefaultIssue issue = issues.next(); boolean saved = persistIssueIfRequired(mapper, issue); if (saved) { IssueStorage.insertChanges(changeMapper, issue); } } dbSession.flushStatements(); dbSession.commit(); } }