3 files changed, 187 insertions, 44 deletions

diff --git a/subprojects/store-query-interpreter/src/main/java/tools/refinery/store/query/interpreter/internal/pquery/Dnf2PQuery.java b/subprojects/store-query-interpreter/src/main/java/tools/refinery/store/query/interpreter/internal/pquery/Dnf2PQuery.java
index 24205cf4..4d30f998 100644
--- a/subprojects/store-query-interpreter/src/main/java/tools/refinery/store/query/interpreter/internal/pquery/Dnf2PQuery.java
+++ b/subprojects/store-query-interpreter/src/main/java/tools/refinery/store/query/interpreter/internal/pquery/Dnf2PQuery.java
@@ -1,17 +1,31 @@
 /*
- * SPDX-FileCopyrightText: 2021-2023 The Refinery Authors <https://refinery.tools/>
+ * SPDX-FileCopyrightText: 2021-2024 The Refinery Authors <https://refinery.tools/>
  *
  * SPDX-License-Identifier: EPL-2.0
  */
 package tools.refinery.store.query.interpreter.internal.pquery;
 
+import tools.refinery.interpreter.matchers.backend.IQueryBackendFactory;
+import tools.refinery.interpreter.matchers.backend.QueryEvaluationHint;
+import tools.refinery.interpreter.matchers.context.IInputKey;
+import tools.refinery.interpreter.matchers.psystem.PBody;
+import tools.refinery.interpreter.matchers.psystem.PVariable;
+import tools.refinery.interpreter.matchers.psystem.aggregations.BoundAggregator;
+import tools.refinery.interpreter.matchers.psystem.aggregations.IMultisetAggregationOperator;
+import tools.refinery.interpreter.matchers.psystem.annotations.PAnnotation;
 import tools.refinery.interpreter.matchers.psystem.annotations.ParameterReference;
 import tools.refinery.interpreter.matchers.psystem.basicdeferred.*;
-import tools.refinery.interpreter.matchers.psystem.basicenumerables.*;
 import tools.refinery.interpreter.matchers.psystem.basicenumerables.Connectivity;
+import tools.refinery.interpreter.matchers.psystem.basicenumerables.*;
+import tools.refinery.interpreter.matchers.psystem.queries.PParameter;
+import tools.refinery.interpreter.matchers.psystem.queries.PParameterDirection;
+import tools.refinery.interpreter.matchers.psystem.queries.PQuery;
+import tools.refinery.interpreter.matchers.tuple.Tuple;
+import tools.refinery.interpreter.matchers.tuple.Tuples;
 import tools.refinery.store.query.Constraint;
 import tools.refinery.store.query.dnf.Dnf;
 import tools.refinery.store.query.dnf.DnfClause;
+import tools.refinery.store.query.dnf.FunctionalDependency;
 import tools.refinery.store.query.dnf.SymbolicParameter;
 import tools.refinery.store.query.literal.*;
 import tools.refinery.store.query.term.ConstantTerm;
@@ -20,19 +34,6 @@ import tools.refinery.store.query.term.StatelessAggregator;
 import tools.refinery.store.query.term.Variable;
 import tools.refinery.store.query.view.AnySymbolView;
 import tools.refinery.store.util.CycleDetectingMapper;
-import tools.refinery.interpreter.matchers.backend.IQueryBackendFactory;
-import tools.refinery.interpreter.matchers.backend.QueryEvaluationHint;
-import tools.refinery.interpreter.matchers.context.IInputKey;
-import tools.refinery.interpreter.matchers.psystem.PBody;
-import tools.refinery.interpreter.matchers.psystem.PVariable;
-import tools.refinery.interpreter.matchers.psystem.aggregations.BoundAggregator;
-import tools.refinery.interpreter.matchers.psystem.aggregations.IMultisetAggregationOperator;
-import tools.refinery.interpreter.matchers.psystem.annotations.PAnnotation;
-import tools.refinery.interpreter.matchers.psystem.queries.PParameter;
-import tools.refinery.interpreter.matchers.psystem.queries.PParameterDirection;
-import tools.refinery.interpreter.matchers.psystem.queries.PQuery;
-import tools.refinery.interpreter.matchers.tuple.Tuple;
-import tools.refinery.interpreter.matchers.tuple.Tuples;
 
 import java.util.ArrayList;
 import java.util.HashMap;
