From 7eb4d3bc9e8ac4dd20de869093fd748017d89de3 Mon Sep 17 00:00:00 2001 From: kric_jspark Date: Wed, 4 Nov 2026 18:26:40 +0900 Subject: [PATCH 1/2] =?UTF-8?q?261104=5F03=5FHOT:=20=ED=8A=B8=EB=9E=9C?= =?UTF-8?q?=EC=A0=9D=EC=85=98=20=EB=88=84=EC=88=98=20=EA=B4=80=EB=A0=A8=20?= =?UTF-8?q?=EA=B8=B4=EA=B8=89=20=EC=A1=B0=EC=B9=98=202?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../persistence/mapper/DerivedMapper.java | 2 + .../repository/DerivedRepository.java | 4 + .../service/DerivedManagementService.java | 73 ++++++++++++++++--- .../derived/DerivedComputationService.java | 31 ++++++++ .../derived/DerivedRecalculationGuard.java | 56 +++++--------- .../mybatis/mapper/DerivedMapper.xml | 3 + 6 files changed, 119 insertions(+), 50 deletions(-) diff --git a/src/main/java/com/kri/kart/server/persistence/mapper/DerivedMapper.java b/src/main/java/com/kri/kart/server/persistence/mapper/DerivedMapper.java index 6aeefa2..5a9c298 100644 --- a/src/main/java/com/kri/kart/server/persistence/mapper/DerivedMapper.java +++ b/src/main/java/com/kri/kart/server/persistence/mapper/DerivedMapper.java @@ -14,6 +14,8 @@ public interface DerivedMapper { String lockProject(@Param("pkey") String pkey); + boolean projectExists(@Param("pkey") String pkey); + List definitions(@Param("pkey") String pkey); DerivedDefinitionDto find(@Param("pkey") String pkey, @Param("qid") String qid); diff --git a/src/main/java/com/kri/kart/server/persistence/repository/DerivedRepository.java b/src/main/java/com/kri/kart/server/persistence/repository/DerivedRepository.java index 4fb02af..444ab8f 100644 --- a/src/main/java/com/kri/kart/server/persistence/repository/DerivedRepository.java +++ b/src/main/java/com/kri/kart/server/persistence/repository/DerivedRepository.java @@ -27,6 +27,10 @@ public class DerivedRepository { .lockProject(project.pkey()); } + public boolean projectExists(ProjectRefDto project) { + return surveySessionProvider.mapper(project, DerivedMapper.class).projectExists(project.pkey()); + } + public List definitions(ProjectRefDto project) { return surveySessionProvider.mapper(project, DerivedMapper.class) .definitions(project.pkey()); diff --git a/src/main/java/com/kri/kart/server/service/DerivedManagementService.java b/src/main/java/com/kri/kart/server/service/DerivedManagementService.java index a1bffd3..919ef2a 100644 --- a/src/main/java/com/kri/kart/server/service/DerivedManagementService.java +++ b/src/main/java/com/kri/kart/server/service/DerivedManagementService.java @@ -6,12 +6,15 @@ import com.kri.common.feature.web.BusinessException; import com.kri.common.feature.web.RequestUserContext; import com.kri.kart.server.common.enums.ProjectType; import com.kri.kart.server.dto.derived.DerivedCalculationDto; +import com.kri.kart.server.dto.derived.DerivedDataDto; import com.kri.kart.server.dto.derived.DerivedDefinitionDto; import com.kri.kart.server.dto.derived.DerivedSaveRequestDto; import com.kri.kart.server.dto.project.ProjectRefDto; +import com.kri.kart.server.dto.question.QuestionDto; import com.kri.kart.server.persistence.repository.DerivedRepository; import com.kri.kart.server.service.derived.DerivedComputationService; import com.kri.kart.server.service.derived.DerivedRecalculationGuard; +import java.util.ArrayList; import java.util.List; import java.util.Objects; import java.util.function.Supplier; @@ -156,23 +159,62 @@ public class DerivedManagementService { if (idkey == null || idkey.isBlank() || idkey.length() > 512) { throw BusinessException.badRequest("응답자 ID를 확인해 주세요."); } - return derivedRecalculationGuard.execute(project, () -> transaction( - project, - () -> { - requireProject(project); - // Legacy creates an empty DERIVED_DATA row even if there is no eligible - // response. + return derivedRecalculationGuard.execute(project, idkey, () -> { + if (!derivedRepository.projectExists(project)) { + throw BusinessException.notFound("PROJECT_NOT_FOUND", "프로젝트를 찾을 수 없습니다."); + } + List definitions = derivedRepository.definitions(project); + List derivedIds = derivedIds(definitions); + List questions = definitions.isEmpty() ? List.of() : questionService.list(project, 1001); + List data = definitions.isEmpty() ? List.of() + : derivedRepository.respondentResponses(project, idkey); + if (data.size() > 1) { + // Legacy joins can return multiple rows for one ID. Preserve their database reread + // semantics rather than assuming uniqueness or collapsing results in memory. + return transaction(project, () -> { derivedRepository.ensureRespondent(project, idkey); - var definitions = derivedRepository.definitions(project); - var derivedIds = derivedIds(definitions); int matched = 0; - for (var definition : definitions) { - matched += calculate(project, definition, idkey, derivedIds); + for (DerivedDefinitionDto definition : definitions) { + matched += calculate(project, definition, idkey, derivedIds, questions); } return new DerivedCalculationDto(definitions.size(), matched); - })); + }); + } + definitions.forEach(definition -> validateId(definition.getQid())); + var results = derivedComputationService.calculateRespondent(definitions, questions, data, derivedIds); + List writes = new ArrayList<>(); + int matched = 0; + for (int variable = 0; variable < definitions.size(); variable++) { + List groups = new ArrayList<>(); + for (var group : results.get(variable)) { + groups.add(group.isEmpty() ? null : JsonUtil.toJson(objectMapper, group)); + if (!group.isEmpty()) { + matched++; + } + } + writes.add(new RespondentWrite(definitions.get(variable).getQid(), groups)); + } + int matchedRespondents = matched; + return transaction(project, () -> { + // Keep the original empty-row contract even when there are no definitions or responses. + derivedRepository.ensureRespondent(project, idkey); + for (RespondentWrite write : writes) { + if (write.groups().isEmpty()) { + derivedRepository.clearRespondentData(project, write.qid(), idkey); + } else { + for (String group : write.groups()) { + // JSON_MODIFY updates only this variable on the current row; never replace DATJSON. + derivedRepository.saveData(project, write.qid(), idkey, group); + } + } + } + return new DerivedCalculationDto(definitions.size(), matchedRespondents); + }); + }); } + private record RespondentWrite(String qid, List groups) {} + /** Stored derived variable IDs; uploaded response columns with these IDs are not imported. */ public List derivedIds(ProjectRefDto project) { return derivedIds(derivedRepository.definitions(project)); @@ -205,6 +247,12 @@ public class DerivedManagementService { DerivedDefinitionDto definition, String idkey, List derivedIds) { + return calculate(project, definition, idkey, derivedIds, null); + } + + private int calculate( + ProjectRefDto project, DerivedDefinitionDto definition, String idkey, + List derivedIds, List questions) { validateId(definition.getQid()); if (idkey == null) { derivedRepository.clearData(project, definition.getQid()); @@ -217,7 +265,8 @@ public class DerivedManagementService { : derivedRepository.respondentResponses(project, idkey); var results = derivedComputationService.calculate( - definition, questionService.list(project, idkey == null ? 0 : 1001), data, derivedIds); + definition, questions == null ? questionService.list(project, idkey == null ? 0 : 1001) : questions, + data, derivedIds); int matched = 0; for (int i = 0; i < data.size(); i++) { var group = results.get(i); diff --git a/src/main/java/com/kri/kart/server/service/derived/DerivedComputationService.java b/src/main/java/com/kri/kart/server/service/derived/DerivedComputationService.java index 8944398..2f18c97 100644 --- a/src/main/java/com/kri/kart/server/service/derived/DerivedComputationService.java +++ b/src/main/java/com/kri/kart/server/service/derived/DerivedComputationService.java @@ -134,6 +134,37 @@ public class DerivedComputationService { return results; } + /** Reuse one respondent snapshot, feeding preceding variable results into later conditions. */ + public List> calculateRespondent( + List definitions, List questions, + List data, Collection derivedIds) { + List working = new ArrayList<>(); + for (DerivedDataDto row : data) { + DerivedDataDto copy = new DerivedDataDto(); + copy.setIdkey(row.getIdkey()); + copy.setDatjson(row.getDatjson()); + copy.setDerivedJson(row.getDerivedJson()); + working.add(copy); + } + List> prepared = new ArrayList<>(); + for (DerivedDefinitionDto definition : definitions) { + List groups = calculate(definition, questions, working, derivedIds); + prepared.add(groups); + for (int row = 0; row < working.size(); row++) { + DerivedDataDto response = working.get(row); + ObjectNode derived = response.getDerivedJson() == null + ? objectMapper.createObjectNode() : object(response.getDerivedJson()); + if (groups.get(row).isEmpty()) { + derived.remove(definition.getQid()); + } else { + derived.set(definition.getQid(), groups.get(row)); + } + response.setDerivedJson(JsonUtil.toJson(objectMapper, derived)); + } + } + return prepared; + } + private void flatten(ObjectNode grouped, Map flat) { grouped .fields() diff --git a/src/main/java/com/kri/kart/server/service/derived/DerivedRecalculationGuard.java b/src/main/java/com/kri/kart/server/service/derived/DerivedRecalculationGuard.java index d34c6f8..59bdd7f 100644 --- a/src/main/java/com/kri/kart/server/service/derived/DerivedRecalculationGuard.java +++ b/src/main/java/com/kri/kart/server/service/derived/DerivedRecalculationGuard.java @@ -1,56 +1,41 @@ package com.kri.kart.server.service.derived; import com.kri.common.feature.web.BusinessException; -import com.kri.kart.server.common.enums.ProjectType; -import com.kri.kart.server.config.KartDatabaseProperties; import com.kri.kart.server.dto.project.ProjectRefDto; import java.util.concurrent.ConcurrentHashMap; import java.util.concurrent.Semaphore; import java.util.concurrent.TimeUnit; import java.util.function.Supplier; -import org.springframework.beans.factory.annotation.Autowired; import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty; import org.springframework.http.HttpStatus; import org.springframework.stereotype.Component; -/** Wait before borrowing JDBC connections; database locks still enforce cross-instance safety. */ +/** Serialize duplicate respondent recalculations before reading their response snapshots. */ @Component @ConditionalOnProperty(prefix = "kri.kart.database", name = "enabled", havingValue = "true") public class DerivedRecalculationGuard { - private final ConcurrentHashMap projects = new ConcurrentHashMap<>(); - private final Semaphore kon; - private final Semaphore konkiwi; + private final ConcurrentHashMap respondents = new ConcurrentHashMap<>(); private final long waitNanos; - @Autowired - public DerivedRecalculationGuard(KartDatabaseProperties properties) { - this(properties, TimeUnit.SECONDS.toNanos(10)); + public DerivedRecalculationGuard() { + this(TimeUnit.SECONDS.toNanos(10)); } - DerivedRecalculationGuard(KartDatabaseProperties properties, long waitNanos) { - // Reserve one connection for access checks and other operations when pool size permits. - this.kon = new Semaphore(Math.max(1, properties.getKon().getMaximumPoolSize() - 1), true); - this.konkiwi = new Semaphore(Math.max(1, properties.getKonkiwi().getMaximumPoolSize() - 1), true); + DerivedRecalculationGuard(long waitNanos) { this.waitNanos = waitNanos; } - public T execute(ProjectRefDto project, Supplier action) { - long deadline = System.nanoTime() + waitNanos; - ProjectGate gate = projects.compute(project, (key, current) -> { - ProjectGate selected = current == null ? new ProjectGate() : current; + public T execute(ProjectRefDto project, String idkey, Supplier action) { + RespondentKey respondent = new RespondentKey(project, idkey); + RespondentGate gate = respondents.compute(respondent, (key, current) -> { + RespondentGate selected = current == null ? new RespondentGate() : current; selected.users++; return selected; }); - Semaphore source = project.projectType() == ProjectType.KON ? kon : konkiwi; - boolean projectAcquired = false; - boolean sourceAcquired = false; + boolean acquired = false; try { - projectAcquired = gate.permit.tryAcquire(remaining(deadline), TimeUnit.NANOSECONDS); - if (!projectAcquired) { - throw busy(); - } - sourceAcquired = source.tryAcquire(remaining(deadline), TimeUnit.NANOSECONDS); - if (!sourceAcquired) { + acquired = gate.permit.tryAcquire(waitNanos, TimeUnit.NANOSECONDS); + if (!acquired) { throw busy(); } return action.get(); @@ -58,29 +43,24 @@ public class DerivedRecalculationGuard { Thread.currentThread().interrupt(); throw busy(); } finally { - if (sourceAcquired) { - source.release(); - } - if (projectAcquired) { + if (acquired) { gate.permit.release(); } - projects.computeIfPresent(project, (key, current) -> --current.users == 0 ? null : current); + respondents.computeIfPresent(respondent, (key, current) -> --current.users == 0 ? null : current); } } - private long remaining(long deadline) { - return Math.max(0, deadline - System.nanoTime()); - } - private BusinessException busy() { return BusinessException.of( HttpStatus.SERVICE_UNAVAILABLE, "DERIVED_RECALCULATION_BUSY", "파생변수 재계산 요청이 많습니다. 잠시 후 다시 요청해 주세요."); } - private static final class ProjectGate { + private record RespondentKey(ProjectRefDto project, String idkey) {} + + private static final class RespondentGate { private final Semaphore permit = new Semaphore(1, true); - // Accessed only inside ConcurrentHashMap.compute/computeIfPresent for the project. + // Accessed only inside ConcurrentHashMap.compute/computeIfPresent for the respondent. private int users; } } diff --git a/src/main/resources/mybatis/mapper/DerivedMapper.xml b/src/main/resources/mybatis/mapper/DerivedMapper.xml index 84f3858..74f7327 100644 --- a/src/main/resources/mybatis/mapper/DerivedMapper.xml +++ b/src/main/resources/mybatis/mapper/DerivedMapper.xml @@ -36,6 +36,9 @@ + SELECT JSON_VALUE(PROJECTJSON, '$.must.surveytype') FROM PROJECT WHERE PKEY = #{pkey} - -- 2.49.0.windows.1