7 files changed, 151 insertions, 107 deletions

diff --git a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/ViatraModelQueryAdapterImpl.java b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/ViatraModelQueryAdapterImpl.java
index e0341598..37700413 100644
--- a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/ViatraModelQueryAdapterImpl.java
+++ b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/ViatraModelQueryAdapterImpl.java
@@ -21,32 +21,37 @@ import java.util.Map;
 
 public class ViatraModelQueryAdapterImpl implements ViatraModelQueryAdapter {
         private static final String DELAY_MESSAGE_DELIVERY_FIELD_NAME = "delayMessageDelivery";
+        private static final MethodHandle SET_UPDATE_PROPAGATION_DELAYED_HANDLE;
         private static final String QUERY_BACKENDS_FIELD_NAME = "queryBackends";
+        private static final MethodHandle GET_QUERY_BACKENDS_HANDLE;
 
         private final Model model;
         private final ViatraModelQueryStoreAdapterImpl storeAdapter;
         private final ViatraQueryEngineImpl queryEngine;
-        private final MethodHandle setUpdatePropagationDelayedHandle;
-        private final MethodHandle getQueryBackendsHandle;
+
         private final Map<Dnf, ResultSet> resultSets;
         private boolean pendingChanges;
 
-        ViatraModelQueryAdapterImpl(Model model, ViatraModelQueryStoreAdapterImpl storeAdapter) {
-                this.model = model;
-                this.storeAdapter = storeAdapter;
-                var scope = new RelationalScope(this);
-                queryEngine = (ViatraQueryEngineImpl) AdvancedViatraQueryEngine.createUnmanagedEngine(scope);
-
+        static {
                 try {
                         var lookup = MethodHandles.privateLookupIn(ViatraQueryEngineImpl.class, MethodHandles.lookup());
-                        setUpdatePropagationDelayedHandle = lookup.findSetter(ViatraQueryEngineImpl.class,
+                        SET_UPDATE_PROPAGATION_DELAYED_HANDLE = lookup.findSetter(ViatraQueryEngineImpl.class,
                                         DELAY_MESSAGE_DELIVERY_FIELD_NAME, Boolean.TYPE);
-                        getQueryBackendsHandle = lookup.findGetter(ViatraQueryEngineImpl.class, QUERY_BACKENDS_FIELD_NAME,
+                        GET_QUERY_BACKENDS_HANDLE = lookup.findGetter(ViatraQueryEngineImpl.class, QUERY_BACKENDS_FIELD_NAME,
                                         Map.class);
                 } catch (IllegalAccessException | NoSuchFieldException e) {
                         throw new IllegalStateException("Cannot access private members of %s"
                                         .formatted(ViatraQueryEngineImpl.class.getName()), e);
                 }
+        }
+
+        ViatraModelQueryAdapterImpl(Model model, ViatraModelQueryStoreAdapterImpl storeAdapter) {
+                this.model = model;
+                this.storeAdapter = storeAdapter;
+                var scope = new RelationalScope(this);
+                queryEngine = (ViatraQueryEngineImpl) AdvancedViatraQueryEngine.createUnmanagedEngine(scope);
+
+
 
                 var querySpecifications = storeAdapter.getQuerySpecifications();
                 GenericQueryGroup.of(
@@ -67,7 +72,7 @@ public class ViatraModelQueryAdapterImpl implements ViatraModelQueryAdapter {
 
         private void setUpdatePropagationDelayed(boolean value) {
                 try {
-                        setUpdatePropagationDelayedHandle.invokeExact(queryEngine, value);
+                        SET_UPDATE_PROPAGATION_DELAYED_HANDLE.invokeExact(queryEngine, value);
                 } catch (Error e) {
                         // Fatal JVM errors should not be wrapped.
                         throw e;
@@ -79,7 +84,7 @@ public class ViatraModelQueryAdapterImpl implements ViatraModelQueryAdapter {
         private Collection<IQueryBackend> getQueryBackends() {
                 try {
                         @SuppressWarnings("unchecked")
-                        var backendMap = (Map<IQueryBackendFactory, IQueryBackend>) getQueryBackendsHandle.invokeExact(queryEngine);
+                        var backendMap = (Map<IQueryBackendFactory, IQueryBackend>) GET_QUERY_BACKENDS_HANDLE.invokeExact(queryEngine);
                         return backendMap.values();
                 } catch (Error e) {
                         // Fatal JVM errors should not be wrapped.
diff --git a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/pquery/IndexerUtils.java b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/pquery/IndexerUtils.java
new file mode 100644
index 00000000..75588b81
--- /dev/null
+++ b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/pquery/IndexerUtils.java
@@ -0,0 +1,48 @@
+package tools.refinery.store.query.viatra.internal.pquery;
+
+import org.eclipse.viatra.query.runtime.matchers.tuple.TupleMask;
+import org.eclipse.viatra.query.runtime.rete.index.Indexer;
+import org.eclipse.viatra.query.runtime.rete.matcher.ReteEngine;
+import org.eclipse.viatra.query.runtime.rete.matcher.RetePatternMatcher;
+import org.eclipse.viatra.query.runtime.rete.traceability.RecipeTraceInfo;
+
+import java.lang.invoke.MethodHandle;
+import java.lang.invoke.MethodHandles;
+import java.lang.invoke.MethodType;
+
+final class IndexerUtils {
+    private static final MethodHandle GET_ENGINE_HANDLE;
+    private static final MethodHandle GET_PRODUCTION_NODE_TRACE_HANDLE;
+    private static final MethodHandle ACCESS_PROJECTION_HANDLE;
+
+    static {
+        try {
+            var lookup = MethodHandles.privateLookupIn(RetePatternMatcher.class, MethodHandles.lookup());
+            GET_ENGINE_HANDLE = lookup.findGetter(RetePatternMatcher.class, "engine", ReteEngine.class);
+            GET_PRODUCTION_NODE_TRACE_HANDLE = lookup.findGetter(RetePatternMatcher.class, "productionNodeTrace",
+                    RecipeTraceInfo.class);
+            ACCESS_PROJECTION_HANDLE = lookup.findVirtual(ReteEngine.class, "accessProjection",
+                    MethodType.methodType(Indexer.class, RecipeTraceInfo.class, TupleMask.class));
+        } catch (IllegalAccessException | NoSuchFieldException | NoSuchMethodException e) {
+            throw new IllegalStateException("Cannot access private members of %s"
+                    .formatted(RetePatternMatcher.class.getPackageName()), e);
+        }
+    }
+
+    private IndexerUtils() {
+        throw new IllegalStateException("This is a static utility class and should not be instantiated directly");
+    }
+
+    public static Indexer getIndexer(RetePatternMatcher backend, TupleMask mask) {
+        try {
+            var engine = (ReteEngine) GET_ENGINE_HANDLE.invokeExact(backend);
+            var trace = (RecipeTraceInfo) GET_PRODUCTION_NODE_TRACE_HANDLE.invokeExact(backend);
+            return (Indexer) ACCESS_PROJECTION_HANDLE.invokeExact(engine, trace, mask);
+        } catch (Error e) {
+            // Fatal JVM errors should not be wrapped.
+            throw e;
+        } catch (Throwable e) {
+            throw new IllegalStateException("Cannot access matcher for mask " + mask, e);
+        }
+    }
+}
diff --git a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/pquery/RawPatternMatcher.java b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/pquery/RawPatternMatcher.java
index e944e873..8f56586e 100644
--- a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/pquery/RawPatternMatcher.java
+++ b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/pquery/RawPatternMatcher.java
@@ -2,71 +2,92 @@ package tools.refinery.store.query.viatra.internal.pquery;
 
 import org.eclipse.viatra.query.runtime.api.GenericPatternMatcher;
 import org.eclipse.viatra.query.runtime.api.GenericQuerySpecification;
+import org.eclipse.viatra.query.runtime.api.ViatraQueryEngine;
+import org.eclipse.viatra.query.runtime.matchers.backend.IMatcherCapability;
+import org.eclipse.viatra.query.runtime.matchers.backend.IQueryResultProvider;
+import org.eclipse.viatra.query.runtime.matchers.tuple.TupleMask;
+import org.eclipse.viatra.query.runtime.matchers.tuple.Tuples;
+import org.eclipse.viatra.query.runtime.rete.index.Indexer;
+import org.eclipse.viatra.query.runtime.rete.matcher.RetePatternMatcher;
 import tools.refinery.store.query.ResultSet;
 import tools.refinery.store.query.viatra.ViatraTupleLike;
 import tools.refinery.store.tuple.Tuple;
 import tools.refinery.store.tuple.TupleLike;
 
-import java.util.Optional;
 import java.util.stream.Stream;
 
+/**
+ * Directly access the tuples inside a VIATRA pattern matcher.<p>
+ * This class neglects calling
+ * {@link org.eclipse.viatra.query.runtime.matchers.context.IQueryRuntimeContext#wrapTuple(org.eclipse.viatra.query.runtime.matchers.tuple.Tuple)}
+ * and
+ * {@link org.eclipse.viatra.query.runtime.matchers.context.IQueryRuntimeContext#unwrapTuple(org.eclipse.viatra.query.runtime.matchers.tuple.Tuple)},
+ * because {@link tools.refinery.store.query.viatra.internal.context.RelationalRuntimeContext} provides a trivial
+ * implementation for these methods.
+ * Using this class with any other runtime context may lead to undefined behavior.
+ */
 public class RawPatternMatcher extends GenericPatternMatcher implements ResultSet {
-        protected final Object[] empty;
+    private final Object[] empty;
+    private final TupleMask identityMask;
+    private Indexer emptyMaskIndexer;
 
-        public RawPatternMatcher(GenericQuerySpecification<? extends GenericPatternMatcher> specification) {
-                super(specification);
-                empty = new Object[specification.getParameterNames().size()];
-        }
+    public RawPatternMatcher(GenericQuerySpecification<? extends GenericPatternMatcher> specification) {
+        super(specification);
+        var arity = specification.getParameterNames().size();
+        empty = new Object[arity];
+        identityMask = TupleMask.identity(arity);
+    }
 
-        @Override
-        public boolean hasResult() {
-                return backend.hasMatch(empty);
-        }
+    @Override
+    protected void setBackend(ViatraQueryEngine engine, IQueryResultProvider resultProvider,
+                              IMatcherCapability capabilities) {
+        super.setBackend(engine, resultProvider, capabilities);
+        if (resultProvider instanceof RetePatternMatcher reteBackend) {
+            emptyMaskIndexer = IndexerUtils.getIndexer(reteBackend, TupleMask.empty(identityMask.sourceWidth));
+        }
+    }
 
-        @Override
-        public boolean hasResult(Tuple parameters) {
-                return backend.hasMatch(toParametersArray(parameters));
-        }
+    @Override
+    public boolean hasResult(TupleLike parameters) {
+        org.eclipse.viatra.query.runtime.matchers.tuple.Tuple tuple;
+        if (parameters instanceof ViatraTupleLike viatraTupleLike) {
+            tuple = viatraTupleLike.wrappedTuple().toImmutable();
+        } else {
+            var parametersArray = toParametersArray(parameters);
+            tuple = Tuples.flatTupleOf(parametersArray);
+        }
+        if (emptyMaskIndexer == null) {
+            return backend.hasMatch(identityMask, tuple);
+        }
+        var matches = emptyMaskIndexer.get(Tuples.staticArityFlatTupleOf());
+        return matches != null && matches.contains(tuple);
+    }
 
-        @Override
-        public Optional<TupleLike> oneResult() {
-                return backend.getOneArbitraryMatch(empty).map(ViatraTupleLike::new);
-        }
+    @Override
+    public Stream<TupleLike> allResults() {
+        if (emptyMaskIndexer == null) {
+            return backend.getAllMatches(empty).map(ViatraTupleLike::new);
+        }
+        var matches = emptyMaskIndexer.get(Tuples.staticArityFlatTupleOf());
+        return matches == null ? Stream.of() : matches.stream().map(ViatraTupleLike::new);
+    }
 
-        @Override
-        public Optional<TupleLike> oneResult(Tuple parameters) {
-                return backend.getOneArbitraryMatch(toParametersArray(parameters)).map(ViatraTupleLike::new);
-        }
+    @Override
+    public int countResults() {
+        if (emptyMaskIndexer == null) {
+            return backend.countMatches(empty);
+        }
+        var matches = emptyMaskIndexer.get(Tuples.staticArityFlatTupleOf());
+        return matches == null ? 0 : matches.size();
+    }
 
-        @Override
-        public Stream<TupleLike> allResults() {
-                return backend.getAllMatches(empty).map(ViatraTupleLike::new);
-        }
-
-        @Override
-        public Stream<TupleLike> allResults(Tuple parameters) {
-                return backend.getAllMatches(toParametersArray(parameters)).map(ViatraTupleLike::new);
-        }
-
-        @Override
-        public int countResults() {
-                return backend.countMatches(empty);
-        }
-
-        @Override
-        public int countResults(Tuple parameters) {
-                return backend.countMatches(toParametersArray(parameters));
-        }
-
-        private Object[] toParametersArray(Tuple tuple) {
-                int size = tuple.getSize();
-                var array = new Object[tuple.getSize()];
-                for (int i = 0; i < size; i++) {
-                        var value = tuple.get(i);
-                        if (value >= 0) {
-                                array[i] = Tuple.of(value);
-                        }
-                }
-                return array;
-        }
+    private Object[] toParametersArray(TupleLike tuple) {
+        int size = tuple.getSize();
+        var array = new Object[size];
+        for (int i = 0; i < size; i++) {
+            var value = tuple.get(i);
+            array[i] = Tuple.of(value);
+        }
+        return array;
+    }
 }
diff --git a/subprojects/store-query-viatra/src/test/java/tools/refinery/store/query/viatra/QueryTest.java b/subprojects/store-query-viatra/src/test/java/tools/refinery/store/query/viatra/QueryTest.java
index 54ae70c3..3dd517c4 100644
--- a/subprojects/store-query-viatra/src/test/java/tools/refinery/store/query/viatra/QueryTest.java
+++ b/subprojects/store-query-viatra/src/test/java/tools/refinery/store/query/viatra/QueryTest.java
@@ -16,8 +16,7 @@ import java.util.HashSet;
 import java.util.Set;
 import java.util.stream.Stream;
 
-import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.*;
 import static tools.refinery.store.query.literal.Literals.not;
 
 class QueryTest {
@@ -97,10 +96,14 @@ class QueryTest {
                 friendInterpretation.put(Tuple.of(1, 2), TruthValue.TRUE);
 
                 assertEquals(0, predicateResultSet.countResults());
+                assertFalse(predicateResultSet.hasResult(Tuple.of(0, 1)));
+                assertFalse(predicateResultSet.hasResult(Tuple.of(0, 2)));
 
                 queryEngine.flushChanges();
                 assertEquals(3, predicateResultSet.countResults());
                 compareMatchSets(predicateResultSet.allResults(), Set.of(Tuple.of(0, 1), Tuple.of(1, 0), Tuple.of(1, 2)));
+                assertTrue(predicateResultSet.hasResult(Tuple.of(0, 1)));
+                assertFalse(predicateResultSet.hasResult(Tuple.of(0, 2)));
         }
 
         @Test
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/EmptyResultSet.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/EmptyResultSet.java
index a01a5a2f..0c2e07d6 100644
--- a/subprojects/store-query/src/main/java/tools/refinery/store/query/EmptyResultSet.java
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/EmptyResultSet.java
@@ -1,49 +1,22 @@
 package tools.refinery.store.query;
 
-import tools.refinery.store.tuple.Tuple;
 import tools.refinery.store.tuple.TupleLike;
 
-import java.util.Optional;
 import java.util.stream.Stream;
 
 public class EmptyResultSet implements ResultSet {
         @Override
-        public boolean hasResult() {
+        public boolean hasResult(TupleLike parameters) {
                 return false;
         }
 
         @Override
-        public boolean hasResult(Tuple parameters) {
-                return false;
-        }
-
-        @Override
-        public Optional<TupleLike> oneResult() {
-                return Optional.empty();
-        }
-
-        @Override
-        public Optional<TupleLike> oneResult(Tuple parameters) {
-                return Optional.empty();
-        }
-
-        @Override
         public Stream<TupleLike> allResults() {
                 return Stream.of();
         }
 
         @Override
-        public Stream<TupleLike> allResults(Tuple parameters) {
-                return Stream.of();
-        }
-
-        @Override
         public int countResults() {
                 return 0;
         }
-
-        @Override
-        public int countResults(Tuple parameters) {
-                return 0;
-        }
 }
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/ResultSet.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/ResultSet.java
index 3542e252..407cf075 100644
--- a/subprojects/store-query/src/main/java/tools/refinery/store/query/ResultSet.java
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/ResultSet.java
@@ -1,25 +1,17 @@
 package tools.refinery.store.query;
 
-import tools.refinery.store.tuple.Tuple;
 import tools.refinery.store.tuple.TupleLike;
 
-import java.util.Optional;
 import java.util.stream.Stream;
 
 public interface ResultSet {
-        boolean hasResult();
+        default boolean hasResult() {
+                return countResults() > 0;
+        }
 
-        boolean hasResult(Tuple parameters);
-
-        Optional<TupleLike> oneResult();
-
-        Optional<TupleLike> oneResult(Tuple parameters);
+        boolean hasResult(TupleLike parameters);
 
         Stream<TupleLike> allResults();
 
-        Stream<TupleLike> allResults(Tuple parameters);
-
         int countResults();
-
-        int countResults(Tuple parameters);
 }
diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/Seed.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/seed/Seed.java
index 779eadbe..042c2636 100644
--- a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/Seed.java
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/seed/Seed.java
@@ -6,6 +6,8 @@ import tools.refinery.store.tuple.Tuple;
 public interface Seed<T> {
         int arity();
 
+        T getReducedValue();
+
         T get(Tuple key);
 
         Cursor<Tuple, T> getCursor(T defaultValue, int nodeCount);