refactor: move viatra into a separate subproject

23 files changed, 533 insertions, 580 deletions

diff --git a/settings.gradle b/settings.gradle
index 36721f4b..3149380d 100644
--- a/settings.gradle
+++ b/settings.gradle
@@ -7,6 +7,7 @@ include 'language-model'
 include 'language-semantics'
 include 'language-web'
 include 'store'
+include 'store-query-viatra'
 
 for (project in rootProject.children) {
         def projectName = project.name
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/src/main/java/tools/refinery/store/query/QueriableModelStoreImpl.java b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/ViatraQueryableModelStore.java
index 653783dd..5a02ca08 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/query/QueriableModelStoreImpl.java
+++ b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/ViatraQueryableModelStore.java
@@ -1,48 +1,49 @@
-package tools.refinery.store.query;
-
-import java.util.Collections;
-import java.util.HashMap;
-import java.util.Map;
-import java.util.Set;
+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.building.DNFAnd;
-import tools.refinery.store.query.building.DNFAtom;
-import tools.refinery.store.query.building.DNFPredicate;
-import tools.refinery.store.query.building.PredicateAtom;
-import tools.refinery.store.query.building.RelationAtom;
-import tools.refinery.store.query.internal.DNF2PQuery;
-import tools.refinery.store.query.internal.QueriableModelImpl;
-import tools.refinery.store.query.internal.RawPatternMatcher;
-import tools.refinery.store.query.internal.DNF2PQuery.SimplePQuery;
+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;
 
-public class QueriableModelStoreImpl implements QueriableModelStore {
+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 QueriableModelStoreImpl(Set<DataRepresentation<?, ?>> dataRepresentations,
-                        Set<RelationView<?>> relationViews, Set<DNFPredicate> predicates) {
-                this.store = new ModelStoreImpl(dataRepresentations);
-                validateViews(dataRepresentations, relationViews);
+        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) {
-                        // TODO: make it work for non-relation representation?
                         if (!dataRepresentations.contains(relationView.getRepresentation())) {
                                 throw new IllegalArgumentException(
                                                 DataRepresentation.class.getSimpleName() + " " + relationView.getStringID() + " added to "
-                                                                + QueriableModelStore.class.getSimpleName() + " without a referred representation.");
+                                                                + QueryableModelStore.class.getSimpleName() + " without a referred representation.");
                         }
                 }
         }
