refactor: move viatra into a separate subproject

17 files changed, 1691 insertions, 0 deletions

diff --git a/subprojects/store-query-viatra/build.gradle b/subprojects/store-query-viatra/build.gradle
new file mode 100644
index 00000000..32a23fe7
--- /dev/null
+++ b/subprojects/store-query-viatra/build.gradle
@@ -0,0 +1,16 @@
+plugins {
+        id 'refinery-java-library'
+}
+
+configurations.testRuntimeClasspath {
+        // VIATRA requires log4j 1.x, but we use log4j-over-slf4j instead
+        exclude group: 'log4j', module: 'log4j'
+}
+
+dependencies {
+        implementation libs.ecore
+        implementation libs.viatra
+        api project(':refinery-store')
+        testImplementation libs.slf4j.simple
+        testImplementation libs.slf4j.log4j
+}
diff --git a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/ViatraQueryableModelStore.java b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/ViatraQueryableModelStore.java
new file mode 100644
index 00000000..5a02ca08
--- /dev/null
+++ b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/ViatraQueryableModelStore.java
@@ -0,0 +1,132 @@
+package tools.refinery.store.query.viatra;
+
+import org.eclipse.viatra.query.runtime.api.GenericQuerySpecification;
+import tools.refinery.store.model.ModelDiffCursor;
+import tools.refinery.store.model.ModelStore;
+import tools.refinery.store.model.ModelStoreImpl;
+import tools.refinery.store.model.representation.DataRepresentation;
+import tools.refinery.store.query.QueryableModel;
+import tools.refinery.store.query.QueryableModelStore;
+import tools.refinery.store.query.building.*;
+import tools.refinery.store.query.viatra.internal.ViatraQueryableModel;
+import tools.refinery.store.query.viatra.internal.pquery.DNF2PQuery;
+import tools.refinery.store.query.viatra.internal.RawPatternMatcher;
+import tools.refinery.store.query.viatra.internal.pquery.SimplePQuery;
+import tools.refinery.store.query.view.RelationView;
+
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Set;
+
+public class ViatraQueryableModelStore implements QueryableModelStore {
+        protected final ModelStore store;
+        protected final Set<RelationView<?>> relationViews;
+        protected final Map<DNFPredicate, GenericQuerySpecification<RawPatternMatcher>> predicates;
+
+        public ViatraQueryableModelStore(ModelStore store, Set<RelationView<?>> relationViews,
+                                                                         Set<DNFPredicate> predicates) {
+                this.store = store;
+                validateViews(store.getDataRepresentations(), relationViews);
+                this.relationViews = Collections.unmodifiableSet(relationViews);
+                validatePredicates(relationViews, predicates);
+                this.predicates = initPredicates(predicates);
+        }
+
+        public ViatraQueryableModelStore(Set<DataRepresentation<?, ?>> dataRepresentations,
+                                                                         Set<RelationView<?>> relationViews, Set<DNFPredicate> predicates) {
+                this(new ModelStoreImpl(dataRepresentations), relationViews, predicates);
+        }
+
+        private void validateViews(Set<DataRepresentation<?, ?>> dataRepresentations, Set<RelationView<?>> relationViews) {
+                for (RelationView<?> relationView : relationViews) {
+                        if (!dataRepresentations.contains(relationView.getRepresentation())) {
+                                throw new IllegalArgumentException(
+                                                DataRepresentation.class.getSimpleName() + " " + relationView.getStringID() + " added to "
+                                                                + QueryableModelStore.class.getSimpleName() + " without a referred representation.");
+                        }
+                }
+        }
+
+        private void validatePredicates(Set<RelationView<?>> relationViews, Set<DNFPredicate> predicates) {
+                for (DNFPredicate dnfPredicate : predicates) {
+                        for (DNFAnd clause : dnfPredicate.getClauses()) {
+                                for (DNFAtom atom : clause.getConstraints()) {
+                                        if (atom instanceof RelationAtom relationAtom) {
+                                                validateRelationAtom(relationViews, dnfPredicate, relationAtom);
+                                        } else if (atom instanceof PredicateAtom predicateAtom) {
+                                                validatePredicateAtom(predicates, dnfPredicate, predicateAtom);
+                                        }
+                                }
+                        }
+                }
+        }
+
+        private void validateRelationAtom(Set<RelationView<?>> relationViews, DNFPredicate dnfPredicate,
+                                                                          RelationAtom relationAtom) {
+                if (!relationViews.contains(relationAtom.view())) {
+                        throw new IllegalArgumentException(DNFPredicate.class.getSimpleName() + " "
+                                        + dnfPredicate.getUniqueName() + " contains reference to a view of "
+                                        + relationAtom.view().getRepresentation().getName()
+                                        + " that is not in the model.");
+                }
+        }
+
+        private void validatePredicateAtom(Set<DNFPredicate> predicates, DNFPredicate dnfPredicate,
+                                                                           PredicateAtom predicateAtom) {
+                if (!predicates.contains(predicateAtom.getReferred())) {
+                        throw new IllegalArgumentException(
+                                        DNFPredicate.class.getSimpleName() + " " + dnfPredicate.getUniqueName()
+                                                        + " contains reference to a predicate "
+                                                        + predicateAtom.getReferred().getName()
+                                                        + "that is not in the model.");
+                }
+        }
+
+        private Map<DNFPredicate, GenericQuerySpecification<RawPatternMatcher>> initPredicates(Set<DNFPredicate> predicates) {
+                Map<DNFPredicate, GenericQuerySpecification<RawPatternMatcher>> result = new HashMap<>();
+                Map<DNFPredicate, SimplePQuery> dnf2PQueryMap = new HashMap<>();
+                for (DNFPredicate dnfPredicate : predicates) {
+                        GenericQuerySpecification<RawPatternMatcher> query =
+                                        DNF2PQuery.translate(dnfPredicate, dnf2PQueryMap).build();
+                        result.put(dnfPredicate, query);
+                }
+
+                return result;
+        }
+
+        @Override
+        public Set<DataRepresentation<?, ?>> getDataRepresentations() {
+                return store.getDataRepresentations();
+        }
+
+        @Override
+        public Set<RelationView<?>> getViews() {
+                return this.relationViews;
+        }
+
+        @Override
+        public Set<DNFPredicate> getPredicates() {
+                return predicates.keySet();
+        }
+
+        @Override
+        public QueryableModel createModel() {
+                return new ViatraQueryableModel(this, this.store.createModel(), predicates);
+        }
+
+        @Override
+        public QueryableModel createModel(long state) {
+                return new ViatraQueryableModel(this, this.store.createModel(state), predicates);
+        }
+
+        @Override
+        public synchronized Set<Long> getStates() {
+                return this.store.getStates();
+        }
+
+        @Override
+        public synchronized ModelDiffCursor getDiffCursor(long from, long to) {
+                return this.store.getDiffCursor(from, to);
+        }
+}
diff --git a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/RawPatternMatcher.java b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/RawPatternMatcher.java
new file mode 100644
index 00000000..be348a63
--- /dev/null
+++ b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/RawPatternMatcher.java
@@ -0,0 +1,51 @@
+package tools.refinery.store.query.viatra.internal;
+
+import org.eclipse.viatra.query.runtime.api.GenericPatternMatcher;
+import org.eclipse.viatra.query.runtime.api.GenericQuerySpecification;
+import org.eclipse.viatra.query.runtime.matchers.tuple.AbstractTuple;
+import org.eclipse.viatra.query.runtime.matchers.tuple.Tuple;
+
+import java.util.Optional;
+import java.util.stream.Stream;
+
+public class RawPatternMatcher extends GenericPatternMatcher {
+        protected final Object[] empty;
+
+        public RawPatternMatcher(GenericQuerySpecification<? extends GenericPatternMatcher> specification) {
+                super(specification);
+                this.empty = new Object[specification.getParameterNames().size()];
+        }
+
+        public boolean hasResult() {
+                return hasResult(empty);
+        }
+
+        public boolean hasResult(Object[] parameters) {
+                return this.backend.hasMatch(parameters);
+        }
+
+        public Optional<Object[]> oneResult() {
+                return oneResult(empty);
+        }
+
+        public Optional<Object[]> oneResult(Object[] parameters) {
+                Optional<Tuple> tuple = this.backend.getOneArbitraryMatch(parameters);
+                return tuple.map(AbstractTuple::getElements);
+        }
+
+        public Stream<Object[]> allResults() {
+                return allResults(empty);
+        }
+
+        public Stream<Object[]> allResults(Object[] parameters) {
+                return this.backend.getAllMatches(parameters).map(AbstractTuple::getElements);
+        }
+
+        public int countResults() {
+                return countResults(empty);
+        }
+
+        public int countResults(Object[] parameters) {
+                return backend.countMatches(parameters);
+        }
+}
diff --git a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/RelationalScope.java b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/RelationalScope.java
new file mode 100644
index 00000000..8dfa22e0
--- /dev/null
+++ b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/RelationalScope.java
@@ -0,0 +1,43 @@
+package tools.refinery.store.query.viatra.internal;
+
+import org.apache.log4j.Logger;
+import org.eclipse.viatra.query.runtime.api.ViatraQueryEngine;
+import org.eclipse.viatra.query.runtime.api.scope.IEngineContext;
+import org.eclipse.viatra.query.runtime.api.scope.IIndexingErrorListener;
+import org.eclipse.viatra.query.runtime.api.scope.QueryScope;
+import tools.refinery.store.model.Model;
+import tools.refinery.store.model.Tuple;
+import tools.refinery.store.model.representation.Relation;
+import tools.refinery.store.query.viatra.internal.context.RelationalEngineContext;
+import tools.refinery.store.query.viatra.internal.viewupdate.ModelUpdateListener;
+import tools.refinery.store.query.view.RelationView;
+
+import java.util.Set;
+
+public class RelationalScope extends QueryScope {
+        private final Model model;
+        private final ModelUpdateListener updateListener;
+
+        public RelationalScope(Model model, Set<RelationView<?>> relationViews) {
+                this.model = model;
+                this.updateListener = new ModelUpdateListener(relationViews);
+        }
+
+        public <D> void processUpdate(Relation<D> relation, Tuple key, D oldValue, D newValue) {
+                updateListener.addUpdate(relation, key, oldValue, newValue);
+        }
+
+        public boolean hasChanges() {
+                return updateListener.hasChanges();
+        }
+
+        public void flush() {
+                updateListener.flush();
+        }
+
+        @Override
+        protected IEngineContext createEngineContext(ViatraQueryEngine engine, IIndexingErrorListener errorListener,
+                                                                                                 Logger logger) {
+                return new RelationalEngineContext(model, updateListener);
+        }
+}
diff --git a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/ViatraQueryableModel.java b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/ViatraQueryableModel.java
new file mode 100644
index 00000000..3803702d
--- /dev/null
+++ b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/ViatraQueryableModel.java
@@ -0,0 +1,219 @@
+package tools.refinery.store.query.viatra.internal;
+
+import org.eclipse.viatra.query.runtime.api.AdvancedViatraQueryEngine;
+import org.eclipse.viatra.query.runtime.api.GenericQueryGroup;
+import org.eclipse.viatra.query.runtime.api.GenericQuerySpecification;
+import org.eclipse.viatra.query.runtime.api.IQueryGroup;
+import tools.refinery.store.map.Cursor;
+import tools.refinery.store.map.DiffCursor;
+import tools.refinery.store.model.Model;
+import tools.refinery.store.model.ModelDiffCursor;
+import tools.refinery.store.model.Tuple;
+import tools.refinery.store.model.representation.DataRepresentation;
+import tools.refinery.store.model.representation.Relation;
+import tools.refinery.store.query.QueryableModel;
+import tools.refinery.store.query.QueryableModelStore;
+import tools.refinery.store.query.building.DNFPredicate;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Optional;
+import java.util.Set;
+import java.util.stream.Stream;
+
+public class ViatraQueryableModel implements QueryableModel {
+        protected final QueryableModelStore store;
+
+        protected final Model model;
+
+        protected final Map<DNFPredicate, GenericQuerySpecification<RawPatternMatcher>> predicates2PQuery;
+
+        protected RelationalScope scope;
+
+        protected AdvancedViatraQueryEngine engine;
+
+        protected Map<DNFPredicate, RawPatternMatcher> predicate2Matcher;
+
+        public ViatraQueryableModel(QueryableModelStore store, Model model,
+                                                                Map<DNFPredicate, GenericQuerySpecification<RawPatternMatcher>> predicates2PQuery) {
+                this.store = store;
+                this.model = model;
+                this.predicates2PQuery = predicates2PQuery;
+                initEngine();
+        }
+
+        private void initEngine() {
+                this.scope = new RelationalScope(this.model, this.store.getViews());
+                this.engine = AdvancedViatraQueryEngine.createUnmanagedEngine(this.scope);
+                this.predicate2Matcher = initMatchers(this.engine, this.predicates2PQuery);
+        }
+
+        private Map<DNFPredicate, RawPatternMatcher> initMatchers(
+                        AdvancedViatraQueryEngine engine,
+                        Map<DNFPredicate, GenericQuerySpecification<RawPatternMatcher>> predicates2pQuery) {
+                // 1. prepare group
+                IQueryGroup queryGroup = GenericQueryGroup.of(Set.copyOf(predicates2pQuery.values()));
+                engine.prepareGroup(queryGroup, null);
+
+                // 2. then get all matchers
+                Map<DNFPredicate, RawPatternMatcher> result = new HashMap<>();
+                for (var entry : predicates2pQuery.entrySet()) {
+                        var matcher = engine.getMatcher(entry.getValue());
+                        result.put(entry.getKey(), matcher);
+                }
+                return result;
+        }
+
+        @Override
+        public Set<DataRepresentation<?, ?>> getDataRepresentations() {
+                return model.getDataRepresentations();
+        }
+
+        @Override
+        public Set<DNFPredicate> getPredicates() {
+                return store.getPredicates();
+        }
+
+        @Override
+        public <K, V> V get(DataRepresentation<K, V> representation, K key) {
+                return model.get(representation, key);
+        }
+
+        @Override
+        public <K, V> Cursor<K, V> getAll(DataRepresentation<K, V> representation) {
+                return model.getAll(representation);
+        }
+
+        @SuppressWarnings("unchecked")
+        @Override
+        public <K, V> V put(DataRepresentation<K, V> representation, K key, V value) {
+                V oldValue = this.model.put(representation, key, value);
+                if (representation instanceof Relation<?> relation) {
+                        this.scope.processUpdate((Relation<V>) relation, (Tuple) key, oldValue, value);
+                }
+                return oldValue;
+        }
+
+        @Override
+        public <K, V> void putAll(DataRepresentation<K, V> representation, Cursor<K, V> cursor) {
+                if (representation instanceof Relation<?>) {
+                        //noinspection RedundantSuppression
+                        @SuppressWarnings("unchecked")
+                        Relation<V> relation = (Relation<V>) representation;
+                        while (cursor.move()) {
+                                Tuple key = (Tuple) cursor.getKey();
+                                V newValue = cursor.getValue();
+                                V oldValue = this.model.put(relation, key, newValue);
+                                this.scope.processUpdate(relation, key, oldValue, newValue);
+                        }
+                } else {
+                        this.model.putAll(representation, cursor);
+                }
+        }
+
+        @Override
+        public <K, V> long getSize(DataRepresentation<K, V> representation) {
+                return model.getSize(representation);
+        }
+
+        protected RawPatternMatcher getMatcher(DNFPredicate predicate) {
+                var result = this.predicate2Matcher.get(predicate);
+                if (result == null) {
+                        throw new IllegalArgumentException("Model does not contain predicate %s".formatted(predicate.getName()));
+                } else
+                        return result;
+        }
+
+        protected void validateParameters(DNFPredicate predicate, Object[] parameters) {
+                int predicateArity = predicate.getVariables().size();
+                int parameterArity = parameters.length;
+                if (parameterArity != predicateArity) {
+                        throw new IllegalArgumentException(
+                                        "Predicate %s with %d arity called with different number of parameters (%d)"
+                                                        .formatted(predicate.getName(), predicateArity, parameterArity));
+                }
+        }
+
+        @Override
+        public boolean hasResult(DNFPredicate predicate) {
+                return getMatcher(predicate).hasResult();
+        }
+
+        @Override
+        public boolean hasResult(DNFPredicate predicate, Object[] parameters) {
+                validateParameters(predicate, parameters);
+                return getMatcher(predicate).hasResult(parameters);
+        }
+
+        @Override
+        public Optional<Object[]> oneResult(DNFPredicate predicate) {
+                return getMatcher(predicate).oneResult();
+        }
+
+        @Override
+        public Optional<Object[]> oneResult(DNFPredicate predicate, Object[] parameters) {
+                validateParameters(predicate, parameters);
+                return getMatcher(predicate).oneResult(parameters);
+        }
+
+        @Override
+        public Stream<Object[]> allResults(DNFPredicate predicate) {
+                return getMatcher(predicate).allResults();
+        }
+
+        @Override
+        public Stream<Object[]> allResults(DNFPredicate predicate, Object[] parameters) {
+                validateParameters(predicate, parameters);
+                return getMatcher(predicate).allResults(parameters);
+        }
+
+        @Override
+        public int countResults(DNFPredicate predicate) {
+                return getMatcher(predicate).countResults();
+        }
+
+        @Override
+        public int countResults(DNFPredicate predicate, Object[] parameters) {
+                validateParameters(predicate, parameters);
+                return getMatcher(predicate).countResults(parameters);
+
+        }
+
+        @Override
+        public boolean hasChanges() {
+                return scope.hasChanges();
+        }
+
+        @Override
+        public void flushChanges() {
+                this.scope.flush();
+        }
+
+        @Override
+        public ModelDiffCursor getDiffCursor(long to) {
+                return model.getDiffCursor(to);
+        }
+
+        @Override
+        public long commit() {
+                return this.model.commit();
+        }
+
+        @Override
+        public void restore(long state) {
+                restoreWithDiffReplay(state);
+        }
+
+        private void restoreWithDiffReplay(long state) {
+                var modelDiffCursor = getDiffCursor(state);
+                for (DataRepresentation<?, ?> dataRepresentation : this.getDataRepresentations()) {
+                        restoreRepresentationWithDiffReplay(modelDiffCursor, dataRepresentation);
+                }
+        }
+
+        private <K, V> void restoreRepresentationWithDiffReplay(ModelDiffCursor modelDiffCursor,
+                                                                                                                        DataRepresentation<K, V> dataRepresentation) {
+                DiffCursor<K, V> diffCursor = modelDiffCursor.getCursor(dataRepresentation);
+                this.putAll(dataRepresentation, diffCursor);
+        }
+}
diff --git a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/context/DummyBaseIndexer.java b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/context/DummyBaseIndexer.java
new file mode 100644
index 00000000..4b311a64
--- /dev/null
+++ b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/context/DummyBaseIndexer.java
@@ -0,0 +1,58 @@
+package tools.refinery.store.query.viatra.internal.context;
+
+import org.eclipse.viatra.query.runtime.api.scope.IBaseIndex;
+import org.eclipse.viatra.query.runtime.api.scope.IIndexingErrorListener;
+import org.eclipse.viatra.query.runtime.api.scope.IInstanceObserver;
+import org.eclipse.viatra.query.runtime.api.scope.ViatraBaseIndexChangeListener;
+
+import java.lang.reflect.InvocationTargetException;
+import java.util.concurrent.Callable;
+
+/**
+ * Copied from <code>org.eclipse.viatra.query.runtime.tabular.TabularEngineContext</code>
+ */
+public class DummyBaseIndexer implements IBaseIndex {
+        @Override
+        public <V> V coalesceTraversals(Callable<V> callable) throws InvocationTargetException {
+                try {
+                        return callable.call();
+                } catch (Exception e) {
+                        throw new InvocationTargetException(e);
+                }
+        }
+
+        @Override
+        public void addBaseIndexChangeListener(ViatraBaseIndexChangeListener listener) {
+                // no notification support
+        }
+
+        @Override
+        public void removeBaseIndexChangeListener(ViatraBaseIndexChangeListener listener) {
+                // no notification support
+        }
+
+        @Override
+        public void resampleDerivedFeatures() {
+                throw new UnsupportedOperationException();
+        }
+
+        @Override
+        public boolean addIndexingErrorListener(IIndexingErrorListener listener) {
+                return true;
+        }
+
+        @Override
+        public boolean removeIndexingErrorListener(IIndexingErrorListener listener) {
+                return true;
+        }
+
+        @Override
+        public boolean addInstanceObserver(IInstanceObserver observer, Object observedObject) {
+                return true;
+        }
+
+        @Override
+        public boolean removeInstanceObserver(IInstanceObserver observer, Object observedObject) {
+                return true;
+        }
+}
diff --git a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/context/RelationalEngineContext.java b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/context/RelationalEngineContext.java
new file mode 100644
index 00000000..882734cb
--- /dev/null
+++ b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/context/RelationalEngineContext.java
@@ -0,0 +1,33 @@
+package tools.refinery.store.query.viatra.internal.context;
+
+import org.eclipse.viatra.query.runtime.api.scope.IBaseIndex;
+import org.eclipse.viatra.query.runtime.api.scope.IEngineContext;
+import org.eclipse.viatra.query.runtime.matchers.context.IQueryRuntimeContext;
+
+import tools.refinery.store.model.Model;
+import tools.refinery.store.query.viatra.internal.viewupdate.ModelUpdateListener;
+
+public class RelationalEngineContext implements IEngineContext {
+        private final IBaseIndex baseIndex = new DummyBaseIndexer();
+        private final RelationalRuntimeContext runtimeContext;
+
+        public RelationalEngineContext(Model model, ModelUpdateListener updateListener) {
+                runtimeContext = new RelationalRuntimeContext(model, updateListener);
+        }
+
+        @Override
+        public IBaseIndex getBaseIndex() {
+                return this.baseIndex;
+        }
+
+        @Override
+        public void dispose() {
+                // Nothing to dispose, because lifecycle is not controlled by the engine.
+        }
+
+        @Override
+        public IQueryRuntimeContext getQueryRuntimeContext() {
+                return runtimeContext;
+        }
+
+}
diff --git a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/context/RelationalQueryMetaContext.java b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/context/RelationalQueryMetaContext.java
new file mode 100644
index 00000000..64c23c61
--- /dev/null
+++ b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/context/RelationalQueryMetaContext.java
@@ -0,0 +1,44 @@
+package tools.refinery.store.query.viatra.internal.context;
+
+import org.eclipse.viatra.query.runtime.matchers.context.AbstractQueryMetaContext;
+import org.eclipse.viatra.query.runtime.matchers.context.IInputKey;
+import org.eclipse.viatra.query.runtime.matchers.context.InputKeyImplication;
+import tools.refinery.store.query.view.RelationView;
+
+import java.util.*;
+
+/**
+ * The meta context information for String scopes.
+ */
+public class RelationalQueryMetaContext extends AbstractQueryMetaContext {
+        @Override
+        public boolean isEnumerable(IInputKey key) {
+                ensureValidKey(key);
+                return key.isEnumerable();
+        }
+
+        @Override
+        public boolean isStateless(IInputKey key) {
+                ensureValidKey(key);
+                return true;
+        }
+
+        @Override
+        public Collection<InputKeyImplication> getImplications(IInputKey implyingKey) {
+                ensureValidKey(implyingKey);
+                return Set.of();
+        }
+
+        @Override
+        public Map<Set<Integer>, Set<Integer>> getFunctionalDependencies(IInputKey key) {
+                ensureValidKey(key);
+                return Map.of();
+        }
+
+        public void ensureValidKey(IInputKey key) {
+                if (key instanceof RelationView<?>) {
+                        return;
+                }
+                throw new IllegalArgumentException("The input key %s is not a valid input key.".formatted(key));
+        }
+}
diff --git a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/context/RelationalRuntimeContext.java b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/context/RelationalRuntimeContext.java
new file mode 100644
index 00000000..0bd1b807
--- /dev/null
+++ b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/context/RelationalRuntimeContext.java
@@ -0,0 +1,172 @@
+package tools.refinery.store.query.viatra.internal.context;
+
+import org.eclipse.viatra.query.runtime.matchers.context.*;
+import org.eclipse.viatra.query.runtime.matchers.tuple.ITuple;
+import org.eclipse.viatra.query.runtime.matchers.tuple.Tuple;
+import org.eclipse.viatra.query.runtime.matchers.tuple.TupleMask;
+import org.eclipse.viatra.query.runtime.matchers.tuple.Tuples;
+import org.eclipse.viatra.query.runtime.matchers.util.Accuracy;
+import tools.refinery.store.model.Model;
+import tools.refinery.store.query.viatra.internal.viewupdate.ModelUpdateListener;
+import tools.refinery.store.query.view.RelationView;
+
+import java.lang.reflect.InvocationTargetException;
+import java.util.Iterator;
+import java.util.Optional;
+import java.util.concurrent.Callable;
+
+import static tools.refinery.store.util.CollectionsUtil.filter;
+import static tools.refinery.store.util.CollectionsUtil.map;
+
+public class RelationalRuntimeContext implements IQueryRuntimeContext {
+        private final RelationalQueryMetaContext metaContext = new RelationalQueryMetaContext();
+
+        private final ModelUpdateListener modelUpdateListener;
+
+        private final Model model;
+
+        public RelationalRuntimeContext(Model model, ModelUpdateListener relationUpdateListener) {
+                this.model = model;
+                this.modelUpdateListener = relationUpdateListener;
+        }
+
+        @Override
+        public IQueryMetaContext getMetaContext() {
+                return metaContext;
+        }
+
+        @Override
+        public <V> V coalesceTraversals(Callable<V> callable) throws InvocationTargetException {
+                try {
+                        return callable.call();
+                } catch (Exception e) {
+                        throw new InvocationTargetException(e);
+                }
+        }
+
+        @Override
+        public boolean isCoalescing() {
+                return true;
+        }
+
+        @Override
+        public boolean isIndexed(IInputKey key, IndexingService service) {
+                if (key instanceof RelationView<?> relationalKey) {
+                        return this.modelUpdateListener.containsRelationalView(relationalKey);
+                } else {
+                        return false;
+                }
+        }
+
+        @Override
+        public void ensureIndexed(IInputKey key, IndexingService service) {
+                if (!isIndexed(key, service)) {
+                        throw new IllegalStateException("Engine tries to index a new key " + key);
+                }
+        }
+
+        @SuppressWarnings("squid:S1452")
+        RelationView<?> checkKey(IInputKey key) {
+                if (key instanceof RelationView<?> relationViewKey) {
+                        if (modelUpdateListener.containsRelationalView(relationViewKey)) {
+                                return relationViewKey;
+                        } else {
+                                throw new IllegalStateException("Query is asking for non-indexed key");
+                        }
+                } else {
+                        throw new IllegalStateException("Query is asking for non-relational key");
+                }
+        }
+
+        @Override
+        public int countTuples(IInputKey key, TupleMask seedMask, ITuple seed) {
+                RelationView<?> relationalViewKey = checkKey(key);
+                Iterable<Object[]> allObjects = relationalViewKey.getAll(model);
+                Iterable<Object[]> filteredBySeed = filter(allObjects, objectArray -> isMatching(objectArray, seedMask, seed));
+                Iterator<Object[]> iterator = filteredBySeed.iterator();
+                int result = 0;
+                while (iterator.hasNext()) {
+                        iterator.next();
+                        result++;
+                }
+                return result;
+        }
+
+        @Override
+        public Optional<Long> estimateCardinality(IInputKey key, TupleMask groupMask, Accuracy requiredAccuracy) {
+                return Optional.empty();
+        }
+
+        @Override
+        public Iterable<Tuple> enumerateTuples(IInputKey key, TupleMask seedMask, ITuple seed) {
+                RelationView<?> relationalViewKey = checkKey(key);
+                Iterable<Object[]> allObjects = relationalViewKey.getAll(model);
+                Iterable<Object[]> filteredBySeed = filter(allObjects, objectArray -> isMatching(objectArray, seedMask, seed));
+                return map(filteredBySeed, Tuples::flatTupleOf);
+        }
+
+        private boolean isMatching(Object[] tuple, TupleMask seedMask, ITuple seed) {
+                for (int i = 0; i < seedMask.indices.length; i++) {
+                        final Object seedElement = seed.get(i);
+                        final Object tupleElement = tuple[seedMask.indices[i]];
+                        if (!tupleElement.equals(seedElement)) {
+                                return false;
+                        }
+                }
+                return true;
+        }
+
+        @Override
+        public Iterable<? extends Object> enumerateValues(IInputKey key, TupleMask seedMask, ITuple seed) {
+                return enumerateTuples(key, seedMask, seed);
+        }
+
+        @Override
+        public boolean containsTuple(IInputKey key, ITuple seed) {
+                RelationView<?> relationalViewKey = checkKey(key);
+                return relationalViewKey.get(model, seed.getElements());
+        }
+
+        @Override
+        public void addUpdateListener(IInputKey key, Tuple seed, IQueryRuntimeContextListener listener) {
+                RelationView<?> relationalKey = checkKey(key);
+                this.modelUpdateListener.addListener(relationalKey, seed, listener);
+
+        }
+
+        @Override
+        public void removeUpdateListener(IInputKey key, Tuple seed, IQueryRuntimeContextListener listener) {
+                RelationView<?> relationalKey = checkKey(key);
+                this.modelUpdateListener.removeListener(relationalKey, seed, listener);
+        }
+
+        @Override
+        public Object wrapElement(Object externalElement) {
+                return externalElement;
+        }
+
+        @Override
+        public Object unwrapElement(Object internalElement) {
+                return internalElement;
+        }
+
+        @Override
+        public Tuple wrapTuple(Tuple externalElements) {
+                return externalElements;
+        }
+
+        @Override
+        public Tuple unwrapTuple(Tuple internalElements) {
+                return internalElements;
+        }
+
+        @Override
+        public void ensureWildcardIndexing(IndexingService service) {
+                throw new UnsupportedOperationException();
+        }
+
+        @Override
+        public void executeAfterTraversal(Runnable runnable) throws InvocationTargetException {
+                runnable.run();
+        }
+}
diff --git a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/pquery/DNF2PQuery.java b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/pquery/DNF2PQuery.java
new file mode 100644
index 00000000..c093be47
--- /dev/null
+++ b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/pquery/DNF2PQuery.java
@@ -0,0 +1,114 @@
+package tools.refinery.store.query.viatra.internal.pquery;
+
+import org.eclipse.viatra.query.runtime.matchers.psystem.PBody;
+import org.eclipse.viatra.query.runtime.matchers.psystem.PVariable;
+import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.Equality;
+import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.ExportedParameter;
+import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.Inequality;
+import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.NegativePatternCall;
+import org.eclipse.viatra.query.runtime.matchers.psystem.basicenumerables.BinaryTransitiveClosure;
+import org.eclipse.viatra.query.runtime.matchers.psystem.basicenumerables.PositivePatternCall;
+import org.eclipse.viatra.query.runtime.matchers.psystem.basicenumerables.TypeConstraint;
+import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PParameter;
+import org.eclipse.viatra.query.runtime.matchers.tuple.Tuples;
+import tools.refinery.store.query.building.*;
+
+import java.util.*;
+
+public class DNF2PQuery {
+        private DNF2PQuery() {
+                throw new IllegalStateException("This is a static utility class and should not be instantiated directly");
+        }
+
+        public static SimplePQuery translate(DNFPredicate predicate, Map<DNFPredicate, SimplePQuery> dnf2PQueryMap) {
+                SimplePQuery query = dnf2PQueryMap.get(predicate);
+                if (query != null) {
+                        return query;
+                }
+                query = new SimplePQuery(predicate.getName());
+                Map<Variable, PParameter> parameters = new HashMap<>();
+
+                predicate.getVariables().forEach(variable -> parameters.put(variable, new PParameter(variable.getName())));
+                List<PParameter> parameterList = new ArrayList<>();
+                for (var param : predicate.getVariables()) {
+                        parameterList.add(parameters.get(param));
+                }
+                query.setParameters(parameterList);
+                for (DNFAnd clause : predicate.getClauses()) {
+                        PBody body = new PBody(query);
+                        List<ExportedParameter> symbolicParameters = new ArrayList<>();
+                        for (var param : predicate.getVariables()) {
+                                PVariable pVar = body.getOrCreateVariableByName(param.getName());
+                                symbolicParameters.add(new ExportedParameter(body, pVar, parameters.get(param)));
+                        }
+                        body.setSymbolicParameters(symbolicParameters);
+                        query.addBody(body);
+                        for (DNFAtom constraint : clause.getConstraints()) {
+                                translateDNFAtom(constraint, body, dnf2PQueryMap);
+                        }
+                }
+                dnf2PQueryMap.put(predicate, query);
+                return query;
+        }
+
+        private static void translateDNFAtom(DNFAtom constraint, PBody body,
+                                                                                 Map<DNFPredicate, SimplePQuery> dnf2PQueryMap) {
+                if (constraint instanceof EquivalenceAtom equivalence) {
+                        translateEquivalenceAtom(equivalence, body);
+                }
+                if (constraint instanceof RelationAtom relation) {
+                        translateRelationAtom(relation, body);
+                }
+                if (constraint instanceof PredicateAtom predicate) {
+                        translatePredicateAtom(predicate, body, dnf2PQueryMap);
+                }
+        }
+
+        private static void translateEquivalenceAtom(EquivalenceAtom equivalence, PBody body) {
+                PVariable varSource = body.getOrCreateVariableByName(equivalence.getLeft().getName());
+                PVariable varTarget = body.getOrCreateVariableByName(equivalence.getRight().getName());
+                if (equivalence.isPositive())
+                        new Equality(body, varSource, varTarget);
+                else
+                        new Inequality(body, varSource, varTarget);
+        }
+
+        private static void translateRelationAtom(RelationAtom relation, PBody body) {
+                if (relation.substitution().size() != relation.view().getArity()) {
+                        throw new IllegalArgumentException("Arity (%d) does not match parameter numbers (%d)".formatted(
+                                        relation.view().getArity(), relation.substitution().size()));
+                }
+                Object[] variables = new Object[relation.substitution().size()];
+                for (int i = 0; i < relation.substitution().size(); i++) {
+                        variables[i] = body.getOrCreateVariableByName(relation.substitution().get(i).getName());
+                }
+                new TypeConstraint(body, Tuples.flatTupleOf(variables), relation.view());
+        }
+
+        private static void translatePredicateAtom(PredicateAtom predicate, PBody body,
+                                                                                           Map<DNFPredicate, SimplePQuery> dnf2PQueryMap) {
+                Object[] variables = new Object[predicate.getSubstitution().size()];
+                for (int i = 0; i < predicate.getSubstitution().size(); i++) {
+                        variables[i] = body.getOrCreateVariableByName(predicate.getSubstitution().get(i).getName());
+                }
+                if (predicate.isPositive()) {
+                        if (predicate.isTransitive()) {
+                                if (predicate.getSubstitution().size() != 2) {
+                                        throw new IllegalArgumentException("Transitive Predicate Atoms must be binary.");
+                                }
+                                new BinaryTransitiveClosure(body, Tuples.flatTupleOf(variables),
+                                                DNF2PQuery.translate(predicate.getReferred(), dnf2PQueryMap));
+                        } else {
+                                new PositivePatternCall(body, Tuples.flatTupleOf(variables),
+                                                DNF2PQuery.translate(predicate.getReferred(), dnf2PQueryMap));
+                        }
+                } else {
+                        if (predicate.isTransitive()) {
+                                throw new InputMismatchException("Transitive Predicate Atoms cannot be negative.");
+                        } else {
+                                new NegativePatternCall(body, Tuples.flatTupleOf(variables),
+                                                DNF2PQuery.translate(predicate.getReferred(), dnf2PQueryMap));
+                        }
+                }
+        }
+}
diff --git a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/pquery/SimplePQuery.java b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/pquery/SimplePQuery.java
new file mode 100644
index 00000000..a367cbf2
--- /dev/null
+++ b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/pquery/SimplePQuery.java
@@ -0,0 +1,74 @@
+package tools.refinery.store.query.viatra.internal.pquery;
+
+import org.eclipse.viatra.query.runtime.api.GenericQuerySpecification;
+import org.eclipse.viatra.query.runtime.api.ViatraQueryEngine;
+import org.eclipse.viatra.query.runtime.api.scope.QueryScope;
+import org.eclipse.viatra.query.runtime.matchers.backend.QueryEvaluationHint;
+import org.eclipse.viatra.query.runtime.matchers.psystem.PBody;
+import org.eclipse.viatra.query.runtime.matchers.psystem.queries.BasePQuery;
+import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PParameter;
+import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PVisibility;
+import tools.refinery.store.query.viatra.internal.RawPatternMatcher;
+import tools.refinery.store.query.viatra.internal.RelationalScope;
+
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Set;
+
+public class SimplePQuery extends BasePQuery {
+        private final String fullyQualifiedName;
+        private List<PParameter> parameters;
+        private final LinkedHashSet<PBody> bodies = new LinkedHashSet<>();
+
+        public SimplePQuery(String name) {
+                super(PVisibility.PUBLIC);
+                fullyQualifiedName = name;
+                setEvaluationHints(new QueryEvaluationHint(null, QueryEvaluationHint.BackendRequirement.UNSPECIFIED));
+        }
+
+        @Override
+        public String getFullyQualifiedName() {
+                return fullyQualifiedName;
+        }
+
+        public void setParameters(List<PParameter> parameters) {
+                this.parameters = parameters;
+        }
+
+        @Override
+        public List<PParameter> getParameters() {
+                return parameters;
+        }
+
+        public void addBody(PBody body) {
+                bodies.add(body);
+        }
+
+        @Override
+        protected Set<PBody> doGetContainedBodies() {
+                return bodies;
+        }
+
+        public GenericQuerySpecification<RawPatternMatcher> build() {
+                return new GenericQuerySpecification<>(this) {
+                        @Override
+                        public Class<? extends QueryScope> getPreferredScopeClass() {
+                                return RelationalScope.class;
+                        }
+
+                        @Override
+                        protected RawPatternMatcher instantiate(ViatraQueryEngine engine) {
+                                RawPatternMatcher matcher = engine.getExistingMatcher(this);
+                                if (matcher == null) {
+                                        matcher = engine.getMatcher(this);
+                                }
+                                return matcher;
+                        }
+
+                        @Override
+                        public RawPatternMatcher instantiate() {
+                                return new RawPatternMatcher(this);
+                        }
+                };
+        }
+}
diff --git a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/viewupdate/ModelUpdateListener.java b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/viewupdate/ModelUpdateListener.java
new file mode 100644
index 00000000..25919888
--- /dev/null
+++ b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/viewupdate/ModelUpdateListener.java
@@ -0,0 +1,105 @@
+package tools.refinery.store.query.viatra.internal.viewupdate;
+
+import org.eclipse.viatra.query.runtime.matchers.context.IQueryRuntimeContextListener;
+import org.eclipse.viatra.query.runtime.matchers.tuple.ITuple;
+import tools.refinery.store.model.Tuple;
+import tools.refinery.store.model.representation.Relation;
+import tools.refinery.store.query.view.RelationView;
+
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+
+public class ModelUpdateListener {
+        /**
+         * Collections of Relations and their Views.
+         */
+        private final Map<Relation<?>, Set<RelationView<?>>> relation2View;
+
+        /**
+         * Collection of Views and their buffers.
+         */
+        private final Map<RelationView<?>, Set<ViewUpdateBuffer<?>>> view2Buffers;
+
+        public ModelUpdateListener(Set<RelationView<?>> relationViews) {
+                this.relation2View = new HashMap<>();
+                this.view2Buffers = new HashMap<>();
+
+                for (RelationView<?> relationView : relationViews) {
+                        registerView(relationView);
+                }
+        }
+
+        private void registerView(RelationView<?> view) {
+                Relation<?> relation = view.getRepresentation();
+
+                // 1. register views to relations, if necessary
+                var views = relation2View.computeIfAbsent(relation, x -> new HashSet<>());
+                views.add(view);
+
+                // 2. register notifier map to views, if necessary
+                view2Buffers.computeIfAbsent(view, x -> new HashSet<>());
+        }
+
+        public boolean containsRelationalView(RelationView<?> relationalKey) {
+                return view2Buffers.containsKey(relationalKey);
+        }
+
+        public <D> void addListener(RelationView<D> relationView, ITuple seed, IQueryRuntimeContextListener listener) {
+                if (view2Buffers.containsKey(relationView)) {
+                        ViewUpdateTranslator<D> updateListener = new ViewUpdateTranslator<>(relationView, seed, listener);
+                        ViewUpdateBuffer<D> updateBuffer = new ViewUpdateBuffer<>(updateListener);
+                        view2Buffers.get(relationView).add(updateBuffer);
+                } else
+                        throw new IllegalArgumentException();
+        }
+
+        public void removeListener(RelationView<?> relationView, ITuple seed, IQueryRuntimeContextListener listener) {
+                if (view2Buffers.containsKey(relationView)) {
+                        Set<ViewUpdateBuffer<?>> buffers = this.view2Buffers.get(relationView);
+                        for (var buffer : buffers) {
+                                if (buffer.getUpdateListener().equals(relationView, seed, listener)) {
+                                        // remove buffer and terminate immediately, or it will break iterator.
+                                        buffers.remove(buffer);
+                                        return;
+                                }
+                        }
+                } else {
+                        throw new IllegalArgumentException("Relation view is not registered for updates");
+                }
+        }
+
+        public <D> void addUpdate(Relation<D> relation, Tuple key, D oldValue, D newValue) {
+                var views = this.relation2View.get(relation);
+                if (views == null) {
+                        return;
+                }
+                for (var view : views) {
+                        var buffers = this.view2Buffers.get(view);
+                        for (var buffer : buffers) {
+                                @SuppressWarnings("unchecked")
+                                var typedBuffer = (ViewUpdateBuffer<D>) buffer;
+                                typedBuffer.addChange(key, oldValue, newValue);
+                        }
+                }
+        }
+
+        public boolean hasChanges() {
+                for (var bufferCollection : this.view2Buffers.values()) {
+                        for (ViewUpdateBuffer<?> buffer : bufferCollection) {
+                                if (buffer.hasChanges())
+                                        return true;
+                        }
+                }
+                return false;
+        }
+
+        public void flush() {
+                for (var bufferCollection : this.view2Buffers.values()) {
+                        for (ViewUpdateBuffer<?> buffer : bufferCollection) {
+                                buffer.flush();
+                        }
+                }
+        }
+}
diff --git a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/viewupdate/ViewUpdate.java b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/viewupdate/ViewUpdate.java
new file mode 100644
index 00000000..c727f046
--- /dev/null
+++ b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/viewupdate/ViewUpdate.java
@@ -0,0 +1,34 @@
+package tools.refinery.store.query.viatra.internal.viewupdate;
+
+import java.util.Arrays;
+import java.util.Objects;
+
+record ViewUpdate (Object[] tuple, boolean isInsertion) {
+
+        @Override
+        public int hashCode() {
+                final int prime = 31;
+                int result = 1;
+                result = prime * result + Arrays.deepHashCode(tuple);
+                result = prime * result + Objects.hash(isInsertion);
+                return result;
+        }
+
+        @Override
+        public boolean equals(Object obj) {
+                if (this == obj)
+                        return true;
+                if (obj == null)
+                        return false;
+                if (getClass() != obj.getClass())
+                        return false;
+                ViewUpdate other = (ViewUpdate) obj;
+                return isInsertion == other.isInsertion && Arrays.deepEquals(tuple, other.tuple);
+        }
+
+        @Override
+        public String toString() {
+                return "ViewUpdate [" + Arrays.toString(tuple) + "insertion= "+this.isInsertion+"]";
+        }
+
+}
diff --git a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/viewupdate/ViewUpdateBuffer.java b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/viewupdate/ViewUpdateBuffer.java
new file mode 100644
index 00000000..5a4243f2
--- /dev/null
+++ b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/viewupdate/ViewUpdateBuffer.java
@@ -0,0 +1,46 @@
+package tools.refinery.store.query.viatra.internal.viewupdate;
+
+import tools.refinery.store.model.Tuple;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+public class ViewUpdateBuffer<D> {
+        protected final ViewUpdateTranslator<D> updateListener;
+        protected final List<ViewUpdate> buffer = new ArrayList<>();
+
+        public ViewUpdateBuffer(ViewUpdateTranslator<D> updateListener) {
+                this.updateListener = updateListener;
+        }
+
+        public ViewUpdateTranslator<D> getUpdateListener() {
+                return updateListener;
+        }
+
+        public boolean hasChanges() {
+                return !buffer.isEmpty();
+        }
+
+        public void addChange(Tuple tuple, D oldValue, D newValue) {
+                if (oldValue != newValue) {
+                        Object[] oldTuple = updateListener.isMatching(tuple, oldValue);
+                        Object[] newTuple = updateListener.isMatching(tuple, newValue);
+                        if (!Arrays.equals(oldTuple, newTuple)) {
+                                if (oldTuple != null) {
+                                        buffer.add(new ViewUpdate(oldTuple, false));
+                                }
+                                if (newTuple != null) {
+                                        buffer.add(new ViewUpdate(newTuple, true));
+                                }
+                        }
+                }
+        }
+
+        public void flush() {
+                for (ViewUpdate viewChange : buffer) {
+                        updateListener.processChange(viewChange);
+                }
+                buffer.clear();
+        }
+}
diff --git a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/viewupdate/ViewUpdateTranslator.java b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/viewupdate/ViewUpdateTranslator.java
new file mode 100644
index 00000000..2f7f9a9c
--- /dev/null
+++ b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/viewupdate/ViewUpdateTranslator.java
@@ -0,0 +1,62 @@
+package tools.refinery.store.query.viatra.internal.viewupdate;
+
+import org.eclipse.viatra.query.runtime.matchers.context.IQueryRuntimeContextListener;
+import org.eclipse.viatra.query.runtime.matchers.tuple.ITuple;
+import org.eclipse.viatra.query.runtime.matchers.tuple.Tuples;
+import tools.refinery.store.model.Tuple;
+import tools.refinery.store.query.view.RelationView;
+
+import java.util.Objects;
+
+public class ViewUpdateTranslator<D> {
+        private final RelationView<D> key;
+
+        private final ITuple filter;
+
+        private final IQueryRuntimeContextListener listener;
+
+        public ViewUpdateTranslator(RelationView<D> key, ITuple filter, IQueryRuntimeContextListener listener) {
+                super();
+                this.key = key;
+                this.filter = filter;
+                this.listener = listener;
+        }
+
+        public boolean equals(RelationView<?> relationView, ITuple seed, IQueryRuntimeContextListener listener) {
+                return key == relationView && filter.equals(seed) && this.listener == listener;
+        }
+
+        public void processChange(ViewUpdate change) {
+                listener.update(key, Tuples.flatTupleOf(change.tuple()), change.isInsertion());
+        }
+
+        public Object[] isMatching(Tuple tuple, D value) {
+                return isMatching(key.getWrappedKey().transform(tuple, value), filter);
+        }
+
+        @SuppressWarnings("squid:S1168")
+        private Object[] isMatching(Object[] tuple, ITuple filter) {
+                for (int i = 0; i < filter.getSize(); i++) {
+                        final Object filterObject = filter.get(i);
+                        if (filterObject != null && !filterObject.equals(tuple[i])) {
+                                return null;
+                        }
+                }
+                return tuple;
+        }
+
+        @Override
+        public int hashCode() {
+                return Objects.hash(filter, key, listener);
+        }
+
+        @Override
+        public boolean equals(Object obj) {
+                if (this == obj)
+                        return true;
+                if (!(obj instanceof ViewUpdateTranslator<?> other))
+                        return false;
+                return Objects.equals(filter, other.filter) && Objects.equals(key, other.key)
+                                && Objects.equals(listener, other.listener);
+        }
+}
diff --git a/subprojects/store-query-viatra/src/test/java/tools/refinery/store/query/viatra/tests/QueryTest.java b/subprojects/store-query-viatra/src/test/java/tools/refinery/store/query/viatra/tests/QueryTest.java
new file mode 100644
index 00000000..4307ab6b
--- /dev/null
+++ b/subprojects/store-query-viatra/src/test/java/tools/refinery/store/query/viatra/tests/QueryTest.java
@@ -0,0 +1,432 @@
+package tools.refinery.store.query.viatra.tests;
+
+import org.junit.jupiter.api.Test;
+import tools.refinery.store.model.Tuple;
+import tools.refinery.store.model.representation.Relation;
+import tools.refinery.store.model.representation.TruthValue;
+import tools.refinery.store.query.QueryableModel;
+import tools.refinery.store.query.QueryableModelStore;
+import tools.refinery.store.query.building.*;
+import tools.refinery.store.query.viatra.ViatraQueryableModelStore;
+import tools.refinery.store.query.view.FilteredRelationView;
+import tools.refinery.store.query.view.KeyOnlyRelationView;
+import tools.refinery.store.query.view.RelationView;
+
+import java.util.*;
+import java.util.stream.Stream;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+class QueryTest {
+        @Test
+        void typeConstraintTest() {
+                Relation<Boolean> person = new Relation<>("Person", 1, false);
+                Relation<Boolean> asset = new Relation<>("Asset", 1, false);
+                RelationView<Boolean> personView = new KeyOnlyRelationView(person);
+
+                List<Variable> parameters = List.of(new Variable("p1"));
+                RelationAtom personRelationAtom = new RelationAtom(personView, parameters);
+                DNFAnd clause = new DNFAnd(Collections.emptySet(), List.of(personRelationAtom));
+                DNFPredicate predicate = new DNFPredicate("TypeConstraint", parameters, List.of(clause));
+
+                QueryableModelStore store = new ViatraQueryableModelStore(Set.of(person, asset), Set.of(personView),
+                                Set.of(predicate));
+                QueryableModel model = store.createModel();
+
+                model.put(person, Tuple.of(0), true);
+                model.put(person, Tuple.of(1), true);
+                model.put(asset, Tuple.of(1), true);
+                model.put(asset, Tuple.of(2), true);
+
+                model.flushChanges();
+                assertEquals(2, model.countResults(predicate));
+                compareMatchSets(model.allResults(predicate), Set.of(List.of(Tuple.of(0)), List.of(Tuple.of(1))));
+        }
+
+        @Test
+        void relationConstraintTest() {
+                Relation<Boolean> person = new Relation<Boolean>("Person", 1, false);
+                Relation<TruthValue> friend = new Relation<>("friend", 2, TruthValue.FALSE);
+                RelationView<Boolean> personView = new KeyOnlyRelationView(person);
+                RelationView<TruthValue> friendMustView = new FilteredRelationView<TruthValue>(friend, (k, v) -> v.must());
+
+                Variable p1 = new Variable("p1");
+                Variable p2 = new Variable("p2");
+                List<Variable> parameters = Arrays.asList(p1, p2);
+
+                RelationAtom personRelationAtom1 = new RelationAtom(personView, List.of(p1));
+                RelationAtom personRelationAtom2 = new RelationAtom(personView, List.of(p2));
+                RelationAtom friendRelationAtom = new RelationAtom(friendMustView, Arrays.asList(p1, p2));
+                DNFAnd clause = new DNFAnd(Collections.emptySet(),
+                                Arrays.asList(personRelationAtom1, personRelationAtom2, friendRelationAtom));
+                DNFPredicate predicate = new DNFPredicate("RelationConstraint", parameters, List.of(clause));
+
+                QueryableModelStore store = new ViatraQueryableModelStore(Set.of(person, friend),
+                                Set.of(personView, friendMustView), Set.of(predicate));
+                QueryableModel model = store.createModel();
+
+                assertEquals(0, model.countResults(predicate));
+
+                model.put(person, Tuple.of(0), true);
+                model.put(person, Tuple.of(1), true);
+                model.put(person, Tuple.of(2), true);
+                model.put(friend, Tuple.of(0, 1), TruthValue.TRUE);
+                model.put(friend, Tuple.of(1, 0), TruthValue.TRUE);
+                model.put(friend, Tuple.of(1, 2), TruthValue.TRUE);
+
+                assertEquals(0, model.countResults(predicate));
+
+                model.flushChanges();
+                assertEquals(3, model.countResults(predicate));
+                compareMatchSets(model.allResults(predicate), Set.of(List.of(Tuple.of(0), Tuple.of(1)),
+                                List.of(Tuple.of(1), Tuple.of(0)), List.of(Tuple.of(1), Tuple.of(2))));
+        }
+
+        @Test
+        void andTest() {
+                Relation<Boolean> person = new Relation<Boolean>("Person", 1, false);
+                Relation<TruthValue> friend = new Relation<>("friend", 2, TruthValue.FALSE);
+                RelationView<Boolean> personView = new KeyOnlyRelationView(person);
+                RelationView<TruthValue> friendMustView = new FilteredRelationView<TruthValue>(friend, (k, v) -> v.must());
+
+                Variable p1 = new Variable("p1");
+                Variable p2 = new Variable("p2");
+                List<Variable> parameters = Arrays.asList(p1, p2);
+
+                RelationAtom personRelationAtom1 = new RelationAtom(personView, List.of(p1));
+                RelationAtom personRelationAtom2 = new RelationAtom(personView, List.of(p2));
+                RelationAtom friendRelationAtom1 = new RelationAtom(friendMustView, Arrays.asList(p1, p2));
+                RelationAtom friendRelationAtom2 = new RelationAtom(friendMustView, Arrays.asList(p2, p1));
+                DNFAnd clause = new DNFAnd(Collections.emptySet(),
+                                Arrays.asList(personRelationAtom1, personRelationAtom2, friendRelationAtom1, friendRelationAtom2));
+                DNFPredicate predicate = new DNFPredicate("RelationConstraint", parameters, List.of(clause));
+
+                QueryableModelStore store = new ViatraQueryableModelStore(Set.of(person, friend),
+                                Set.of(personView, friendMustView), Set.of(predicate));
+                QueryableModel model = store.createModel();
+
+                assertEquals(0, model.countResults(predicate));
+
+                model.put(person, Tuple.of(0), true);
+                model.put(person, Tuple.of(1), true);
+                model.put(person, Tuple.of(2), true);
+
+                model.put(friend, Tuple.of(0, 1), TruthValue.TRUE);
+                model.put(friend, Tuple.of(0, 2), TruthValue.TRUE);
+
+                model.flushChanges();
+                assertEquals(0, model.countResults(predicate));
+
+                model.put(friend, Tuple.of(1, 0), TruthValue.TRUE);
+                model.flushChanges();
+                assertEquals(2, model.countResults(predicate));
+                compareMatchSets(model.allResults(predicate),
+                                Set.of(List.of(Tuple.of(0), Tuple.of(1)), List.of(Tuple.of(1), Tuple.of(0))));
+
+                model.put(friend, Tuple.of(2, 0), TruthValue.TRUE);
+                model.flushChanges();
+                assertEquals(4, model.countResults(predicate));
+                compareMatchSets(model.allResults(predicate),
+                                Set.of(List.of(Tuple.of(0), Tuple.of(1)), List.of(Tuple.of(1), Tuple.of(0)),
+                                                List.of(Tuple.of(0), Tuple.of(2)), List.of(Tuple.of(2), Tuple.of(0))));
+        }
+
+        @Test
+        void existTest() {
+                Relation<Boolean> person = new Relation<Boolean>("Person", 1, false);
+                Relation<TruthValue> friend = new Relation<>("friend", 2, TruthValue.FALSE);
+                RelationView<Boolean> personView = new KeyOnlyRelationView(person);
+                RelationView<TruthValue> friendMustView = new FilteredRelationView<TruthValue>(friend, (k, v) -> v.must());
+
+                Variable p1 = new Variable("p1");
+                Variable p2 = new Variable("p2");
+                List<Variable> parameters = List.of(p1);
+
+                RelationAtom personRelationAtom1 = new RelationAtom(personView, List.of(p1));
+                RelationAtom personRelationAtom2 = new RelationAtom(personView, List.of(p2));
+                RelationAtom friendRelationAtom = new RelationAtom(friendMustView, Arrays.asList(p1, p2));
+                DNFAnd clause = new DNFAnd(Set.of(p2),
+                                Arrays.asList(personRelationAtom1, personRelationAtom2, friendRelationAtom));
+                DNFPredicate predicate = new DNFPredicate("RelationConstraint", parameters, List.of(clause));
+
+                QueryableModelStore store = new ViatraQueryableModelStore(Set.of(person, friend),
+                                Set.of(personView, friendMustView), Set.of(predicate));
+                QueryableModel model = store.createModel();
+
+                assertEquals(0, model.countResults(predicate));
+
+                model.put(person, Tuple.of(0), true);
+                model.put(person, Tuple.of(1), true);
+                model.put(person, Tuple.of(2), true);
+                model.put(friend, Tuple.of(0, 1), TruthValue.TRUE);
+                model.put(friend, Tuple.of(1, 0), TruthValue.TRUE);
+                model.put(friend, Tuple.of(1, 2), TruthValue.TRUE);
+
+                assertEquals(0, model.countResults(predicate));
+
+                model.flushChanges();
+                assertEquals(2, model.countResults(predicate));
+                compareMatchSets(model.allResults(predicate), Set.of(List.of(Tuple.of(0)), List.of(Tuple.of(1))));
+        }
+
+        @Test
+        void orTest() {
+                Relation<Boolean> person = new Relation<>("Person", 1, false);
+                Relation<Boolean> animal = new Relation<>("Animal", 1, false);
+                Relation<TruthValue> friend = new Relation<>("friend", 2, TruthValue.FALSE);
+                RelationView<Boolean> personView = new KeyOnlyRelationView(person);
+                RelationView<Boolean> animalView = new KeyOnlyRelationView(animal);
+                RelationView<TruthValue> friendMustView = new FilteredRelationView<TruthValue>(friend, (k, v) -> v.must());
+
+                Variable p1 = new Variable("p1");
+                Variable p2 = new Variable("p2");
+                List<Variable> parameters = Arrays.asList(p1, p2);
+
+                // Person-Person friendship
+                RelationAtom personRelationAtom1 = new RelationAtom(personView, List.of(p1));
+                RelationAtom personRelationAtom2 = new RelationAtom(personView, List.of(p2));
+                RelationAtom friendRelationAtom1 = new RelationAtom(friendMustView, Arrays.asList(p1, p2));
+                DNFAnd clause1 = new DNFAnd(Collections.emptySet(),
+                                Arrays.asList(personRelationAtom1, personRelationAtom2, friendRelationAtom1));
+
+                // Animal-Animal friendship
+                RelationAtom animalRelationAtom1 = new RelationAtom(animalView, List.of(p1));
+                RelationAtom animalRelationAtom2 = new RelationAtom(animalView, List.of(p2));
+                RelationAtom friendRelationAtom2 = new RelationAtom(friendMustView, Arrays.asList(p1, p2));
+                DNFAnd clause2 = new DNFAnd(Collections.emptySet(),
+                                Arrays.asList(animalRelationAtom1, animalRelationAtom2, friendRelationAtom2));
+
+                // No inter-species friendship
+
+                DNFPredicate predicate = new DNFPredicate("Or", parameters, Arrays.asList(clause1, clause2));
+
+                QueryableModelStore store = new ViatraQueryableModelStore(Set.of(person, animal, friend),
+                                Set.of(personView, animalView, friendMustView), Set.of(predicate));
+                QueryableModel model = store.createModel();
+
+                model.put(person, Tuple.of(0), true);
+                model.put(person, Tuple.of(1), true);
+                model.put(animal, Tuple.of(2), true);
+                model.put(animal, Tuple.of(3), true);
+                model.put(friend, Tuple.of(0, 1), TruthValue.TRUE);
+                model.put(friend, Tuple.of(0, 2), TruthValue.TRUE);
+                model.put(friend, Tuple.of(2, 3), TruthValue.TRUE);
+                model.put(friend, Tuple.of(3, 0), TruthValue.TRUE);
+
+                model.flushChanges();
+                assertEquals(2, model.countResults(predicate));
+                compareMatchSets(model.allResults(predicate),
+                                Set.of(List.of(Tuple.of(0), Tuple.of(1)), List.of(Tuple.of(2), Tuple.of(3))));
+        }
+
+        @Test
+        void equalityTest() {
+                Relation<Boolean> person = new Relation<Boolean>("Person", 1, false);
+                RelationView<Boolean> personView = new KeyOnlyRelationView(person);
+
+                Variable p1 = new Variable("p1");
+                Variable p2 = new Variable("p2");
+                List<Variable> parameters = Arrays.asList(p1, p2);
+
+                RelationAtom personRelationAtom1 = new RelationAtom(personView, List.of(p1));
+                RelationAtom personRelationAtom2 = new RelationAtom(personView, List.of(p2));
+                EquivalenceAtom equivalenceAtom = new EquivalenceAtom(true, p1, p2);
+                DNFAnd clause = new DNFAnd(Collections.emptySet(),
+                                Arrays.asList(personRelationAtom1, personRelationAtom2, equivalenceAtom));
+                DNFPredicate predicate = new DNFPredicate("Equality", parameters, List.of(clause));
+
+                QueryableModelStore store = new ViatraQueryableModelStore(Set.of(person), Set.of(personView), Set.of(predicate));
+                QueryableModel model = store.createModel();
+
+                model.put(person, Tuple.of(0), true);
+                model.put(person, Tuple.of(1), true);
+                model.put(person, Tuple.of(2), true);
+
+                model.flushChanges();
+                assertEquals(3, model.countResults(predicate));
+                compareMatchSets(model.allResults(predicate), Set.of(List.of(Tuple.of(0), Tuple.of(0)),
+                                List.of(Tuple.of(1), Tuple.of(1)), List.of(Tuple.of(2), Tuple.of(2))));
+        }
+
+        @Test
+        void inequalityTest() {
+                Relation<Boolean> person = new Relation<Boolean>("Person", 1, false);
+                Relation<TruthValue> friend = new Relation<>("friend", 2, TruthValue.FALSE);
+                RelationView<Boolean> personView = new KeyOnlyRelationView(person);
+                RelationView<TruthValue> friendMustView = new FilteredRelationView<TruthValue>(friend, (k, v) -> v.must());
+
+                Variable p1 = new Variable("p1");
+                Variable p2 = new Variable("p2");
+                Variable p3 = new Variable("p3");
+                List<Variable> parameters = Arrays.asList(p1, p2, p3);
+
+                RelationAtom personRelationAtom1 = new RelationAtom(personView, List.of(p1));
+                RelationAtom personRelationAtom2 = new RelationAtom(personView, List.of(p2));
+                RelationAtom friendRelationAtom1 = new RelationAtom(friendMustView, Arrays.asList(p1, p3));
+                RelationAtom friendRelationAtom2 = new RelationAtom(friendMustView, Arrays.asList(p2, p3));
+                EquivalenceAtom inequivalenceAtom = new EquivalenceAtom(false, p1, p2);
+                DNFAnd clause = new DNFAnd(Collections.emptySet(), Arrays.asList(personRelationAtom1, personRelationAtom2,
+                                friendRelationAtom1, friendRelationAtom2, inequivalenceAtom));
+                DNFPredicate predicate = new DNFPredicate("Inequality", parameters, List.of(clause));
+
+                QueryableModelStore store = new ViatraQueryableModelStore(Set.of(person, friend),
+                                Set.of(personView, friendMustView), Set.of(predicate));
+                QueryableModel model = store.createModel();
+
+                model.put(person, Tuple.of(0), true);
+                model.put(person, Tuple.of(1), true);
+                model.put(person, Tuple.of(2), true);
+                model.put(friend, Tuple.of(0, 2), TruthValue.TRUE);
+                model.put(friend, Tuple.of(1, 2), TruthValue.TRUE);
+
+                model.flushChanges();
+                assertEquals(2, model.countResults(predicate));
+                compareMatchSets(model.allResults(predicate),
+                                Set.of(List.of(Tuple.of(0), Tuple.of(1), Tuple.of(2)), List.of(Tuple.of(1), Tuple.of(0), Tuple.of(2))));
+        }
+
+        @Test
+        void patternCallTest() {
+                Relation<Boolean> person = new Relation<Boolean>("Person", 1, false);
+                Relation<TruthValue> friend = new Relation<>("friend", 2, TruthValue.FALSE);
+                RelationView<Boolean> personView = new KeyOnlyRelationView(person);
+                RelationView<TruthValue> friendMustView = new FilteredRelationView<TruthValue>(friend, (k, v) -> v.must());
+
+                Variable p1 = new Variable("p1");
+                Variable p2 = new Variable("p2");
+                List<Variable> parameters = Arrays.asList(p1, p2);
+
+                RelationAtom personRelationAtom1 = new RelationAtom(personView, List.of(p1));
+                RelationAtom personRelationAtom2 = new RelationAtom(personView, List.of(p2));
+                RelationAtom friendRelationAtom = new RelationAtom(friendMustView, Arrays.asList(p1, p2));
+                DNFAnd clause = new DNFAnd(Collections.emptySet(),
+                                Arrays.asList(personRelationAtom1, personRelationAtom2, friendRelationAtom));
+                DNFPredicate friendPredicate = new DNFPredicate("RelationConstraint", parameters, List.of(clause));
+
+                Variable p3 = new Variable("p3");
+                Variable p4 = new Variable("p4");
+                List<Variable> substitution = Arrays.asList(p3, p4);
+                RelationAtom personRelationAtom3 = new RelationAtom(personView, List.of(p3));
+                RelationAtom personRelationAtom4 = new RelationAtom(personView, List.of(p4));
+                PredicateAtom friendPredicateAtom = new PredicateAtom(true, false, friendPredicate, substitution);
+                DNFAnd patternCallClause = new DNFAnd(Collections.emptySet(),
+                                Arrays.asList(personRelationAtom3, personRelationAtom4, friendPredicateAtom));
+                DNFPredicate predicate = new DNFPredicate("PatternCall", substitution, List.of(patternCallClause));
+
+                QueryableModelStore store = new ViatraQueryableModelStore(Set.of(person, friend),
+                                Set.of(personView, friendMustView), Set.of(friendPredicate, predicate));
+                QueryableModel model = store.createModel();
+
+                model.put(person, Tuple.of(0), true);
+                model.put(person, Tuple.of(1), true);
+                model.put(person, Tuple.of(2), true);
+                model.put(friend, Tuple.of(0, 1), TruthValue.TRUE);
+                model.put(friend, Tuple.of(1, 0), TruthValue.TRUE);
+                model.put(friend, Tuple.of(1, 2), TruthValue.TRUE);
+
+                model.flushChanges();
+
+                assertEquals(3, model.countResults(friendPredicate));
+        }
+
+        @Test
+        void negativePatternCallTest() {
+                Relation<Boolean> person = new Relation<Boolean>("Person", 1, false);
+                Relation<TruthValue> friend = new Relation<>("friend", 2, TruthValue.FALSE);
+                RelationView<Boolean> personView = new KeyOnlyRelationView(person);
+                RelationView<TruthValue> friendMustView = new FilteredRelationView<TruthValue>(friend, (k, v) -> v.must());
+
+                Variable p1 = new Variable("p1");
+                Variable p2 = new Variable("p2");
+                List<Variable> parameters = Arrays.asList(p1, p2);
+
+                RelationAtom personRelationAtom1 = new RelationAtom(personView, List.of(p1));
+                RelationAtom personRelationAtom2 = new RelationAtom(personView, List.of(p2));
+                RelationAtom friendRelationAtom = new RelationAtom(friendMustView, Arrays.asList(p1, p2));
+                DNFAnd clause = new DNFAnd(Collections.emptySet(),
+                                Arrays.asList(personRelationAtom1, personRelationAtom2, friendRelationAtom));
+                DNFPredicate friendPredicate = new DNFPredicate("RelationConstraint", parameters, List.of(clause));
+
+                Variable p3 = new Variable("p3");
+                Variable p4 = new Variable("p4");
+                List<Variable> substitution = Arrays.asList(p3, p4);
+                RelationAtom personRelationAtom3 = new RelationAtom(personView, List.of(p3));
+                RelationAtom personRelationAtom4 = new RelationAtom(personView, List.of(p4));
+                PredicateAtom friendPredicateAtom = new PredicateAtom(false, false, friendPredicate, substitution);
+                DNFAnd negativePatternCallClause = new DNFAnd(Collections.emptySet(),
+                                Arrays.asList(personRelationAtom3, personRelationAtom4, friendPredicateAtom));
+                DNFPredicate predicate = new DNFPredicate("NegativePatternCall", substitution,
+                                List.of(negativePatternCallClause));
+
+                QueryableModelStore store = new ViatraQueryableModelStore(Set.of(person, friend),
+                                Set.of(personView, friendMustView), Set.of(friendPredicate, predicate));
+                QueryableModel model = store.createModel();
+
+                model.put(person, Tuple.of(0), true);
+                model.put(person, Tuple.of(1), true);
+                model.put(person, Tuple.of(2), true);
+                model.put(friend, Tuple.of(0, 1), TruthValue.TRUE);
+                model.put(friend, Tuple.of(1, 0), TruthValue.TRUE);
+                model.put(friend, Tuple.of(1, 2), TruthValue.TRUE);
+
+                model.flushChanges();
+                assertEquals(6, model.countResults(predicate));
+        }
+
+        @Test
+        void transitivePatternCallTest() {
+                Relation<Boolean> person = new Relation<Boolean>("Person", 1, false);
+                Relation<TruthValue> friend = new Relation<>("friend", 2, TruthValue.FALSE);
+                RelationView<Boolean> personView = new KeyOnlyRelationView(person);
+                RelationView<TruthValue> friendMustView = new FilteredRelationView<TruthValue>(friend, (k, v) -> v.must());
+
+                Variable p1 = new Variable("p1");
+                Variable p2 = new Variable("p2");
+                List<Variable> parameters = Arrays.asList(p1, p2);
+
+                RelationAtom personRelationAtom1 = new RelationAtom(personView, List.of(p1));
+                RelationAtom personRelationAtom2 = new RelationAtom(personView, List.of(p2));
+                RelationAtom friendRelationAtom = new RelationAtom(friendMustView, Arrays.asList(p1, p2));
+                DNFAnd clause = new DNFAnd(Collections.emptySet(),
+                                Arrays.asList(personRelationAtom1, personRelationAtom2, friendRelationAtom));
+                DNFPredicate friendPredicate = new DNFPredicate("RelationConstraint", parameters, List.of(clause));
+
+                Variable p3 = new Variable("p3");
+                Variable p4 = new Variable("p4");
+                List<Variable> substitution = Arrays.asList(p3, p4);
+                RelationAtom personRelationAtom3 = new RelationAtom(personView, List.of(p3));
+                RelationAtom personRelationAtom4 = new RelationAtom(personView, List.of(p4));
+                PredicateAtom friendPredicateAtom = new PredicateAtom(true, true, friendPredicate, substitution);
+                DNFAnd patternCallClause = new DNFAnd(Collections.emptySet(),
+                                Arrays.asList(personRelationAtom3, personRelationAtom4, friendPredicateAtom));
+                DNFPredicate predicate = new DNFPredicate("TransitivePatternCall", substitution,
+                                List.of(patternCallClause));
+
+                QueryableModelStore store = new ViatraQueryableModelStore(Set.of(person, friend),
+                                Set.of(personView, friendMustView), Set.of(friendPredicate, predicate));
+                QueryableModel model = store.createModel();
+
+                model.put(person, Tuple.of(0), true);
+                model.put(person, Tuple.of(1), true);
+                model.put(person, Tuple.of(2), true);
+                model.put(friend, Tuple.of(0, 1), TruthValue.TRUE);
+                model.put(friend, Tuple.of(1, 2), TruthValue.TRUE);
+
+                model.flushChanges();
+                assertEquals(3, model.countResults(predicate));
+        }
+        static void compareMatchSets(Stream<Object[]> matchSet, Set<List<Tuple>> expected) {
+                Set<List<Tuple>> translatedMatchSet = new HashSet<>();
+                var iterator = matchSet.iterator();
+                while (iterator.hasNext()) {
+                        var element = iterator.next();
+                        List<Tuple> elementToTranslatedMatchSet = new ArrayList<>();
+                        for (Object o : element) {
+                                elementToTranslatedMatchSet.add((Tuple) o);
+                        }
+                        translatedMatchSet.add(elementToTranslatedMatchSet);
+                }
+
+                assertEquals(expected, translatedMatchSet);
+        }
+}
diff --git a/subprojects/store-query-viatra/src/test/java/tools/refinery/store/query/viatra/tests/QueryTransactionTest.java b/subprojects/store-query-viatra/src/test/java/tools/refinery/store/query/viatra/tests/QueryTransactionTest.java
new file mode 100644
index 00000000..613d0074
--- /dev/null
+++ b/subprojects/store-query-viatra/src/test/java/tools/refinery/store/query/viatra/tests/QueryTransactionTest.java
@@ -0,0 +1,56 @@
+package tools.refinery.store.query.viatra.tests;
+
+import org.junit.jupiter.api.Test;
+import tools.refinery.store.model.Tuple;
+import tools.refinery.store.model.representation.Relation;
+import tools.refinery.store.query.QueryableModel;
+import tools.refinery.store.query.QueryableModelStore;
+import tools.refinery.store.query.building.DNFAnd;
+import tools.refinery.store.query.building.DNFPredicate;
+import tools.refinery.store.query.building.RelationAtom;
+import tools.refinery.store.query.building.Variable;
+import tools.refinery.store.query.viatra.ViatraQueryableModelStore;
+import tools.refinery.store.query.view.KeyOnlyRelationView;
+import tools.refinery.store.query.view.RelationView;
+
+import java.util.Collections;
+import java.util.List;
+import java.util.Set;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+class QueryTransactionTest {
+        @Test
+        void flushTest() {
+                Relation<Boolean> person = new Relation<>("Person", 1, false);
+                Relation<Boolean> asset = new Relation<>("Asset", 1, false);
+                RelationView<Boolean> personView = new KeyOnlyRelationView(person);
+
+                List<Variable> parameters = List.of(new Variable("p1"));
+                RelationAtom personRelationAtom = new RelationAtom(personView, parameters);
+                DNFAnd clause = new DNFAnd(Collections.emptySet(), List.of(personRelationAtom));
+                DNFPredicate predicate = new DNFPredicate("TypeConstraint", parameters, List.of(clause));
+
+                QueryableModelStore store = new ViatraQueryableModelStore(Set.of(person, asset), Set.of(personView),
+                                Set.of(predicate));
+                QueryableModel model = store.createModel();
+
+                assertEquals(0, model.countResults(predicate));
+
+                model.put(person, Tuple.of(0), true);
+                model.put(person, Tuple.of(1), true);
+                model.put(asset, Tuple.of(1), true);
+                model.put(asset, Tuple.of(2), true);
+
+                assertEquals(0, model.countResults(predicate));
+
+                model.flushChanges();
+                assertEquals(2, model.countResults(predicate));
+
+                model.put(person, Tuple.of(4), true);
+                assertEquals(2, model.countResults(predicate));
+
+                model.flushChanges();
+                assertEquals(3, model.countResults(predicate));
+        }
+}