@@ -79,15 +80,7 @@ public class Dnf2PQuery {
                 pQuery.setParameters(parameterList);
 
                 for (var functionalDependency : dnfQuery.getFunctionalDependencies()) {
-                        var functionalDependencyAnnotation = new PAnnotation("FunctionalDependency");
-                        for (var forEachVariable : functionalDependency.forEach()) {
-                                var reference = new ParameterReference(forEachVariable.getUniqueName());
-                                functionalDependencyAnnotation.addAttribute("forEach", reference);
-                        }
-                        for (var uniqueVariable : functionalDependency.unique()) {
-                                var reference = new ParameterReference(uniqueVariable.getUniqueName());
-                                functionalDependencyAnnotation.addAttribute("unique", reference);
-                        }
+                        var functionalDependencyAnnotation = getFunctionalDependencyAnnotation(functionalDependency);
                         pQuery.addAnnotation(functionalDependencyAnnotation);
                 }
 
@@ -108,26 +101,33 @@ public class Dnf2PQuery {
                 return pQuery;
         }
 
-        private void translateLiteral(Literal literal, PBody body) {
-                if (literal instanceof EquivalenceLiteral equivalenceLiteral) {
-                        translateEquivalenceLiteral(equivalenceLiteral, body);
-                } else if (literal instanceof CallLiteral callLiteral) {
-                        translateCallLiteral(callLiteral, body);
-                } else if (literal instanceof ConstantLiteral constantLiteral) {
-                        translateConstantLiteral(constantLiteral, body);
-                } else if (literal instanceof AssignLiteral<?> assignLiteral) {
-                        translateAssignLiteral(assignLiteral, body);
-                } else if (literal instanceof CheckLiteral checkLiteral) {
-                        translateCheckLiteral(checkLiteral, body);
-                } else if (literal instanceof CountLiteral countLiteral) {
-                        translateCountLiteral(countLiteral, body);
-                } else if (literal instanceof AggregationLiteral<?, ?> aggregationLiteral) {
-                        translateAggregationLiteral(aggregationLiteral, body);
-                } else if (literal instanceof RepresentativeElectionLiteral representativeElectionLiteral) {
-                        translateRepresentativeElectionLiteral(representativeElectionLiteral, body);
-                } else {
-                        throw new IllegalArgumentException("Unknown literal: " + literal.toString());
+        private static PAnnotation getFunctionalDependencyAnnotation(FunctionalDependency<Variable> functionalDependency) {
+                var functionalDependencyAnnotation = new PAnnotation("FunctionalDependency");
+                for (var forEachVariable : functionalDependency.forEach()) {
+                        var reference = new ParameterReference(forEachVariable.getUniqueName());
+                        functionalDependencyAnnotation.addAttribute("forEach", reference);
+                }
+                for (var uniqueVariable : functionalDependency.unique()) {
+                        var reference = new ParameterReference(uniqueVariable.getUniqueName());
+                        functionalDependencyAnnotation.addAttribute("unique", reference);
                 }
+                return functionalDependencyAnnotation;
+        }
+
+        private void translateLiteral(Literal literal, PBody body) {
+        switch (literal) {
+            case EquivalenceLiteral equivalenceLiteral -> translateEquivalenceLiteral(equivalenceLiteral, body);
+            case CallLiteral callLiteral -> translateCallLiteral(callLiteral, body);
+            case ConstantLiteral constantLiteral -> translateConstantLiteral(constantLiteral, body);
+            case AssignLiteral<?> assignLiteral -> translateAssignLiteral(assignLiteral, body);
+            case CheckLiteral checkLiteral -> translateCheckLiteral(checkLiteral, body);
+            case CountLiteral countLiteral -> translateCountLiteral(countLiteral, body);
+            case AggregationLiteral<?, ?> aggregationLiteral -> translateAggregationLiteral(aggregationLiteral, body);
+                        case LeftJoinLiteral<?> leftJoinLiteral -> translateLeftJoinLiteral(leftJoinLiteral, body);
+            case RepresentativeElectionLiteral representativeElectionLiteral ->
+                    translateRepresentativeElectionLiteral(representativeElectionLiteral, body);
+            case null, default -> throw new IllegalArgumentException("Unknown literal: " + literal);
+        }
         }
 
         private void translateEquivalenceLiteral(EquivalenceLiteral equivalenceLiteral, PBody body) {
@@ -244,6 +244,21 @@ public class Dnf2PQuery {
                                 aggregatedColumn);
         }
 
+        private <T> void translateLeftJoinLiteral(LeftJoinLiteral<T> leftJoinLiteral, PBody body) {
+                var wrappedCall = wrapperFactory.maybeWrapConstraint(leftJoinLiteral);
+                var substitution = translateSubstitution(wrappedCall.remappedArguments(), body);
+                var placeholderVariable = body.getOrCreateVariableByName(
+                                leftJoinLiteral.getPlaceholderVariable().getUniqueName());
+                var optionalColumn = substitution.invertIndex().get(placeholderVariable);
+                if (optionalColumn == null) {
+                        throw new IllegalStateException("Placeholder variable %s not found in substitution %s"
+                                        .formatted(placeholderVariable, substitution));
+                }
+                var resultVariable = body.getOrCreateVariableByName(leftJoinLiteral.getResultVariable().getUniqueName());
+                new LeftJoinConstraint(body, substitution, wrappedCall.pattern(), resultVariable, optionalColumn,
+                                leftJoinLiteral.getDefaultValue());
+        }
+
         private void translateRepresentativeElectionLiteral(RepresentativeElectionLiteral literal, PBody body) {
                 var substitution = translateSubstitution(literal.getArguments(), body);
                 var pattern = wrapConstraintWithIdentityArguments(literal.getTarget());
diff --git a/subprojects/store-query-interpreter/src/test/java/tools/refinery/store/query/interpreter/FunctionalQueryTest.java b/subprojects/store-query-interpreter/src/test/java/tools/refinery/store/query/interpreter/FunctionalQueryTest.java
index b6c96676..ca1512d8 100644
--- a/subprojects/store-query-interpreter/src/test/java/tools/refinery/store/query/interpreter/FunctionalQueryTest.java
+++ b/subprojects/store-query-interpreter/src/test/java/tools/refinery/store/query/interpreter/FunctionalQueryTest.java
@@ -554,7 +554,6 @@ class FunctionalQueryTest {
                 friendInterpretation.put(Tuple.of(1, 2), TruthValue.TRUE);
 
                 queryEngine.flushChanges();
-                queryEngine.flushChanges();
                 assertNullableResults(Map.of(
                                 Tuple.of(0), Optional.of(25),
                                 Tuple.of(1), Optional.of(32),
diff --git a/subprojects/store-query-interpreter/src/test/java/tools/refinery/store/query/interpreter/LeftJoinTest.java b/subprojects/store-query-interpreter/src/test/java/tools/refinery/store/query/interpreter/LeftJoinTest.java
new file mode 100644
index 00000000..4c849e9d
--- /dev/null
+++ b/subprojects/store-query-interpreter/src/test/java/tools/refinery/store/query/interpreter/LeftJoinTest.java
@@ -0,0 +1,129 @@
+/*
+ * SPDX-FileCopyrightText: 2024 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.query.interpreter;
+
+import org.junit.jupiter.api.Test;
+import tools.refinery.store.model.ModelStore;
+import tools.refinery.store.query.ModelQueryAdapter;
+import tools.refinery.store.query.dnf.Query;
+import tools.refinery.store.query.term.int_.IntTerms;
+import tools.refinery.store.query.view.AnySymbolView;
+import tools.refinery.store.query.view.FunctionView;
+import tools.refinery.store.query.view.KeyOnlyView;
+import tools.refinery.store.representation.Symbol;
+import tools.refinery.store.tuple.Tuple;
+
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+
+import static tools.refinery.store.query.interpreter.tests.QueryAssertions.assertNullableResults;
+import static tools.refinery.store.query.interpreter.tests.QueryAssertions.assertResults;
+
+class LeftJoinTest {
+        private static final Symbol<Boolean> person = Symbol.of("Person", 1);
+        private static final Symbol<Integer> age = Symbol.of("age", 1, Integer.class);
+        private static final AnySymbolView personView = new KeyOnlyView<>(person);
+        private static final FunctionView<Integer> ageView = new FunctionView<>(age);
+
+        @Test
+        void unarySymbolTest() {
+                var query = Query.of("Query", Integer.class, (builder, p1, output) -> builder
+                                .clause(
+                                                personView.call(p1),
+                                                output.assign(ageView.leftJoin(18, p1))
+                                ));
+
+                var store = ModelStore.builder()
+                                .symbols(person, age)
+                                .with(QueryInterpreterAdapter.builder()
+                                                .queries(query))
+                                .build();
+
+                var model = store.createEmptyModel();
+                var personInterpretation = model.getInterpretation(person);
+                var ageInterpretation = model.getInterpretation(age);
+                var queryEngine = model.getAdapter(ModelQueryAdapter.class);
+                var queryResultSet = queryEngine.getResultSet(query);
+
+                personInterpretation.put(Tuple.of(0), true);
+                personInterpretation.put(Tuple.of(1), true);
+                personInterpretation.put(Tuple.of(2), true);
+
+                ageInterpretation.put(Tuple.of(2), 24);
+
+                queryEngine.flushChanges();
+                assertNullableResults(Map.of(
+                                Tuple.of(0), Optional.of(18),
+                                Tuple.of(1), Optional.of(18),
+                                Tuple.of(2), Optional.of(24),
+                                Tuple.of(3), Optional.empty()
+                ), queryResultSet);
+
+                personInterpretation.put(Tuple.of(0), false);
+
+                ageInterpretation.put(Tuple.of(1), 20);
+                ageInterpretation.put(Tuple.of(2), null);
+
+                queryEngine.flushChanges();
+                assertNullableResults(Map.of(
+                                Tuple.of(0), Optional.empty(),
+                                Tuple.of(1), Optional.of(20),
+                                Tuple.of(2), Optional.of(18),
+                                Tuple.of(3), Optional.empty()
+                ), queryResultSet);
+        }
+
+        @Test
+        void unarySymbolWithAssignmentTest() {
+                // Tests an edge case where the outer joined variable is already bound in the query plan.
+                var query = Query.of("Query", (builder, p1) -> builder
+                                .clause(Integer.class, v1 -> List.of(
+                                                personView.call(p1),
+                                                v1.assign(IntTerms.constant(18)),
+                                                v1.assign(ageView.leftJoin(18, p1))
+                                )));
+
+                var store = ModelStore.builder()
+                                .symbols(person, age)
+                                .with(QueryInterpreterAdapter.builder()
+                                                .queries(query))
+                                .build();
+
+                var model = store.createEmptyModel();
+                var personInterpretation = model.getInterpretation(person);
+                var ageInterpretation = model.getInterpretation(age);
+                var queryEngine = model.getAdapter(ModelQueryAdapter.class);
+                var queryResultSet = queryEngine.getResultSet(query);
+
+                personInterpretation.put(Tuple.of(0), true);
+                personInterpretation.put(Tuple.of(1), true);
+                personInterpretation.put(Tuple.of(2), true);
+
+                ageInterpretation.put(Tuple.of(2), 24);
+
+                queryEngine.flushChanges();
+                assertResults(Map.of(
+                                Tuple.of(0), true,
+                                Tuple.of(1), true,
+                                Tuple.of(2), false,
+                                Tuple.of(3), false
+                ), queryResultSet);
+
+                personInterpretation.put(Tuple.of(0), false);
+
+                ageInterpretation.put(Tuple.of(1), 20);
+                ageInterpretation.put(Tuple.of(2), null);
+
+                queryEngine.flushChanges();
+                assertResults(Map.of(
+                                Tuple.of(0), false,
+                                Tuple.of(1), false,
+                                Tuple.of(2), true,
+                                Tuple.of(3), false
+                ), queryResultSet);
+        }
+}