@@ -62,16 +63,17 @@ public class QueriableModelStoreImpl implements QueriableModelStore {
         }
 
         private void validateRelationAtom(Set<RelationView<?>> relationViews, DNFPredicate dnfPredicate,
-                        RelationAtom relationAtom) {
-                if (!relationViews.contains(relationAtom.getView())) {
+                                                                          RelationAtom relationAtom) {
+                if (!relationViews.contains(relationAtom.view())) {
                         throw new IllegalArgumentException(DNFPredicate.class.getSimpleName() + " "
                                         + dnfPredicate.getUniqueName() + " contains reference to a view of "
-                                        + relationAtom.getView().getRepresentation().getName()
+                                        + relationAtom.view().getRepresentation().getName()
                                         + " that is not in the model.");
                 }
         }
+
         private void validatePredicateAtom(Set<DNFPredicate> predicates, DNFPredicate dnfPredicate,
-                        PredicateAtom predicateAtom) {
+                                                                           PredicateAtom predicateAtom) {
                 if (!predicates.contains(predicateAtom.getReferred())) {
                         throw new IllegalArgumentException(
                                         DNFPredicate.class.getSimpleName() + " " + dnfPredicate.getUniqueName()
@@ -85,7 +87,8 @@ public class QueriableModelStoreImpl implements QueriableModelStore {
                 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();
+                        GenericQuerySpecification<RawPatternMatcher> query =
+                                        DNF2PQuery.translate(dnfPredicate, dnf2PQueryMap).build();
                         result.put(dnfPredicate, query);
                 }
 
@@ -96,23 +99,25 @@ public class QueriableModelStoreImpl implements QueriableModelStore {
         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 QueriableModel createModel() {
-                return new QueriableModelImpl(this, this.store.createModel(), predicates);
+        public QueryableModel createModel() {
+                return new ViatraQueryableModel(this, this.store.createModel(), predicates);
         }
 
         @Override
-        public QueriableModel createModel(long state) {
-                return new QueriableModelImpl(this, this.store.createModel(state), predicates);
+        public QueryableModel createModel(long state) {
+                return new ViatraQueryableModel(this, this.store.createModel(state), predicates);
         }
 
         @Override
diff --git a/subprojects/store/src/main/java/tools/refinery/store/query/internal/RawPatternMatcher.java b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/RawPatternMatcher.java
index c6d6353c..be348a63 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/query/internal/RawPatternMatcher.java
+++ b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/RawPatternMatcher.java
@@ -1,56 +1,50 @@
-package tools.refinery.store.query.internal;
-
-import java.util.Optional;
-import java.util.stream.Stream;
+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.Tuple;
 import org.eclipse.viatra.query.runtime.matchers.tuple.AbstractTuple;
+import org.eclipse.viatra.query.runtime.matchers.tuple.Tuple;
 
-public class RawPatternMatcher extends GenericPatternMatcher implements PredicateResult{
-        
+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()];
         }
-        
-        @Override
+
         public boolean hasResult() {
                 return hasResult(empty);
         }
-        @Override
+
         public boolean hasResult(Object[] parameters) {
                 return this.backend.hasMatch(parameters);
         }
-        @Override
+
         public Optional<Object[]> oneResult() {
                 return oneResult(empty);
         }
-        @Override
+
         public Optional<Object[]> oneResult(Object[] parameters) {
                 Optional<Tuple> tuple = this.backend.getOneArbitraryMatch(parameters);
-                if(tuple.isPresent()) {
-                        return Optional.of(tuple.get().getElements());
-                } else {
-                        return Optional.empty();
-                }
+                return tuple.map(AbstractTuple::getElements);
         }
-        @Override
+
         public Stream<Object[]> allResults() {
                 return allResults(empty);
         }
-        @Override
+
         public Stream<Object[]> allResults(Object[] parameters) {
                 return this.backend.getAllMatches(parameters).map(AbstractTuple::getElements);
         }
-        @Override
+
         public int countResults() {
                 return countResults(empty);
         }
-        @Override
+
         public int countResults(Object[] parameters) {
                 return backend.countMatches(parameters);
         }
diff --git a/subprojects/store/src/main/java/tools/refinery/store/query/internal/RelationalScope.java b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/RelationalScope.java
index e8d45356..8dfa22e0 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/query/internal/RelationalScope.java
+++ b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/RelationalScope.java
@@ -1,43 +1,43 @@
-package tools.refinery.store.query.internal;
-
-import java.util.Set;
+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;
 
-public class RelationalScope extends QueryScope{
+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);
-                //this.changeListener = new 
         }
-        
+
         public <D> void processUpdate(Relation<D> relation, Tuple key, D oldValue, D newValue) {
                 updateListener.addUpdate(relation, key, oldValue, newValue);
         }
-        
-        public boolean hasChange() {
-                return updateListener.hasChange();
+
+        public boolean hasChanges() {
+                return updateListener.hasChanges();
         }
 
         public void flush() {
                 updateListener.flush();
         }
-        
+
         @Override
         protected IEngineContext createEngineContext(ViatraQueryEngine engine, IIndexingErrorListener errorListener,
-                        Logger logger) {
+                                                                                                 Logger logger) {
                 return new RelationalEngineContext(model, updateListener);
         }
 }
diff --git a/subprojects/store/src/main/java/tools/refinery/store/query/internal/QueriableModelImpl.java b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/ViatraQueryableModel.java
index 0f4d609f..3803702d 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/query/internal/QueriableModelImpl.java
+++ b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/ViatraQueryableModel.java
@@ -1,16 +1,9 @@
-package tools.refinery.store.query.internal;
-
-import java.util.HashMap;
-import java.util.Map;
-import java.util.Optional;
-import java.util.Set;
-import java.util.stream.Stream;
+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;
@@ -18,21 +11,31 @@ 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.QueriableModel;
-import tools.refinery.store.query.QueriableModelStore;
+import tools.refinery.store.query.QueryableModel;
+import tools.refinery.store.query.QueryableModelStore;
 import tools.refinery.store.query.building.DNFPredicate;
 
-public class QueriableModelImpl implements QueriableModel {
-        protected final QueriableModelStore store;
+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 QueriableModelImpl(QueriableModelStore store, Model model,
-                        Map<DNFPredicate, GenericQuerySpecification<RawPatternMatcher>> predicates2PQuery) {
+        public ViatraQueryableModel(QueryableModelStore store, Model model,
+                                                                Map<DNFPredicate, GenericQuerySpecification<RawPatternMatcher>> predicates2PQuery) {
                 this.store = store;
                 this.model = model;
                 this.predicates2PQuery = predicates2PQuery;
@@ -45,7 +48,8 @@ public class QueriableModelImpl implements QueriableModel {
                 this.predicate2Matcher = initMatchers(this.engine, this.predicates2PQuery);
         }
 
-        private Map<DNFPredicate, RawPatternMatcher> initMatchers(AdvancedViatraQueryEngine engine,
+        private Map<DNFPredicate, RawPatternMatcher> initMatchers(
+                        AdvancedViatraQueryEngine engine,
                         Map<DNFPredicate, GenericQuerySpecification<RawPatternMatcher>> predicates2pQuery) {
                 // 1. prepare group
                 IQueryGroup queryGroup = GenericQueryGroup.of(Set.copyOf(predicates2pQuery.values()));
@@ -84,18 +88,19 @@ public class QueriableModelImpl implements QueriableModel {
         @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);
+                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<?>) {
+                if (representation instanceof Relation<?>) {
+                        //noinspection RedundantSuppression
                         @SuppressWarnings("unchecked")
                         Relation<V> relation = (Relation<V>) representation;
-                        while(cursor.move()) {
+                        while (cursor.move()) {
                                 Tuple key = (Tuple) cursor.getKey();
                                 V newValue = cursor.getValue();
                                 V oldValue = this.model.put(relation, key, newValue);
@@ -111,10 +116,10 @@ public class QueriableModelImpl implements QueriableModel {
                 return model.getSize(representation);
         }
 
-        protected PredicateResult getPredicateResult(DNFPredicate predicate) {
+        protected RawPatternMatcher getMatcher(DNFPredicate predicate) {
                 var result = this.predicate2Matcher.get(predicate);
                 if (result == null) {
-                        throw new IllegalArgumentException("Model does not contain predicate " + predicate.getName() + "!");
+                        throw new IllegalArgumentException("Model does not contain predicate %s".formatted(predicate.getName()));
                 } else
                         return result;
         }
@@ -123,55 +128,62 @@ public class QueriableModelImpl implements QueriableModel {
                 int predicateArity = predicate.getVariables().size();
                 int parameterArity = parameters.length;
                 if (parameterArity != predicateArity) {
-                        throw new IllegalArgumentException("Predicate " + predicate.getName() + " with " + predicateArity
-                                        + " arity called with different number of parameters (" + parameterArity + ")!");
+                        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 getPredicateResult(predicate).hasResult();
+                return getMatcher(predicate).hasResult();
         }
 
         @Override
         public boolean hasResult(DNFPredicate predicate, Object[] parameters) {
                 validateParameters(predicate, parameters);
-                return getPredicateResult(predicate).hasResult(parameters);
+                return getMatcher(predicate).hasResult(parameters);
         }
-        
+
         @Override
-        public Optional<Object[]> oneResult(DNFPredicate predicate){
-                return getPredicateResult(predicate).oneResult();
+        public Optional<Object[]> oneResult(DNFPredicate predicate) {
+                return getMatcher(predicate).oneResult();
         }
 
         @Override
-        public Optional<Object[]> oneResult(DNFPredicate predicate, Object[] parameters){
+        public Optional<Object[]> oneResult(DNFPredicate predicate, Object[] parameters) {
                 validateParameters(predicate, parameters);
-                return getPredicateResult(predicate).oneResult(parameters);
+                return getMatcher(predicate).oneResult(parameters);
         }
 
         @Override
-        public Stream<Object[]> allResults(DNFPredicate predicate){
-                return getPredicateResult(predicate).allResults();
+        public Stream<Object[]> allResults(DNFPredicate predicate) {
+                return getMatcher(predicate).allResults();
         }
 
         @Override
-        public Stream<Object[]> allResults(DNFPredicate predicate, Object[] parameters){
+        public Stream<Object[]> allResults(DNFPredicate predicate, Object[] parameters) {
                 validateParameters(predicate, parameters);
-                return getPredicateResult(predicate).allResults(parameters);
+                return getMatcher(predicate).allResults(parameters);
         }
 
         @Override
-        public int countResults(DNFPredicate predicate){
-                return getPredicateResult(predicate).countResults();
+        public int countResults(DNFPredicate predicate) {
+                return getMatcher(predicate).countResults();
         }
 
         @Override
-        public int countResults(DNFPredicate predicate, Object[] parameters){
+        public int countResults(DNFPredicate predicate, Object[] parameters) {
                 validateParameters(predicate, parameters);
-                return getPredicateResult(predicate).countResults(parameters);
-                
+                return getMatcher(predicate).countResults(parameters);
+
+        }
+
+        @Override
+        public boolean hasChanges() {
+                return scope.hasChanges();
         }
+
         @Override
         public void flushChanges() {
                 this.scope.flush();
@@ -192,21 +204,16 @@ public class QueriableModelImpl implements QueriableModel {
                 restoreWithDiffReplay(state);
         }
 
-        public void restoreWithDiffReplay(long state) {
+        private void restoreWithDiffReplay(long state) {
                 var modelDiffCursor = getDiffCursor(state);
-                for(DataRepresentation<?,?> dataRepresentation : this.getDataRepresentations()) {
+                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);
+        private <K, V> void restoreRepresentationWithDiffReplay(ModelDiffCursor modelDiffCursor,
+                                                                                                                        DataRepresentation<K, V> dataRepresentation) {
+                DiffCursor<K, V> diffCursor = modelDiffCursor.getCursor(dataRepresentation);
                 this.putAll(dataRepresentation, diffCursor);
         }
-        
-        public void restoreWithReinit(long state) {
-                model.restore(state);
-                this.initEngine();
-        }
 }
diff --git a/subprojects/store/src/main/java/tools/refinery/store/query/internal/DummyBaseIndexer.java b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/context/DummyBaseIndexer.java
index 49637071..4b311a64 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/query/internal/DummyBaseIndexer.java
+++ b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/context/DummyBaseIndexer.java
@@ -1,18 +1,17 @@
-package tools.refinery.store.query.internal;
-
-import java.lang.reflect.InvocationTargetException;
-import java.util.concurrent.Callable;
+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 org.eclipse.viatra.query.runtime.tabular.TabularEngineContext;
+ * Copied from <code>org.eclipse.viatra.query.runtime.tabular.TabularEngineContext</code>
  */
-public class DummyBaseIndexer implements IBaseIndex{
-
+public class DummyBaseIndexer implements IBaseIndex {
         @Override
         public <V> V coalesceTraversals(Callable<V> callable) throws InvocationTargetException {
                 try {
diff --git a/subprojects/store/src/main/java/tools/refinery/store/query/internal/RelationalEngineContext.java b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/context/RelationalEngineContext.java
index dfbd8545..882734cb 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/query/internal/RelationalEngineContext.java
+++ b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/context/RelationalEngineContext.java
@@ -1,15 +1,15 @@
-package tools.refinery.store.query.internal;
+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{
+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);
@@ -22,7 +22,7 @@ public class RelationalEngineContext implements IEngineContext{
 
         @Override
         public void dispose() {
-                //lifecycle not controlled by engine
+                // Nothing to dispose, because lifecycle is not controlled by the engine.
         }
 
         @Override
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/src/main/java/tools/refinery/store/query/internal/RelationalRuntimeContext.java b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/context/RelationalRuntimeContext.java
index a186b5dd..0bd1b807 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/query/internal/RelationalRuntimeContext.java
+++ b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/context/RelationalRuntimeContext.java
@@ -1,53 +1,47 @@
-package tools.refinery.store.query.internal;
+package tools.refinery.store.query.viatra.internal.context;
 
-import static tools.refinery.store.util.CollectionsUtil.filter;
-import static tools.refinery.store.util.CollectionsUtil.map;
-
-import java.lang.reflect.InvocationTargetException;
-import java.util.Iterator;
-import java.util.Optional;
-import java.util.concurrent.Callable;
-
-import org.eclipse.viatra.query.runtime.base.core.NavigationHelperImpl;
-import org.eclipse.viatra.query.runtime.matchers.context.IInputKey;
-import org.eclipse.viatra.query.runtime.matchers.context.IQueryMetaContext;
-import org.eclipse.viatra.query.runtime.matchers.context.IQueryRuntimeContext;
-import org.eclipse.viatra.query.runtime.matchers.context.IQueryRuntimeContextListener;
-import org.eclipse.viatra.query.runtime.matchers.context.IndexingService;
+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;
         }
 
-        /**
-         * TODO: check {@link NavigationHelperImpl#coalesceTraversals(Callable)}
-         */
         @Override
         public <V> V coalesceTraversals(Callable<V> callable) throws InvocationTargetException {
-        try {
-            return callable.call();
-        } catch (Exception e) {
-            throw new InvocationTargetException(e);
-        }
+                try {
+                        return callable.call();
+                } catch (Exception e) {
+                        throw new InvocationTargetException(e);
+                }
         }
 
         @Override
@@ -57,7 +51,7 @@ public class RelationalRuntimeContext implements IQueryRuntimeContext {
 
         @Override
         public boolean isIndexed(IInputKey key, IndexingService service) {
-                if(key instanceof RelationView<?> relationalKey) {
+                if (key instanceof RelationView<?> relationalKey) {
                         return this.modelUpdateListener.containsRelationalView(relationalKey);
                 } else {
                         return false;
@@ -66,15 +60,15 @@ public class RelationalRuntimeContext implements IQueryRuntimeContext {
 
         @Override
         public void ensureIndexed(IInputKey key, IndexingService service) {
-                if(!isIndexed(key, service)) {
-                        throw new IllegalStateException("Engine tries to index a new key " +key);
+                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) {
-                        RelationView<?> relationViewKey = (RelationView<?>) key;
-                        if(modelUpdateListener.containsRelationalView(relationViewKey)) {
+                if (key instanceof RelationView<?> relationViewKey) {
+                        if (modelUpdateListener.containsRelationalView(relationViewKey)) {
                                 return relationViewKey;
                         } else {
                                 throw new IllegalStateException("Query is asking for non-indexed key");
@@ -83,15 +77,15 @@ public class RelationalRuntimeContext implements IQueryRuntimeContext {
                         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));
+                Iterable<Object[]> filteredBySeed = filter(allObjects, objectArray -> isMatching(objectArray, seedMask, seed));
                 Iterator<Object[]> iterator = filteredBySeed.iterator();
                 int result = 0;
-                while(iterator.hasNext()) {
+                while (iterator.hasNext()) {
                         iterator.next();
                         result++;
                 }
@@ -107,15 +101,15 @@ public class RelationalRuntimeContext implements IQueryRuntimeContext {
         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);
+                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++) {
+                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)) {
+                        if (!tupleElement.equals(seedElement)) {
                                 return false;
                         }
                 }
@@ -130,14 +124,14 @@ public class RelationalRuntimeContext implements IQueryRuntimeContext {
         @Override
         public boolean containsTuple(IInputKey key, ITuple seed) {
                 RelationView<?> relationalViewKey = checkKey(key);
-                return relationalViewKey.get(model,seed.getElements());
+                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
diff --git a/subprojects/store/src/main/java/tools/refinery/store/query/internal/DNF2PQuery.java b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/pquery/DNF2PQuery.java
index bcc03fb4..c093be47 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/query/internal/DNF2PQuery.java
+++ b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/pquery/DNF2PQuery.java
@@ -1,17 +1,5 @@
-package tools.refinery.store.query.internal;
+package tools.refinery.store.query.viatra.internal.pquery;
 
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.InputMismatchException;
-import java.util.LinkedHashSet;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
-
-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.PVariable;
 import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.Equality;
@@ -21,39 +9,35 @@ import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.NegativeP
 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.BasePQuery;
 import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PParameter;
-import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PVisibility;
 import org.eclipse.viatra.query.runtime.matchers.tuple.Tuples;
+import tools.refinery.store.query.building.*;
 
-import tools.refinery.store.query.building.DNFAnd;
-import tools.refinery.store.query.building.DNFAtom;
-import tools.refinery.store.query.building.DNFPredicate;
-import tools.refinery.store.query.building.EquivalenceAtom;
-import tools.refinery.store.query.building.PredicateAtom;
-import tools.refinery.store.query.building.RelationAtom;
-import tools.refinery.store.query.building.Variable;
+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 DNF2PQuery().new SimplePQuery(predicate.getName());
+                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()) {
+                for (var param : predicate.getVariables()) {
                         parameterList.add(parameters.get(param));
                 }
-                query.setParameter(parameterList);
+                query.setParameters(parameterList);
                 for (DNFAnd clause : predicate.getClauses()) {
                         PBody body = new PBody(query);
                         List<ExportedParameter> symbolicParameters = new ArrayList<>();
-                        for(var param : predicate.getVariables()) {
+                        for (var param : predicate.getVariables()) {
                                 PVariable pVar = body.getOrCreateVariableByName(param.getName());
                                 symbolicParameters.add(new ExportedParameter(body, pVar, parameters.get(param)));
                         }
@@ -67,7 +51,8 @@ public class DNF2PQuery {
                 return query;
         }
 
-        private static void translateDNFAtom(DNFAtom constraint, PBody body, Map<DNFPredicate, SimplePQuery> dnf2PQueryMap) {
+        private static void translateDNFAtom(DNFAtom constraint, PBody body,
+                                                                                 Map<DNFPredicate, SimplePQuery> dnf2PQueryMap) {
                 if (constraint instanceof EquivalenceAtom equivalence) {
                         translateEquivalenceAtom(equivalence, body);
                 }
@@ -89,18 +74,19 @@ public class DNF2PQuery {
         }
 
         private static void translateRelationAtom(RelationAtom relation, PBody body) {
-                if (relation.getSubstitution().size() != relation.getView().getArity()) {
-                        throw new IllegalArgumentException("Arity (" + relation.getView().getArity()
-                                        + ") does not match parameter numbers (" + relation.getSubstitution().size() + ")");
+                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.getSubstitution().size()];
-                for (int i = 0; i < relation.getSubstitution().size(); i++) {
-                        variables[i] = body.getOrCreateVariableByName(relation.getSubstitution().get(i).getName());
+                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.getView());
+                new TypeConstraint(body, Tuples.flatTupleOf(variables), relation.view());
         }
 
-        private static void translatePredicateAtom(PredicateAtom predicate, PBody body, Map<DNFPredicate, SimplePQuery> dnf2PQueryMap) {
+        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());
@@ -125,65 +111,4 @@ public class DNF2PQuery {
                         }
                 }
         }
-
-        public class SimplePQuery extends BasePQuery {
-
-                private String fullyQualifiedName;
-                private List<PParameter> parameters;
-                private LinkedHashSet<PBody> bodies = new LinkedHashSet<>();
-
-                public SimplePQuery(String name) {
-                        super(PVisibility.PUBLIC);
-                        fullyQualifiedName = name;
-                }
-
-                @Override
-                public String getFullyQualifiedName() {
-                        return fullyQualifiedName;
-                }
-
-                public void setParameter(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() {
-                        setEvaluationHints(new QueryEvaluationHint(null, QueryEvaluationHint.BackendRequirement.UNSPECIFIED));
-                        return bodies;
-                }
-
-                public GenericQuerySpecification<RawPatternMatcher> build() {
-                        return new GenericQuerySpecification<RawPatternMatcher>(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);
-                                }
-
-                        };
-                }
-        }
-}
\ No newline at end of file
+}
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/src/main/java/tools/refinery/store/query/internal/ModelUpdateListener.java b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/viewupdate/ModelUpdateListener.java
index aa80985f..25919888 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/query/internal/ModelUpdateListener.java
+++ b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/viewupdate/ModelUpdateListener.java
@@ -1,22 +1,22 @@
-package tools.refinery.store.query.internal;
-
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.Map;
-import java.util.Set;
+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.
          */
@@ -35,18 +35,18 @@ public class ModelUpdateListener {
                 Relation<?> relation = view.getRepresentation();
 
                 // 1. register views to relations, if necessary
-                var views = relation2View.computeIfAbsent(relation, x->new HashSet<>());
+                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<>());
+                view2Buffers.computeIfAbsent(view, x -> new HashSet<>());
         }
 
-        boolean containsRelationalView(RelationView<?> relationalKey) {
+        public boolean containsRelationalView(RelationView<?> relationalKey) {
                 return view2Buffers.containsKey(relationalKey);
         }
 
-        <D> void addListener(RelationView<D> relationView, ITuple seed, IQueryRuntimeContextListener listener) {
+        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);
@@ -55,38 +55,40 @@ public class ModelUpdateListener {
                         throw new IllegalArgumentException();
         }
 
-        void removeListener(RelationView<?> relationView, ITuple seed, IQueryRuntimeContextListener listener) {
+        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().key == seed && buffer.getUpdateListener().listener == listener) {
+                        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();
+                } 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) {
-                        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);
-                                }
+                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 hasChange() {
+        public boolean hasChanges() {
                 for (var bufferCollection : this.view2Buffers.values()) {
                         for (ViewUpdateBuffer<?> buffer : bufferCollection) {
-                                if (buffer.hasChange())
+                                if (buffer.hasChanges())
                                         return true;
                         }
                 }
diff --git a/subprojects/store/src/main/java/tools/refinery/store/query/internal/ViewUpdate.java b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/viewupdate/ViewUpdate.java
index 7d1a4c05..c727f046 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/query/internal/ViewUpdate.java
+++ b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/viewupdate/ViewUpdate.java
@@ -1,4 +1,4 @@
-package tools.refinery.store.query.internal;
+package tools.refinery.store.query.viatra.internal.viewupdate;
 
 import java.util.Arrays;
 import java.util.Objects;
@@ -30,5 +30,5 @@ record ViewUpdate (Object[] tuple, boolean isInsertion) {
         public String toString() {
                 return "ViewUpdate [" + Arrays.toString(tuple) + "insertion= "+this.isInsertion+"]";
         }
-        
+
 }
diff --git a/subprojects/store/src/main/java/tools/refinery/store/query/internal/ViewUpdateBuffer.java b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/viewupdate/ViewUpdateBuffer.java
index 6bc4c96a..5a4243f2 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/query/internal/ViewUpdateBuffer.java
+++ b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/viewupdate/ViewUpdateBuffer.java
@@ -1,42 +1,42 @@
-package tools.refinery.store.query.internal;
+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;
 
-import tools.refinery.store.model.Tuple;
-
 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 hasChange() {
-                return ! buffer.isEmpty();
+
+        public boolean hasChanges() {
+                return !buffer.isEmpty();
         }
-        
+
         public void addChange(Tuple tuple, D oldValue, D newValue) {
-                if(oldValue != newValue) {
+                if (oldValue != newValue) {
                         Object[] oldTuple = updateListener.isMatching(tuple, oldValue);
                         Object[] newTuple = updateListener.isMatching(tuple, newValue);
-                        if(!Arrays.equals(oldTuple, newTuple)) {
-                                if(oldTuple != null) {
+                        if (!Arrays.equals(oldTuple, newTuple)) {
+                                if (oldTuple != null) {
                                         buffer.add(new ViewUpdate(oldTuple, false));
                                 }
-                                if(newTuple != null) {
+                                if (newTuple != null) {
                                         buffer.add(new ViewUpdate(newTuple, true));
                                 }
                         }
                 }
         }
-        
+
         public void flush() {
                 for (ViewUpdate viewChange : buffer) {
                         updateListener.processChange(viewChange);
diff --git a/subprojects/store/src/main/java/tools/refinery/store/query/internal/ViewUpdateTranslator.java b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/viewupdate/ViewUpdateTranslator.java
index 1c210c5f..2f7f9a9c 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/query/internal/ViewUpdateTranslator.java
+++ b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/viewupdate/ViewUpdateTranslator.java
@@ -1,38 +1,44 @@
-package tools.refinery.store.query.internal;
-
-import java.util.Objects;
+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> {
-        final RelationView<D> key;
-        final ITuple filter;
-        final IQueryRuntimeContextListener listener;
-        
+        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){
+        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++) {
+                for (int i = 0; i < filter.getSize(); i++) {
                         final Object filterObject = filter.get(i);
-                        if(filterObject != null && !filterObject.equals(tuple[i])) {
+                        if (filterObject != null && !filterObject.equals(tuple[i])) {
                                 return null;
                         }
                 }
@@ -48,9 +54,8 @@ public class ViewUpdateTranslator<D> {
         public boolean equals(Object obj) {
                 if (this == obj)
                         return true;
-                if (!(obj instanceof ViewUpdateTranslator))
+                if (!(obj instanceof ViewUpdateTranslator<?> other))
                         return false;
-                ViewUpdateTranslator<?> other = (ViewUpdateTranslator<?>) obj;
                 return Objects.equals(filter, other.filter) && Objects.equals(key, other.key)
                                 && Objects.equals(listener, other.listener);
         }
diff --git a/subprojects/store/src/test/java/tools/refinery/store/query/test/QueryTest.java b/subprojects/store-query-viatra/src/test/java/tools/refinery/store/query/viatra/tests/QueryTest.java
index 02381bcd..4307ab6b 100644
--- a/subprojects/store/src/test/java/tools/refinery/store/query/test/QueryTest.java
+++ b/subprojects/store-query-viatra/src/test/java/tools/refinery/store/query/viatra/tests/QueryTest.java
@@ -1,64 +1,37 @@
-package tools.refinery.store.query.test;
-
-import static org.junit.jupiter.api.Assertions.assertEquals;
-
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Collections;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Set;
-import java.util.stream.Stream;
+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.QueriableModel;
-import tools.refinery.store.query.QueriableModelStore;
-import tools.refinery.store.query.QueriableModelStoreImpl;
-import tools.refinery.store.query.building.DNFAnd;
-import tools.refinery.store.query.building.DNFPredicate;
-import tools.refinery.store.query.building.EquivalenceAtom;
-import tools.refinery.store.query.building.PredicateAtom;
-import tools.refinery.store.query.building.RelationAtom;
-import tools.refinery.store.query.building.Variable;
+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;
 
-class QueryTest {
-
-        static void compareMatchSets(Stream<Object[]> matchSet, Set<List<Tuple>> expected) {
-                Set<List<Tuple>> translatedMatchSet = new HashSet<>();
-                var interator = matchSet.iterator();
-                while (interator.hasNext()) {
-                        var element = interator.next();
-                        List<Tuple> elementToTranslatedMatchSet = new ArrayList<>();
-                        for (int i = 0; i < element.length; i++) {
-                                elementToTranslatedMatchSet.add((Tuple) element[i]);
-                        }
-                        translatedMatchSet.add(elementToTranslatedMatchSet);
-                }
+import java.util.*;
+import java.util.stream.Stream;
 
-                assertEquals(expected, translatedMatchSet);
-        }
+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> persionView = new KeyOnlyRelationView(person);
+                RelationView<Boolean> personView = new KeyOnlyRelationView(person);
 
-                List<Variable> parameters = Arrays.asList(new Variable("p1"));
-                RelationAtom personRelationAtom = new RelationAtom(persionView, parameters);
-                DNFAnd clause = new DNFAnd(Collections.emptySet(), Arrays.asList(personRelationAtom));
-                DNFPredicate predicate = new DNFPredicate("TypeConstraint", parameters, Arrays.asList(clause));
+                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));
 
-                QueriableModelStore store = new QueriableModelStoreImpl(Set.of(person, asset), Set.of(persionView),
+                QueryableModelStore store = new ViatraQueryableModelStore(Set.of(person, asset), Set.of(personView),
                                 Set.of(predicate));
-                QueriableModel model = store.createModel();
+                QueryableModel model = store.createModel();
 
                 model.put(person, Tuple.of(0), true);
                 model.put(person, Tuple.of(1), true);
@@ -74,23 +47,23 @@ class QueryTest {
         void relationConstraintTest() {
                 Relation<Boolean> person = new Relation<Boolean>("Person", 1, false);
                 Relation<TruthValue> friend = new Relation<>("friend", 2, TruthValue.FALSE);
-                RelationView<Boolean> persionView = new KeyOnlyRelationView(person);
+                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(persionView, Arrays.asList(p1));
-                RelationAtom personRelationAtom2 = new RelationAtom(persionView, Arrays.asList(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, Arrays.asList(clause));
+                DNFPredicate predicate = new DNFPredicate("RelationConstraint", parameters, List.of(clause));
 
-                QueriableModelStore store = new QueriableModelStoreImpl(Set.of(person, friend),
-                                Set.of(persionView, friendMustView), Set.of(predicate));
-                QueriableModel model = store.createModel();
+                QueryableModelStore store = new ViatraQueryableModelStore(Set.of(person, friend),
+                                Set.of(personView, friendMustView), Set.of(predicate));
+                QueryableModel model = store.createModel();
 
                 assertEquals(0, model.countResults(predicate));
 
@@ -113,24 +86,24 @@ class QueryTest {
         void andTest() {
                 Relation<Boolean> person = new Relation<Boolean>("Person", 1, false);
                 Relation<TruthValue> friend = new Relation<>("friend", 2, TruthValue.FALSE);
-                RelationView<Boolean> persionView = new KeyOnlyRelationView(person);
+                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(persionView, Arrays.asList(p1));
-                RelationAtom personRelationAtom2 = new RelationAtom(persionView, Arrays.asList(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, Arrays.asList(clause));
+                DNFPredicate predicate = new DNFPredicate("RelationConstraint", parameters, List.of(clause));
 
-                QueriableModelStore store = new QueriableModelStoreImpl(Set.of(person, friend),
-                                Set.of(persionView, friendMustView), Set.of(predicate));
-                QueriableModel model = store.createModel();
+                QueryableModelStore store = new ViatraQueryableModelStore(Set.of(person, friend),
+                                Set.of(personView, friendMustView), Set.of(predicate));
+                QueryableModel model = store.createModel();
 
                 assertEquals(0, model.countResults(predicate));
 
@@ -162,23 +135,23 @@ class QueryTest {
         void existTest() {
                 Relation<Boolean> person = new Relation<Boolean>("Person", 1, false);
                 Relation<TruthValue> friend = new Relation<>("friend", 2, TruthValue.FALSE);
-                RelationView<Boolean> persionView = new KeyOnlyRelationView(person);
+                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);
+                List<Variable> parameters = List.of(p1);
 
-                RelationAtom personRelationAtom1 = new RelationAtom(persionView, Arrays.asList(p1));
-                RelationAtom personRelationAtom2 = new RelationAtom(persionView, Arrays.asList(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(Set.of(p2),
                                 Arrays.asList(personRelationAtom1, personRelationAtom2, friendRelationAtom));
-                DNFPredicate predicate = new DNFPredicate("RelationConstraint", parameters, Arrays.asList(clause));
+                DNFPredicate predicate = new DNFPredicate("RelationConstraint", parameters, List.of(clause));
 
-                QueriableModelStore store = new QueriableModelStoreImpl(Set.of(person, friend),
-                                Set.of(persionView, friendMustView), Set.of(predicate));
-                QueriableModel model = store.createModel();
+                QueryableModelStore store = new ViatraQueryableModelStore(Set.of(person, friend),
+                                Set.of(personView, friendMustView), Set.of(predicate));
+                QueryableModel model = store.createModel();
 
                 assertEquals(0, model.countResults(predicate));
 
@@ -201,7 +174,7 @@ class QueryTest {
                 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> persionView = new KeyOnlyRelationView(person);
+                RelationView<Boolean> personView = new KeyOnlyRelationView(person);
                 RelationView<Boolean> animalView = new KeyOnlyRelationView(animal);
                 RelationView<TruthValue> friendMustView = new FilteredRelationView<TruthValue>(friend, (k, v) -> v.must());
 
@@ -210,15 +183,15 @@ class QueryTest {
                 List<Variable> parameters = Arrays.asList(p1, p2);
 
                 // Person-Person friendship
-                RelationAtom personRelationAtom1 = new RelationAtom(persionView, Arrays.asList(p1));
-                RelationAtom personRelationAtom2 = new RelationAtom(persionView, Arrays.asList(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));
                 DNFAnd clause1 = new DNFAnd(Collections.emptySet(),
                                 Arrays.asList(personRelationAtom1, personRelationAtom2, friendRelationAtom1));
 
                 // Animal-Animal friendship
-                RelationAtom animalRelationAtom1 = new RelationAtom(animalView, Arrays.asList(p1));
-                RelationAtom animalRelationAtom2 = new RelationAtom(animalView, Arrays.asList(p2));
+                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));
@@ -227,9 +200,9 @@ class QueryTest {
 
                 DNFPredicate predicate = new DNFPredicate("Or", parameters, Arrays.asList(clause1, clause2));
 
-                QueriableModelStore store = new QueriableModelStoreImpl(Set.of(person, animal, friend),
-                                Set.of(persionView, animalView, friendMustView), Set.of(predicate));
-                QueriableModel model = store.createModel();
+                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);
@@ -249,21 +222,21 @@ class QueryTest {
         @Test
         void equalityTest() {
                 Relation<Boolean> person = new Relation<Boolean>("Person", 1, false);
-                RelationView<Boolean> persionView = new KeyOnlyRelationView(person);
+                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(persionView, Arrays.asList(p1));
-                RelationAtom personRelationAtom2 = new RelationAtom(persionView, Arrays.asList(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, Arrays.asList(clause));
+                DNFPredicate predicate = new DNFPredicate("Equality", parameters, List.of(clause));
 
-                QueriableModelStore store = new QueriableModelStoreImpl(Set.of(person), Set.of(persionView), Set.of(predicate));
-                QueriableModel model = store.createModel();
+                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);
@@ -279,7 +252,7 @@ class QueryTest {
         void inequalityTest() {
                 Relation<Boolean> person = new Relation<Boolean>("Person", 1, false);
                 Relation<TruthValue> friend = new Relation<>("friend", 2, TruthValue.FALSE);
-                RelationView<Boolean> persionView = new KeyOnlyRelationView(person);
+                RelationView<Boolean> personView = new KeyOnlyRelationView(person);
                 RelationView<TruthValue> friendMustView = new FilteredRelationView<TruthValue>(friend, (k, v) -> v.must());
 
                 Variable p1 = new Variable("p1");
@@ -287,18 +260,18 @@ class QueryTest {
                 Variable p3 = new Variable("p3");
                 List<Variable> parameters = Arrays.asList(p1, p2, p3);
 
-                RelationAtom personRelationAtom1 = new RelationAtom(persionView, Arrays.asList(p1));
-                RelationAtom personRelationAtom2 = new RelationAtom(persionView, Arrays.asList(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, 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, Arrays.asList(clause));
+                DNFPredicate predicate = new DNFPredicate("Inequality", parameters, List.of(clause));
 
-                QueriableModelStore store = new QueriableModelStoreImpl(Set.of(person, friend),
-                                Set.of(persionView, friendMustView), Set.of(predicate));
-                QueriableModel model = store.createModel();
+                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);
@@ -316,33 +289,33 @@ class QueryTest {
         void patternCallTest() {
                 Relation<Boolean> person = new Relation<Boolean>("Person", 1, false);
                 Relation<TruthValue> friend = new Relation<>("friend", 2, TruthValue.FALSE);
-                RelationView<Boolean> persionView = new KeyOnlyRelationView(person);
+                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(persionView, Arrays.asList(p1));
-                RelationAtom personRelationAtom2 = new RelationAtom(persionView, Arrays.asList(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, Arrays.asList(clause));
+                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(persionView, Arrays.asList(p3));
-                RelationAtom personRelationAtom4 = new RelationAtom(persionView, Arrays.asList(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, Arrays.asList(patternCallClause));
+                DNFPredicate predicate = new DNFPredicate("PatternCall", substitution, List.of(patternCallClause));
 
-                QueriableModelStore store = new QueriableModelStoreImpl(Set.of(person, friend),
-                                Set.of(persionView, friendMustView), Set.of(friendPredicate, predicate));
-                QueriableModel model = store.createModel();
+                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);
@@ -360,34 +333,34 @@ class QueryTest {
         void negativePatternCallTest() {
                 Relation<Boolean> person = new Relation<Boolean>("Person", 1, false);
                 Relation<TruthValue> friend = new Relation<>("friend", 2, TruthValue.FALSE);
-                RelationView<Boolean> persionView = new KeyOnlyRelationView(person);
+                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(persionView, Arrays.asList(p1));
-                RelationAtom personRelationAtom2 = new RelationAtom(persionView, Arrays.asList(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, Arrays.asList(clause));
+                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(persionView, Arrays.asList(p3));
-                RelationAtom personRelationAtom4 = new RelationAtom(persionView, Arrays.asList(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,
-                                Arrays.asList(negativePatternCallClause));
+                                List.of(negativePatternCallClause));
 
-                QueriableModelStore store = new QueriableModelStoreImpl(Set.of(person, friend),
-                                Set.of(persionView, friendMustView), Set.of(friendPredicate, predicate));
-                QueriableModel model = store.createModel();
+                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);
@@ -404,42 +377,56 @@ class QueryTest {
         void transitivePatternCallTest() {
                 Relation<Boolean> person = new Relation<Boolean>("Person", 1, false);
                 Relation<TruthValue> friend = new Relation<>("friend", 2, TruthValue.FALSE);
-                RelationView<Boolean> persionView = new KeyOnlyRelationView(person);
+                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(persionView, Arrays.asList(p1));
-                RelationAtom personRelationAtom2 = new RelationAtom(persionView, Arrays.asList(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, Arrays.asList(clause));
+                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(persionView, Arrays.asList(p3));
-                RelationAtom personRelationAtom4 = new RelationAtom(persionView, Arrays.asList(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,
-                                Arrays.asList(patternCallClause));
+                                List.of(patternCallClause));
 
-                QueriableModelStore store = new QueriableModelStoreImpl(Set.of(person, friend),
-                                Set.of(persionView, friendMustView), Set.of(friendPredicate, predicate));
-                QueriableModel model = store.createModel();
+                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));
         }
-}
\ No newline at end of file
+        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/src/test/java/tools/refinery/store/query/test/QueryTransactionTest.java b/subprojects/store-query-viatra/src/test/java/tools/refinery/store/query/viatra/tests/QueryTransactionTest.java
index e72186b9..613d0074 100644
--- a/subprojects/store/src/test/java/tools/refinery/store/query/test/QueryTransactionTest.java
+++ b/subprojects/store-query-viatra/src/test/java/tools/refinery/store/query/viatra/tests/QueryTransactionTest.java
@@ -1,41 +1,39 @@
-package tools.refinery.store.query.test;
-
-import static org.junit.jupiter.api.Assertions.assertEquals;
-
-import java.util.Arrays;
-import java.util.Collections;
-import java.util.List;
-import java.util.Set;
+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.QueriableModel;
-import tools.refinery.store.query.QueriableModelStore;
-import tools.refinery.store.query.QueriableModelStoreImpl;
+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> persionView = new KeyOnlyRelationView(person);
+                RelationView<Boolean> personView = new KeyOnlyRelationView(person);
 
-                List<Variable> parameters = Arrays.asList(new Variable("p1"));
-                RelationAtom personRelationAtom = new RelationAtom(persionView, parameters);
-                DNFAnd clause = new DNFAnd(Collections.emptySet(), Arrays.asList(personRelationAtom));
-                DNFPredicate predicate = new DNFPredicate("TypeConstraint", parameters, Arrays.asList(clause));
+                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));
 
-                QueriableModelStore store = new QueriableModelStoreImpl(Set.of(person, asset), Set.of(persionView),
+                QueryableModelStore store = new ViatraQueryableModelStore(Set.of(person, asset), Set.of(personView),
                                 Set.of(predicate));
-                QueriableModel model = store.createModel();
+                QueryableModel model = store.createModel();
 
                 assertEquals(0, model.countResults(predicate));
 
@@ -48,10 +46,10 @@ class QueryTransactionTest {
 
                 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));
         }
diff --git a/subprojects/store/src/main/java/tools/refinery/store/query/QueriableModel.java b/subprojects/store/src/main/java/tools/refinery/store/query/QueryableModel.java
index f669b3ed..187abbc2 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/query/QueriableModel.java
+++ b/subprojects/store/src/main/java/tools/refinery/store/query/QueryableModel.java
@@ -1,15 +1,17 @@
 package tools.refinery.store.query;
 
+import tools.refinery.store.model.Model;
+import tools.refinery.store.query.building.DNFPredicate;
+
 import java.util.Optional;
 import java.util.Set;
 import java.util.stream.Stream;
 
-import tools.refinery.store.model.Model;
-import tools.refinery.store.query.building.DNFPredicate;
-
-public interface QueriableModel extends Model{
+public interface QueryableModel extends Model{
         Set<DNFPredicate> getPredicates();
-        
+
+        boolean hasChanges();
+
         void flushChanges();
 
         boolean hasResult(DNFPredicate predicate);
diff --git a/subprojects/store/src/main/java/tools/refinery/store/query/QueriableModelStore.java b/subprojects/store/src/main/java/tools/refinery/store/query/QueryableModelStore.java
index 3a5b51ff..08efe17c 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/query/QueriableModelStore.java
+++ b/subprojects/store/src/main/java/tools/refinery/store/query/QueryableModelStore.java
@@ -1,23 +1,23 @@
 package tools.refinery.store.query;
 
-import java.util.Set;
-
 import tools.refinery.store.model.ModelDiffCursor;
 import tools.refinery.store.model.ModelStore;
 import tools.refinery.store.model.representation.DataRepresentation;
 import tools.refinery.store.query.building.DNFPredicate;
 import tools.refinery.store.query.view.RelationView;
 
-public interface QueriableModelStore extends ModelStore{
+import java.util.Set;
+
+public interface QueryableModelStore extends ModelStore{
         @SuppressWarnings("squid:S1452")
         Set<DataRepresentation<?, ?>> getDataRepresentations();
         @SuppressWarnings("squid:S1452")
         Set<RelationView<?>> getViews();
         Set<DNFPredicate> getPredicates();
-        
-        QueriableModel createModel();
-        QueriableModel createModel(long state);
-        
+
+        QueryableModel createModel();
+        QueryableModel createModel(long state);
+
         Set<Long> getStates();
         ModelDiffCursor getDiffCursor(long from, long to);
 }
diff --git a/subprojects/store/src/main/java/tools/refinery/store/query/building/RelationAtom.java b/subprojects/store/src/main/java/tools/refinery/store/query/building/RelationAtom.java
index 1238f1d7..f66245fc 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/query/building/RelationAtom.java
+++ b/subprojects/store/src/main/java/tools/refinery/store/query/building/RelationAtom.java
@@ -1,35 +1,17 @@
 package tools.refinery.store.query.building;
 
+import tools.refinery.store.query.view.RelationView;
+
+import java.util.ArrayList;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
 
-import tools.refinery.store.query.view.FilteredRelationView;
-import tools.refinery.store.query.view.RelationView;
-
-public class RelationAtom implements DNFAtom {
-        RelationView<?> view;
-        List<Variable> substitution;
-
+public record RelationAtom(RelationView<?> view, List<Variable> substitution) implements DNFAtom {
         public RelationAtom(RelationView<?> view, List<Variable> substitution) {
                 this.view = view;
-                this.substitution = substitution;
-        }
-
-        public RelationView<?> getView() {
-                return view;
-        }
-
-        public void setView(FilteredRelationView<?> view) {
-                this.view = view;
-        }
-
-        public List<Variable> getSubstitution() {
-                return substitution;
-        }
-
-        public void setSubstitution(List<Variable> substitution) {
-                this.substitution = substitution;
+                // Create a mutable copy of substitution so that unifyVariables can change it.
+                this.substitution = new ArrayList<>(substitution);
         }
 
         @Override
diff --git a/subprojects/store/src/main/java/tools/refinery/store/query/internal/PredicateResult.java b/subprojects/store/src/main/java/tools/refinery/store/query/internal/PredicateResult.java
deleted file mode 100644
index 65d23eb6..00000000
--- a/subprojects/store/src/main/java/tools/refinery/store/query/internal/PredicateResult.java
+++ /dev/null
@@ -1,24 +0,0 @@
-package tools.refinery.store.query.internal;
-
-import java.util.Optional;
-import java.util.stream.Stream;
-
-public interface PredicateResult {
-
-        boolean hasResult();
-
-        boolean hasResult(Object[] parameters);
-
-        Optional<Object[]> oneResult();
-
-        Optional<Object[]> oneResult(Object[] parameters);
-
-        Stream<Object[]> allResults();
-
-        Stream<Object[]> allResults(Object[] parameters);
-
-        int countResults();
-
-        int countResults(Object[] parameters);
-
-}
\ No newline at end of file
diff --git a/subprojects/store/src/main/java/tools/refinery/store/query/internal/RelationalQueryMetaContext.java b/subprojects/store/src/main/java/tools/refinery/store/query/internal/RelationalQueryMetaContext.java
deleted file mode 100644
index 05fb0904..00000000
--- a/subprojects/store/src/main/java/tools/refinery/store/query/internal/RelationalQueryMetaContext.java
+++ /dev/null
@@ -1,58 +0,0 @@
-package tools.refinery.store.query.internal;
-
-import java.util.Collection;
-import java.util.Collections;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.Map;
-import java.util.Set;
-
-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;
-
-/**
- * The meta context information for String scopes.
- */
-public final class RelationalQueryMetaContext extends AbstractQueryMetaContext {
-
-        @Override
-        public boolean isEnumerable(IInputKey key) {            
-        ensureValidKey(key);
-        return key.isEnumerable();
-        }
-
-        @Override
-        public boolean isStateless(IInputKey key) {
-        ensureValidKey(key);
-        return key instanceof RelationView<?>;
-        }
-
-        @Override
-        public Collection<InputKeyImplication> getImplications(IInputKey implyingKey) {
-        ensureValidKey(implyingKey);
-        return new HashSet<InputKeyImplication>();
-        }               
-
-        @Override
-    public Map<Set<Integer>, Set<Integer>> getFunctionalDependencies(IInputKey key) {
-        ensureValidKey(key);
-        if (key instanceof RelationView) {
-            return new HashMap<Set<Integer>, Set<Integer>>();
-        } else {
-            return Collections.emptyMap();
-        }
-    }
-
-    public void ensureValidKey(IInputKey key) {
-        if (! (key instanceof RelationView<?>))
-            illegalInputKey(key);
-    }
-
-    public void illegalInputKey(IInputKey key) {
-        throw new IllegalArgumentException("The input key " + key + " is not a valid input key.");
-    }
-        
-}