Optimize CQL library evaluation and consequently measure evaluation

cqf-fhir-benchmark/src/test/java/org/opencds/cqf/fhir/benchmark/measure/r4/Measure.java

@@ -82,7 +82,7 @@ public Given evaluationOptions(MeasureEvaluationOptions evaluationOptions) {
         }
 
         private R4MeasureService buildMeasureService() {
-            return new R4MeasureService(repository, evaluationOptions, measurePeriodValidator, measureServiceUtils);
+            return new R4MeasureService(repository, evaluationOptions, measurePeriodValidator);
         }
 
         public When when() {

cqf-fhir-cql/src/main/java/org/opencds/cqf/fhir/cql/LibraryEngine.java

@@ -14,6 +14,7 @@
 import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
+import java.util.Objects;
 import java.util.Set;
 import java.util.stream.Collectors;
 import org.apache.commons.lang3.StringUtils;
@@ -25,6 +26,7 @@
 import org.hl7.fhir.instance.model.api.IBaseParameters;
 import org.opencds.cqf.cql.engine.execution.CqlEngine;
 import org.opencds.cqf.cql.engine.execution.EvaluationResult;
+import org.opencds.cqf.cql.engine.execution.EvaluationResultsForMultiLib;
 import org.opencds.cqf.fhir.cql.engine.parameters.CqlFhirParametersConverter;
 import org.opencds.cqf.fhir.cql.engine.parameters.CqlParameterDefinition;
 import org.opencds.cqf.fhir.utility.CqfExpression;
@@ -325,8 +327,8 @@ public List<IBase> resolveExpression(
         return result;
     }
 
-    public EvaluationResult getEvaluationResult(
-            VersionedIdentifier id,
+    public EvaluationResultsForMultiLib getEvaluationResult(
+            List<VersionedIdentifier> ids,
             String patientId,
             IBaseParameters parameters,
             Map<String, Object> rawParameters,
@@ -336,25 +338,53 @@ public EvaluationResult getEvaluationResult(
             @Nullable ZonedDateTime zonedDateTime,
             CqlEngine engine) {
 
-        if (cqlFhirParametersConverter == null) {
-            cqlFhirParametersConverter = Engines.getCqlFhirParametersConverter(repository.fhirContext());
-        }
+        var cqlFhirParametersConverterToUse = Objects.requireNonNullElseGet(
+                cqlFhirParametersConverter, () -> Engines.getCqlFhirParametersConverter(repository.fhirContext()));
+
         // engine context built externally of LibraryEngine?
-        if (engine == null) {
-            engine = Engines.forRepository(repository, settings, additionalData);
-        }
+        var engineToUse = Objects.requireNonNullElseGet(
+                engine, () -> Engines.forRepository(repository, settings, additionalData));
 
-        var evaluationParameters = cqlFhirParametersConverter.toCqlParameters(parameters);
+        var evaluationParameters = cqlFhirParametersConverterToUse.toCqlParameters(parameters);
         if (rawParameters != null && !rawParameters.isEmpty()) {
             evaluationParameters.putAll(rawParameters);
         }
 
-        return engine.evaluate(
-                new VersionedIdentifier().withId(id.getId()),
+        var versionlessIdentifiers = ids.stream()
+                .map(id -> new VersionedIdentifier().withId(id.getId()))
+                .toList();
+
+        return engineToUse.evaluate(
+                versionlessIdentifiers,
                 expressions,
                 buildContextParameter(patientId),
                 evaluationParameters,
                 null,
                 zonedDateTime);
     }
+
+    public EvaluationResult getEvaluationResult(
+            VersionedIdentifier id,
+            String patientId,
+            IBaseParameters parameters,
+            Map<String, Object> rawParameters,
+            IBaseBundle additionalData,
+            Set<String> expressions,
+            CqlFhirParametersConverter cqlFhirParametersConverter,
+            @Nullable ZonedDateTime zonedDateTime,
+            CqlEngine engine) {
+
+        var evaluationResultsForMultiLib = getEvaluationResult(
+                List.of(id),
+                patientId,
+                parameters,
+                rawParameters,
+                additionalData,
+                expressions,
+                cqlFhirParametersConverter,
+                zonedDateTime,
+                engine);
+
+        return evaluationResultsForMultiLib.getOnlyResultOrThrow();
+    }
 }

cqf-fhir-cql/src/test/java/org/opencds/cqf/fhir/cql/EnginesTest.java

@@ -14,11 +14,11 @@
 
 import ca.uhn.fhir.context.FhirContext;
 import ca.uhn.fhir.util.BundleBuilder;
+import jakarta.annotation.Nonnull;
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
 import java.util.stream.StreamSupport;
-import javax.annotation.Nonnull;
 import org.cqframework.cql.cql2elm.StringLibrarySourceProvider;
 import org.cqframework.fhir.npm.NpmPackageManager;
 import org.cqframework.fhir.npm.NpmProcessor;

cqf-fhir-cr-cli/src/main/java/org/opencds/cqf/fhir/cr/cli/command/MeasureCommand.java

@@ -26,10 +26,8 @@
 import org.opencds.cqf.fhir.cr.cli.argument.MeasureCommandArgument;
 import org.opencds.cqf.fhir.cr.cli.command.CqlCommand.SubjectAndResult;
 import org.opencds.cqf.fhir.cr.measure.MeasureEvaluationOptions;
-import org.opencds.cqf.fhir.cr.measure.SubjectProviderOptions;
+import org.opencds.cqf.fhir.cr.measure.common.MeasureProcessorUtils;
 import org.opencds.cqf.fhir.cr.measure.r4.R4MeasureProcessor;
-import org.opencds.cqf.fhir.cr.measure.r4.R4RepositorySubjectProvider;
-import org.opencds.cqf.fhir.cr.measure.r4.utils.R4MeasureServiceUtils;
 import picocli.CommandLine.ArgGroup;
 import picocli.CommandLine.Command;
 
@@ -139,11 +137,7 @@ private static R4MeasureProcessor getR4MeasureProcessor(
         evaluationOptions.setApplyScoringSetMembership(false);
         evaluationOptions.setEvaluationSettings(evaluationSettings);
 
-        return new R4MeasureProcessor(
-                repository,
-                evaluationOptions,
-                new R4RepositorySubjectProvider(new SubjectProviderOptions()),
-                new R4MeasureServiceUtils(repository));
+        return new R4MeasureProcessor(repository, evaluationOptions, new MeasureProcessorUtils());
     }
 
     private void writeJsonToFile(String json, String patientId, Path path) {

cqf-fhir-cr-cli/src/test/java/org/opencds/cqf/fhir/cr/cli/CliTest.java

@@ -327,7 +327,7 @@ void optionsFailure() {
         Main.run(args);
 
         String errOutput = errContent.toString();
-        assertTrue(errOutput.contains("library FluentFunctions loaded, but had errors"));
+        assertTrue(errOutput.contains("Library FluentFunctions loaded, but had errors"));
     }
 
     @Test

cqf-fhir-cr-hapi/src/main/java/org/opencds/cqf/fhir/cr/hapi/config/r4/CrR4Config.java

@@ -48,13 +48,8 @@ public class CrR4Config {
     R4MeasureEvaluatorSingleFactory r4MeasureServiceFactory(
             IRepositoryFactory repositoryFactory,
             MeasureEvaluationOptions evaluationOptions,
-            MeasurePeriodValidator measurePeriodValidator,
-            R4MeasureServiceUtilsFactory r4MeasureServiceUtilsFactory) {
-        return rd -> new R4MeasureService(
-                repositoryFactory.create(rd),
-                evaluationOptions,
-                measurePeriodValidator,
-                r4MeasureServiceUtilsFactory.create(rd));
+            MeasurePeriodValidator measurePeriodValidator) {
+        return rd -> new R4MeasureService(repositoryFactory.create(rd), evaluationOptions, measurePeriodValidator);
     }
 
     @Bean
@@ -90,8 +85,7 @@ ICollectDataServiceFactory collectDataServiceFactory(
             IRepositoryFactory repositoryFactory,
             MeasureEvaluationOptions measureEvaluationOptions,
             R4MeasureServiceUtilsFactory r4MeasureServiceUtilsFactory) {
-        return rd -> new R4CollectDataService(
-                repositoryFactory.create(rd), measureEvaluationOptions, r4MeasureServiceUtilsFactory.create(rd));
+        return rd -> new R4CollectDataService(repositoryFactory.create(rd), measureEvaluationOptions);
     }
 
     @Bean

cqf-fhir-cr-spring/src/main/java/org/opencds/cqf/fhir/cr/spring/measure/MeasureConfiguration.java

@@ -2,10 +2,10 @@
 
 import ca.uhn.fhir.repository.IRepository;
 import org.opencds.cqf.fhir.cr.measure.MeasureEvaluationOptions;
+import org.opencds.cqf.fhir.cr.measure.common.MeasureProcessorUtils;
 import org.opencds.cqf.fhir.cr.measure.common.SubjectProvider;
 import org.opencds.cqf.fhir.cr.measure.dstu3.Dstu3MeasureProcessor;
 import org.opencds.cqf.fhir.cr.measure.r4.R4MeasureProcessor;
-import org.opencds.cqf.fhir.cr.measure.r4.utils.R4MeasureServiceUtils;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.ComponentScan;
 import org.springframework.context.annotation.Configuration;
@@ -26,8 +26,7 @@ Dstu3MeasureProcessor dstu3MeasureProcessor(
     R4MeasureProcessor r4MeasureProcessor(
             IRepository repository,
             MeasureEvaluationOptions measureEvaluationOptions,
-            SubjectProvider subjectProvider,
-            R4MeasureServiceUtils measureServiceUtils) {
-        return new R4MeasureProcessor(repository, measureEvaluationOptions, subjectProvider, measureServiceUtils);
+            MeasureProcessorUtils measureProcessorUtils) {
+        return new R4MeasureProcessor(repository, measureEvaluationOptions, measureProcessorUtils);
     }
 }

cqf-fhir-cr/src/main/java/org/opencds/cqf/fhir/cr/measure/common/CompositeEvaluationResultsPerMeasure.java

@@ -0,0 +1,110 @@
+package org.opencds.cqf.fhir.cr.measure.common;
+
+import com.google.common.collect.ImmutableMap;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import org.hl7.fhir.instance.model.api.IIdType;
+import org.opencds.cqf.cql.engine.execution.EvaluationResult;
+
+/**
+ * Container meant to hold the results or an early and cached CQL measure evaluation that holds
+ * two data points:
+ * <ol>
+ * <li>To hold the results of a measure evaluation, grouped by measure ID, with each measure evaluation grouped by Subject ID</li>
+ * <li>To hold any errors that occurred during the evaluation, grouped by measure ID</li>
+ * </ol>
+ * These data points are not mutually exclusive, meaning a measure may have both successful results and errors.
+ * <p/>
+ * This class also allows the caller to mutate a {@link MeasureDef} with the errors that occurred during the evaluation
+ */
+public class CompositeEvaluationResultsPerMeasure {
+    // The same measure may have successful results AND errors, so account for both
+    private final Map<IIdType, Map<String, EvaluationResult>> resultsPerMeasure;
+    // We may get several errors for a given measure
+    private final Map<IIdType, List<String>> errorsPerMeasure;
+
+    private CompositeEvaluationResultsPerMeasure(Builder builder) {
+
+        var resultsBuilder = ImmutableMap.<IIdType, Map<String, EvaluationResult>>builder();
+        builder.resultsPerMeasure.forEach((key, value) -> resultsBuilder.put(key, ImmutableMap.copyOf(value)));
+        resultsPerMeasure = resultsBuilder.build();
+
+        var errorsBuilder = ImmutableMap.<IIdType, List<String>>builder();
+        builder.errorsPerMeasure.forEach((key, value) -> errorsBuilder.put(key, List.copyOf(value)));
+        errorsPerMeasure = errorsBuilder.build();
+    }
+
+    /**
+     * Retrieves results and populates errors for a given measure.
+     * This method uses direct map lookups for efficient data retrieval.
+     * measureDef will occasionally be prepended with the version, which means we need to parse it into an IIdType which
+     * is too much work, so pass in the measureId directly
+     *
+     * @param measureId the ID of the measure to process
+     * @param measureDef the MeasureDef to populate with errors
+     *
+     * @return a map of evaluation results per subject, or an empty map if none exist
+     */
+    public Map<String, EvaluationResult> processMeasureForSuccessOrFailure(IIdType measureId, MeasureDef measureDef) {
+        var unqualifiedMeasureId = measureId.toUnqualifiedVersionless();
+
+        errorsPerMeasure.getOrDefault(unqualifiedMeasureId, List.of()).forEach(measureDef::addError);
+
+        // We are explicitly maintaining the logic of accepting the lack of any sort of results,
+        // either errors or successes, and returning an empty map.
+        return resultsPerMeasure.getOrDefault(unqualifiedMeasureId, Map.of());
+    }
+
+    public static Builder builder() {
+        return new Builder();
+    }
+
+    public static class Builder {
+        private final Map<IIdType, Map<String, EvaluationResult>> resultsPerMeasure = new HashMap<>();
+        private final Map<IIdType, List<String>> errorsPerMeasure = new HashMap<>();
+
+        public CompositeEvaluationResultsPerMeasure build() {
+            return new CompositeEvaluationResultsPerMeasure(this);
+        }
+
+        public void addResults(List<IIdType> measureIds, String subjectId, EvaluationResult evaluationResult) {
+            for (IIdType measureId : measureIds) {
+                addResult(measureId, subjectId, evaluationResult);
+            }
+        }
+
+        public void addResult(IIdType measureId, String subjectId, EvaluationResult evaluationResult) {
+            // if we have no results, we don't need to add anything
+            if (evaluationResult == null || evaluationResult.expressionResults.isEmpty()) {
+                return;
+            }
+
+            var resultPerMeasure =
+                    resultsPerMeasure.computeIfAbsent(measureId.toUnqualifiedVersionless(), k -> new HashMap<>());
+
+            resultPerMeasure.put(subjectId, evaluationResult);
+        }
+
+        public void addErrors(List<? extends IIdType> measureIds, String error) {
+            if (error == null || error.isEmpty()) {
+                return;
+            }
+
+            for (IIdType measureId : measureIds) {
+                addError(measureId, error);
+            }
+        }
+
+        public void addError(IIdType measureId, String error) {
+            if (error == null || error.isBlank()) {
+                return;
+            }
+
+            errorsPerMeasure
+                    .computeIfAbsent(measureId.toUnqualifiedVersionless(), k -> new ArrayList<>())
+                    .add(error);
+        }
+    }
+}