refactor: rename RelationView to SymbolView

* Add NodeFunctionView for symbols that hold function-like (single
  associated object for each key) relations as integer values for performance.

15 files changed, 190 insertions, 190 deletions

diff --git a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/ViatraModelQueryBuilderImpl.java b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/ViatraModelQueryBuilderImpl.java
index 999d349a..44ed1505 100644
--- a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/ViatraModelQueryBuilderImpl.java
+++ b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/ViatraModelQueryBuilderImpl.java
@@ -117,7 +117,7 @@ public class ViatraModelQueryBuilderImpl extends AbstractModelAdapterBuilder imp
         public ViatraModelQueryStoreAdapterImpl createStoreAdapter(ModelStore store) {
                 validateSymbols(store);
                 dnf2PQuery.assertNoUnusedHints();
-                return new ViatraModelQueryStoreAdapterImpl(store, buildEngineOptions(), dnf2PQuery.getRelationViews(),
+                return new ViatraModelQueryStoreAdapterImpl(store, buildEngineOptions(), dnf2PQuery.getSymbolViews(),
                                 Collections.unmodifiableMap(querySpecifications), Collections.unmodifiableSet(vacuousQueries));
         }
 
@@ -140,11 +140,11 @@ public class ViatraModelQueryBuilderImpl extends AbstractModelAdapterBuilder imp
 
         private void validateSymbols(ModelStore store) {
                 var symbols = store.getSymbols();
-                for (var relationView : dnf2PQuery.getRelationViews().keySet()) {
-                        var symbol = relationView.getSymbol();
+                for (var symbolView : dnf2PQuery.getSymbolViews().keySet()) {
+                        var symbol = symbolView.getSymbol();
                         if (!symbols.contains(symbol)) {
-                                throw new IllegalArgumentException("Cannot query relation view %s: symbol %s is not in the model"
-                                                .formatted(relationView, symbol));
+                                throw new IllegalArgumentException("Cannot query view %s: symbol %s is not in the model"
+                                                .formatted(symbolView, symbol));
                         }
                 }
         }
diff --git a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/ViatraModelQueryStoreAdapterImpl.java b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/ViatraModelQueryStoreAdapterImpl.java
index aa102a35..11a3c7fd 100644
--- a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/ViatraModelQueryStoreAdapterImpl.java
+++ b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/ViatraModelQueryStoreAdapterImpl.java
@@ -13,20 +13,20 @@ import tools.refinery.store.model.ModelStore;
 import tools.refinery.store.query.dnf.AnyQuery;
 import tools.refinery.store.query.viatra.ViatraModelQueryStoreAdapter;
 import tools.refinery.store.query.viatra.internal.matcher.RawPatternMatcher;
-import tools.refinery.store.query.view.AnyRelationView;
+import tools.refinery.store.query.view.AnySymbolView;
 
 import java.util.*;
 
 public class ViatraModelQueryStoreAdapterImpl implements ViatraModelQueryStoreAdapter {
         private final ModelStore store;
         private final ViatraQueryEngineOptions engineOptions;
-        private final Map<AnyRelationView, IInputKey> inputKeys;
+        private final Map<AnySymbolView, IInputKey> inputKeys;
         private final Map<AnyQuery, IQuerySpecification<RawPatternMatcher>> querySpecifications;
         private final Set<AnyQuery> vacuousQueries;
         private final Set<AnyQuery> allQueries;
 
         ViatraModelQueryStoreAdapterImpl(ModelStore store, ViatraQueryEngineOptions engineOptions,
-                                                                         Map<AnyRelationView, IInputKey> inputKeys,
+                                                                         Map<AnySymbolView, IInputKey> inputKeys,
                                                                          Map<AnyQuery, IQuerySpecification<RawPatternMatcher>> querySpecifications,
                                                                          Set<AnyQuery> vacuousQueries) {
                 this.store = store;
@@ -45,11 +45,11 @@ public class ViatraModelQueryStoreAdapterImpl implements ViatraModelQueryStoreAd
                 return store;
         }
 
-        public Collection<AnyRelationView> getRelationViews() {
+        public Collection<AnySymbolView> getSymbolViews() {
                 return inputKeys.keySet();
         }
 
-        public Map<AnyRelationView, IInputKey> getInputKeys() {
+        public Map<AnySymbolView, IInputKey> getInputKeys() {
                 return inputKeys;
         }
 
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
index 07a5a6ea..cf96b7fd 100644
--- 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
@@ -10,8 +10,8 @@ import org.eclipse.viatra.query.runtime.matchers.context.IInputKey;
 import org.eclipse.viatra.query.runtime.matchers.context.InputKeyImplication;
 import org.eclipse.viatra.query.runtime.matchers.context.common.JavaTransitiveInstancesKey;
 import tools.refinery.store.query.term.DataSort;
-import tools.refinery.store.query.viatra.internal.pquery.RelationViewWrapper;
-import tools.refinery.store.query.view.AnyRelationView;
+import tools.refinery.store.query.viatra.internal.pquery.SymbolViewWrapper;
+import tools.refinery.store.query.view.AnySymbolView;
 
 import java.util.*;
 
@@ -19,9 +19,9 @@ import java.util.*;
  * The meta context information for String scopes.
  */
 public class RelationalQueryMetaContext extends AbstractQueryMetaContext {
-        private final Map<AnyRelationView, IInputKey> inputKeys;
+        private final Map<AnySymbolView, IInputKey> inputKeys;
 
-        RelationalQueryMetaContext(Map<AnyRelationView, IInputKey> inputKeys) {
+        RelationalQueryMetaContext(Map<AnySymbolView, IInputKey> inputKeys) {
                 this.inputKeys = inputKeys;
         }
 
@@ -47,23 +47,23 @@ public class RelationalQueryMetaContext extends AbstractQueryMetaContext {
                 if (implyingKey instanceof JavaTransitiveInstancesKey) {
                         return List.of();
                 }
-                var relationView = checkKey(implyingKey);
-                var relationViewImplications = relationView.getImpliedRelationViews();
+                var symbolView = checkKey(implyingKey);
+                var relationViewImplications = symbolView.getImpliedRelationViews();
                 var inputKeyImplications = new HashSet<InputKeyImplication>(relationViewImplications.size());
                 for (var relationViewImplication : relationViewImplications) {
-                        if (!relationView.equals(relationViewImplication.implyingRelationView())) {
+                        if (!symbolView.equals(relationViewImplication.implyingView())) {
                                 throw new IllegalArgumentException("Relation view %s returned unrelated implication %s".formatted(
-                                                relationView, relationViewImplication));
+                                                symbolView, relationViewImplication));
                         }
-                        var impliedInputKey = inputKeys.get(relationViewImplication.impliedRelationView());
+                        var impliedInputKey = inputKeys.get(relationViewImplication.impliedView());
                         // Ignore implications not relevant for any queries included in the model.
                         if (impliedInputKey != null) {
                                 inputKeyImplications.add(new InputKeyImplication(implyingKey, impliedInputKey,
                                                 relationViewImplication.impliedIndices()));
                         }
                 }
-                var sorts = relationView.getSorts();
-                int arity = relationView.arity();
+                var sorts = symbolView.getSorts();
+                int arity = symbolView.arity();
                 for (int i = 0; i < arity; i++) {
                         var sort = sorts.get(i);
                         if (sort instanceof DataSort<?> dataSort) {
@@ -99,20 +99,20 @@ public class RelationalQueryMetaContext extends AbstractQueryMetaContext {
                 return flattened;
         }
 
-        private static void checkValidIndices(AnyRelationView relationView, Collection<Integer> indices) {
+        private static void checkValidIndices(AnySymbolView relationView, Collection<Integer> indices) {
                 indices.stream().filter(relationView::invalidIndex).findAny().ifPresent(i -> {
                         throw new IllegalArgumentException("Index %d is invalid for %s".formatted(i, relationView));
                 });
         }
 
-        public AnyRelationView checkKey(IInputKey key) {
-                if (!(key instanceof RelationViewWrapper wrapper)) {
+        public AnySymbolView checkKey(IInputKey key) {
+                if (!(key instanceof SymbolViewWrapper wrapper)) {
                         throw new IllegalArgumentException("The input key %s is not a valid input key".formatted(key));
                 }
-                var relationView = wrapper.getWrappedKey();
-                if (!inputKeys.containsKey(relationView)) {
+                var symbolView = wrapper.getWrappedKey();
+                if (!inputKeys.containsKey(symbolView)) {
                         throw new IllegalArgumentException("The input key %s is not present in the model".formatted(key));
                 }
-                return relationView;
+                return symbolView;
         }
 }
diff --git a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/context/RelationalRuntimeContext.java b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/context/RelationalRuntimeContext.java
index 71943737..0f2daca8 100644
--- a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/context/RelationalRuntimeContext.java
+++ b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/context/RelationalRuntimeContext.java
@@ -13,9 +13,9 @@ 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.ViatraModelQueryAdapterImpl;
-import tools.refinery.store.query.viatra.internal.pquery.RelationViewWrapper;
+import tools.refinery.store.query.viatra.internal.pquery.SymbolViewWrapper;
 import tools.refinery.store.query.viatra.internal.update.ModelUpdateListener;
-import tools.refinery.store.query.view.AnyRelationView;
+import tools.refinery.store.query.view.AnySymbolView;
 
 import java.lang.reflect.InvocationTargetException;
 import java.util.Iterator;
@@ -59,9 +59,9 @@ public class RelationalRuntimeContext implements IQueryRuntimeContext {
 
         @Override
         public boolean isIndexed(IInputKey key, IndexingService service) {
-                if (key instanceof RelationViewWrapper wrapper) {
-                        var relationalKey = wrapper.getWrappedKey();
-                        return this.modelUpdateListener.containsRelationView(relationalKey);
+                if (key instanceof SymbolViewWrapper wrapper) {
+                        var symbolViewKey = wrapper.getWrappedKey();
+                        return this.modelUpdateListener.containsSymbolView(symbolViewKey);
                 } else {
                         return false;
                 }
@@ -74,13 +74,13 @@ public class RelationalRuntimeContext implements IQueryRuntimeContext {
                 }
         }
 
-        AnyRelationView checkKey(IInputKey key) {
-                if (key instanceof RelationViewWrapper wrappedKey) {
-                        var relationViewKey = wrappedKey.getWrappedKey();
-                        if (modelUpdateListener.containsRelationView(relationViewKey)) {
-                                return relationViewKey;
+        AnySymbolView checkKey(IInputKey key) {
+                if (key instanceof SymbolViewWrapper wrappedKey) {
+                        var symbolViewKey = wrappedKey.getWrappedKey();
+                        if (modelUpdateListener.containsSymbolView(symbolViewKey)) {
+                                return symbolViewKey;
                         } else {
-                                throw new IllegalStateException("Query is asking for non-indexed key %s".formatted(relationViewKey));
+                                throw new IllegalStateException("Query is asking for non-indexed key %s".formatted(symbolViewKey));
                         }
                 } else {
                         throw new IllegalStateException("Query is asking for non-relational key");
diff --git a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/pquery/Dnf2PQuery.java b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/pquery/Dnf2PQuery.java
index 714d41c0..b511a5c7 100644
--- a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/pquery/Dnf2PQuery.java
+++ b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/pquery/Dnf2PQuery.java
@@ -29,7 +29,7 @@ import tools.refinery.store.query.term.ConstantTerm;
 import tools.refinery.store.query.term.StatefulAggregator;
 import tools.refinery.store.query.term.StatelessAggregator;
 import tools.refinery.store.query.term.Variable;
-import tools.refinery.store.query.view.AnyRelationView;
+import tools.refinery.store.query.view.AnySymbolView;
 import tools.refinery.store.util.CycleDetectingMapper;
 
 import java.util.*;
@@ -53,8 +53,8 @@ public class Dnf2PQuery {
                 return mapper.map(dnfQuery);
         }
 
-        public Map<AnyRelationView, IInputKey> getRelationViews() {
-                return wrapperFactory.getRelationViews();
+        public Map<AnySymbolView, IInputKey> getSymbolViews() {
+                return wrapperFactory.getSymbolViews();
         }
 
         public void hint(Dnf dnf, QueryEvaluationHint hint) {
@@ -165,8 +165,8 @@ public class Dnf2PQuery {
                         if (constraint instanceof Dnf dnf) {
                                 var pattern = translate(dnf);
                                 new PositivePatternCall(body, substitution, pattern);
-                        } else if (constraint instanceof AnyRelationView relationView) {
-                                var inputKey = wrapperFactory.getInputKey(relationView);
+                        } else if (constraint instanceof AnySymbolView symbolView) {
+                                var inputKey = wrapperFactory.getInputKey(symbolView);
                                 new TypeConstraint(body, substitution, inputKey);
                         } else {
                                 throw new IllegalArgumentException("Unknown Constraint: " + constraint);
@@ -178,8 +178,8 @@ public class Dnf2PQuery {
                         PQuery pattern;
                         if (constraint instanceof Dnf dnf) {
                                 pattern = translate(dnf);
-                        } else if (constraint instanceof AnyRelationView relationView) {
-                                pattern = wrapperFactory.wrapRelationViewIdentityArguments(relationView);
+                        } else if (constraint instanceof AnySymbolView symbolView) {
+                                pattern = wrapperFactory.wrapSymbolViewIdentityArguments(symbolView);
                         } else {
                                 throw new IllegalArgumentException("Unknown Constraint: " + constraint);
                         }
diff --git a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/pquery/QueryWrapperFactory.java b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/pquery/QueryWrapperFactory.java
index 30f848a6..0d046455 100644
--- a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/pquery/QueryWrapperFactory.java
+++ b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/pquery/QueryWrapperFactory.java
@@ -21,8 +21,8 @@ import tools.refinery.store.query.dnf.DnfClause;
 import tools.refinery.store.query.dnf.DnfUtils;
 import tools.refinery.store.query.literal.AbstractCallLiteral;
 import tools.refinery.store.query.term.Variable;
-import tools.refinery.store.query.view.AnyRelationView;
-import tools.refinery.store.query.view.RelationView;
+import tools.refinery.store.query.view.AnySymbolView;
+import tools.refinery.store.query.view.SymbolView;
 import tools.refinery.store.util.CycleDetectingMapper;
 
 import java.util.*;
@@ -30,7 +30,7 @@ import java.util.function.ToIntFunction;
 
 class QueryWrapperFactory {
         private final Dnf2PQuery dnf2PQuery;
-        private final Map<AnyRelationView, RelationViewWrapper> view2WrapperMap = new LinkedHashMap<>();
+        private final Map<AnySymbolView, SymbolViewWrapper> view2WrapperMap = new LinkedHashMap<>();
         private final CycleDetectingMapper<RemappedConstraint, RawPQuery> wrapConstraint = new CycleDetectingMapper<>(
                         RemappedConstraint::toString, this::doWrapConstraint);
 
@@ -38,12 +38,12 @@ class QueryWrapperFactory {
                 this.dnf2PQuery = dnf2PQuery;
         }
 
-        public PQuery wrapRelationViewIdentityArguments(AnyRelationView relationView) {
-                var identity = new int[relationView.arity()];
+        public PQuery wrapSymbolViewIdentityArguments(AnySymbolView symbolView) {
+                var identity = new int[symbolView.arity()];
                 for (int i = 0; i < identity.length; i++) {
                         identity[i] = i;
                 }
-                return maybeWrapConstraint(relationView, identity);
+                return maybeWrapConstraint(symbolView, identity);
         }
         public WrappedCall maybeWrapConstraint(AbstractCallLiteral callLiteral, DnfClause clause) {
                 var arguments = callLiteral.getArguments();
@@ -112,8 +112,8 @@ class QueryWrapperFactory {
                 }
                 var argumentTuple = Tuples.flatTupleOf(arguments);
 
-                if (constraint instanceof RelationView<?> relationView) {
-                        new TypeConstraint(body, argumentTuple, getInputKey(relationView));
+                if (constraint instanceof SymbolView<?> view) {
+                        new TypeConstraint(body, argumentTuple, getInputKey(view));
                 } else if (constraint instanceof Dnf dnf) {
                         var calledPQuery = dnf2PQuery.translate(dnf);
                         new PositivePatternCall(body, argumentTuple, calledPQuery);
@@ -125,11 +125,11 @@ class QueryWrapperFactory {
                 return embeddedPQuery;
         }
 
-        public IInputKey getInputKey(AnyRelationView relationView) {
-                return view2WrapperMap.computeIfAbsent(relationView, RelationViewWrapper::new);
+        public IInputKey getInputKey(AnySymbolView symbolView) {
+                return view2WrapperMap.computeIfAbsent(symbolView, SymbolViewWrapper::new);
         }
 
-        public Map<AnyRelationView, IInputKey> getRelationViews() {
+        public Map<AnySymbolView, IInputKey> getSymbolViews() {
                 return Collections.unmodifiableMap(view2WrapperMap);
         }
 
diff --git a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/pquery/RelationViewWrapper.java b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/pquery/SymbolViewWrapper.java
index 02da932b..a777613e 100644
--- a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/pquery/RelationViewWrapper.java
+++ b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/pquery/SymbolViewWrapper.java
@@ -6,10 +6,10 @@
 package tools.refinery.store.query.viatra.internal.pquery;
 
 import org.eclipse.viatra.query.runtime.matchers.context.common.BaseInputKeyWrapper;
-import tools.refinery.store.query.view.AnyRelationView;
+import tools.refinery.store.query.view.AnySymbolView;
 
-public class RelationViewWrapper extends BaseInputKeyWrapper<AnyRelationView> {
-        public RelationViewWrapper(AnyRelationView wrappedKey) {
+public class SymbolViewWrapper extends BaseInputKeyWrapper<AnySymbolView> {
+        public SymbolViewWrapper(AnySymbolView wrappedKey) {
                 super(wrappedKey);
         }
 
diff --git a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/update/ModelUpdateListener.java b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/update/ModelUpdateListener.java
index c612574f..986bb0b1 100644
--- a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/update/ModelUpdateListener.java
+++ b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/update/ModelUpdateListener.java
@@ -9,43 +9,43 @@ import org.eclipse.viatra.query.runtime.matchers.context.IInputKey;
 import org.eclipse.viatra.query.runtime.matchers.context.IQueryRuntimeContextListener;
 import org.eclipse.viatra.query.runtime.matchers.tuple.ITuple;
 import tools.refinery.store.query.viatra.internal.ViatraModelQueryAdapterImpl;
-import tools.refinery.store.query.view.AnyRelationView;
-import tools.refinery.store.query.view.RelationView;
+import tools.refinery.store.query.view.AnySymbolView;
+import tools.refinery.store.query.view.SymbolView;
 
 import java.util.HashMap;
 import java.util.Map;
 
 public class ModelUpdateListener {
-        private final Map<AnyRelationView, RelationViewUpdateListener<?>> relationViewUpdateListeners;
+        private final Map<AnySymbolView, SymbolViewUpdateListener<?>> symbolViewUpdateListeners;
 
         public ModelUpdateListener(ViatraModelQueryAdapterImpl adapter) {
-                var relationViews = adapter.getStoreAdapter().getInputKeys().keySet();
-                relationViewUpdateListeners = new HashMap<>(relationViews.size());
-                for (var relationView : relationViews) {
-                        registerView(adapter, (RelationView<?>) relationView);
+                var symbolViews = adapter.getStoreAdapter().getInputKeys().keySet();
+                symbolViewUpdateListeners = new HashMap<>(symbolViews.size());
+                for (var symbolView : symbolViews) {
+                        registerView(adapter, (SymbolView<?>) symbolView);
                 }
         }
 
-        private <T> void registerView(ViatraModelQueryAdapterImpl adapter, RelationView<T> relationView) {
+        private <T> void registerView(ViatraModelQueryAdapterImpl adapter, SymbolView<T> view) {
                 var model = adapter.getModel();
-                var interpretation = model.getInterpretation(relationView.getSymbol());
-                var listener = RelationViewUpdateListener.of(adapter, relationView, interpretation);
-                relationViewUpdateListeners.put(relationView, listener);
+                var interpretation = model.getInterpretation(view.getSymbol());
+                var listener = SymbolViewUpdateListener.of(adapter, view, interpretation);
+                symbolViewUpdateListeners.put(view, listener);
         }
 
-        public boolean containsRelationView(AnyRelationView relationView) {
-                return relationViewUpdateListeners.containsKey(relationView);
+        public boolean containsSymbolView(AnySymbolView relationView) {
+                return symbolViewUpdateListeners.containsKey(relationView);
         }
 
-        public void addListener(IInputKey key, AnyRelationView relationView, ITuple seed,
+        public void addListener(IInputKey key, AnySymbolView symbolView, ITuple seed,
                                                         IQueryRuntimeContextListener listener) {
-                var relationViewUpdateListener = relationViewUpdateListeners.get(relationView);
-                relationViewUpdateListener.addFilter(key, seed, listener);
+                var symbolViewUpdateListener = symbolViewUpdateListeners.get(symbolView);
+                symbolViewUpdateListener.addFilter(key, seed, listener);
         }
 
-        public void removeListener(IInputKey key, AnyRelationView relationView, ITuple seed,
+        public void removeListener(IInputKey key, AnySymbolView symbolView, ITuple seed,
                                                            IQueryRuntimeContextListener listener) {
-                var relationViewUpdateListener = relationViewUpdateListeners.get(relationView);
-                relationViewUpdateListener.removeFilter(key, seed, listener);
+                var symbolViewUpdateListener = symbolViewUpdateListeners.get(symbolView);
+                symbolViewUpdateListener.removeFilter(key, seed, listener);
         }
 }
diff --git a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/update/RelationViewUpdateListener.java b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/update/SymbolViewUpdateListener.java
index 185e4ebc..f1a2ac7c 100644
--- a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/update/RelationViewUpdateListener.java
+++ b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/update/SymbolViewUpdateListener.java
@@ -12,18 +12,18 @@ import org.eclipse.viatra.query.runtime.matchers.tuple.Tuple;
 import tools.refinery.store.model.Interpretation;
 import tools.refinery.store.model.InterpretationListener;
 import tools.refinery.store.query.viatra.internal.ViatraModelQueryAdapterImpl;
-import tools.refinery.store.query.view.RelationView;
-import tools.refinery.store.query.view.TuplePreservingRelationView;
+import tools.refinery.store.query.view.SymbolView;
+import tools.refinery.store.query.view.TuplePreservingView;
 
 import java.util.ArrayList;
 import java.util.List;
 
-public abstract class RelationViewUpdateListener<T> implements InterpretationListener<T> {
+public abstract class SymbolViewUpdateListener<T> implements InterpretationListener<T> {
         private final ViatraModelQueryAdapterImpl adapter;
         private final Interpretation<T> interpretation;
         private final List<RelationViewFilter> filters = new ArrayList<>();
 
-        protected RelationViewUpdateListener(ViatraModelQueryAdapterImpl adapter, Interpretation<T> interpretation) {
+        protected SymbolViewUpdateListener(ViatraModelQueryAdapterImpl adapter, Interpretation<T> interpretation) {
                 this.adapter = adapter;
                 this.interpretation = interpretation;
         }
@@ -53,13 +53,13 @@ public abstract class RelationViewUpdateListener<T> implements InterpretationLis
                 }
         }
 
-        public static <T> RelationViewUpdateListener<T> of(ViatraModelQueryAdapterImpl adapter,
-                                                                                                           RelationView<T> relationView,
-                                                                                                           Interpretation<T> interpretation) {
-                if (relationView instanceof TuplePreservingRelationView<T> tuplePreservingRelationView) {
-                        return new TuplePreservingRelationViewUpdateListener<>(adapter, tuplePreservingRelationView,
+        public static <T> SymbolViewUpdateListener<T> of(ViatraModelQueryAdapterImpl adapter,
+                                                                                                         SymbolView<T> view,
+                                                                                                         Interpretation<T> interpretation) {
+                if (view instanceof TuplePreservingView<T> tuplePreservingRelationView) {
+                        return new TuplePreservingViewUpdateListener<>(adapter, tuplePreservingRelationView,
                                         interpretation);
                 }
-                return new TupleChangingRelationViewUpdateListener<>(adapter, relationView, interpretation);
+                return new TupleChangingViewUpdateListener<>(adapter, view, interpretation);
         }
 }
diff --git a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/update/TupleChangingRelationViewUpdateListener.java b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/update/TupleChangingViewUpdateListener.java
index be4951af..45d35571 100644
--- a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/update/TupleChangingRelationViewUpdateListener.java
+++ b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/update/TupleChangingViewUpdateListener.java
@@ -8,37 +8,37 @@ package tools.refinery.store.query.viatra.internal.update;
 import org.eclipse.viatra.query.runtime.matchers.tuple.Tuples;
 import tools.refinery.store.model.Interpretation;
 import tools.refinery.store.query.viatra.internal.ViatraModelQueryAdapterImpl;
-import tools.refinery.store.query.view.RelationView;
+import tools.refinery.store.query.view.SymbolView;
 import tools.refinery.store.tuple.Tuple;
 
 import java.util.Arrays;
 
-public class TupleChangingRelationViewUpdateListener<T> extends RelationViewUpdateListener<T> {
-        private final RelationView<T> relationView;
+public class TupleChangingViewUpdateListener<T> extends SymbolViewUpdateListener<T> {
+        private final SymbolView<T> view;
 
-        TupleChangingRelationViewUpdateListener(ViatraModelQueryAdapterImpl adapter, RelationView<T> relationView,
-                                                                                        Interpretation<T> interpretation) {
+        TupleChangingViewUpdateListener(ViatraModelQueryAdapterImpl adapter, SymbolView<T> view,
+                                                                        Interpretation<T> interpretation) {
         super(adapter, interpretation);
-        this.relationView = relationView;
+        this.view = view;
         }
 
         @Override
         public void put(Tuple key, T fromValue, T toValue, boolean restoring) {
-                boolean fromPresent = relationView.filter(key, fromValue);
-                boolean toPresent = relationView.filter(key, toValue);
+                boolean fromPresent = view.filter(key, fromValue);
+                boolean toPresent = view.filter(key, toValue);
                 if (fromPresent) {
                         if (toPresent) { // value change
-                                var fromArray = relationView.forwardMap(key, fromValue);
-                                var toArray = relationView.forwardMap(key, toValue);
+                                var fromArray = view.forwardMap(key, fromValue);
+                                var toArray = view.forwardMap(key, toValue);
                                 if (!Arrays.equals(fromArray, toArray)) {
                                         processUpdate(Tuples.flatTupleOf(fromArray), false);
                                         processUpdate(Tuples.flatTupleOf(toArray), true);
                                 }
                         } else { // fromValue disappears
-                                processUpdate(Tuples.flatTupleOf(relationView.forwardMap(key, fromValue)), false);
+                                processUpdate(Tuples.flatTupleOf(view.forwardMap(key, fromValue)), false);
                         }
                 } else if (toPresent) { // toValue appears
-                        processUpdate(Tuples.flatTupleOf(relationView.forwardMap(key, toValue)), true);
+                        processUpdate(Tuples.flatTupleOf(view.forwardMap(key, toValue)), true);
                 }
         }
 }
diff --git a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/update/TuplePreservingRelationViewUpdateListener.java b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/update/TuplePreservingViewUpdateListener.java
index 9638266b..c18dbafb 100644
--- a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/update/TuplePreservingRelationViewUpdateListener.java
+++ b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/update/TuplePreservingViewUpdateListener.java
@@ -8,14 +8,14 @@ package tools.refinery.store.query.viatra.internal.update;
 import org.eclipse.viatra.query.runtime.matchers.tuple.Tuples;
 import tools.refinery.store.model.Interpretation;
 import tools.refinery.store.query.viatra.internal.ViatraModelQueryAdapterImpl;
-import tools.refinery.store.query.view.TuplePreservingRelationView;
+import tools.refinery.store.query.view.TuplePreservingView;
 import tools.refinery.store.tuple.Tuple;
 
-public class TuplePreservingRelationViewUpdateListener<T> extends RelationViewUpdateListener<T> {
-        private final TuplePreservingRelationView<T> view;
+public class TuplePreservingViewUpdateListener<T> extends SymbolViewUpdateListener<T> {
+        private final TuplePreservingView<T> view;
 
-        TuplePreservingRelationViewUpdateListener(ViatraModelQueryAdapterImpl adapter,
-                                                                                          TuplePreservingRelationView<T> view, Interpretation<T> interpretation) {
+        TuplePreservingViewUpdateListener(ViatraModelQueryAdapterImpl adapter, TuplePreservingView<T> view,
+                                                                          Interpretation<T> interpretation) {
         super(adapter, interpretation);
         this.view = view;
         }
diff --git a/subprojects/store-query-viatra/src/test/java/tools/refinery/store/query/viatra/DiagonalQueryTest.java b/subprojects/store-query-viatra/src/test/java/tools/refinery/store/query/viatra/DiagonalQueryTest.java
index da4aba7f..5cffef71 100644
--- a/subprojects/store-query-viatra/src/test/java/tools/refinery/store/query/viatra/DiagonalQueryTest.java
+++ b/subprojects/store-query-viatra/src/test/java/tools/refinery/store/query/viatra/DiagonalQueryTest.java
@@ -12,8 +12,8 @@ import tools.refinery.store.query.dnf.Dnf;
 import tools.refinery.store.query.dnf.Query;
 import tools.refinery.store.query.term.Variable;
 import tools.refinery.store.query.viatra.tests.QueryEngineTest;
-import tools.refinery.store.query.view.FunctionalRelationView;
-import tools.refinery.store.query.view.KeyOnlyRelationView;
+import tools.refinery.store.query.view.FunctionView;
+import tools.refinery.store.query.view.KeyOnlyView;
 import tools.refinery.store.representation.Symbol;
 import tools.refinery.store.tuple.Tuple;
 
@@ -30,8 +30,8 @@ class DiagonalQueryTest {
         void inputKeyNegationTest(QueryEvaluationHint hint) {
                 var person = new Symbol<>("Person", 1, Boolean.class, false);
                 var symbol = new Symbol<>("symbol", 4, Boolean.class, false);
-                var personView = new KeyOnlyRelationView<>(person);
-                var symbolView = new KeyOnlyRelationView<>(symbol);
+                var personView = new KeyOnlyView<>(person);
+                var symbolView = new KeyOnlyView<>(symbol);
 
                 var p1 = Variable.of("p1");
                 var p2 = Variable.of("p2");
@@ -78,8 +78,8 @@ class DiagonalQueryTest {
         void subQueryNegationTest(QueryEvaluationHint hint) {
                 var person = new Symbol<>("Person", 1, Boolean.class, false);
                 var symbol = new Symbol<>("symbol", 4, Boolean.class, false);
-                var personView = new KeyOnlyRelationView<>(person);
-                var symbolView = new KeyOnlyRelationView<>(symbol);
+                var personView = new KeyOnlyView<>(person);
+                var symbolView = new KeyOnlyView<>(symbol);
 
                 var p1 = Variable.of("p1");
                 var p2 = Variable.of("p2");
@@ -139,8 +139,8 @@ class DiagonalQueryTest {
         void inputKeyCountTest(QueryEvaluationHint hint) {
                 var person = new Symbol<>("Person", 1, Boolean.class, false);
                 var symbol = new Symbol<>("symbol", 4, Boolean.class, false);
-                var personView = new KeyOnlyRelationView<>(person);
-                var symbolView = new KeyOnlyRelationView<>(symbol);
+                var personView = new KeyOnlyView<>(person);
+                var symbolView = new KeyOnlyView<>(symbol);
 
                 var p1 = Variable.of("p1");
                 var p2 = Variable.of("p2");
@@ -190,8 +190,8 @@ class DiagonalQueryTest {
         void subQueryCountTest(QueryEvaluationHint hint) {
                 var person = new Symbol<>("Person", 1, Boolean.class, false);
                 var symbol = new Symbol<>("symbol", 4, Boolean.class, false);
-                var personView = new KeyOnlyRelationView<>(person);
-                var symbolView = new KeyOnlyRelationView<>(symbol);
+                var personView = new KeyOnlyView<>(person);
+                var symbolView = new KeyOnlyView<>(symbol);
 
                 var p1 = Variable.of("p1");
                 var p2 = Variable.of("p2");
@@ -254,8 +254,8 @@ class DiagonalQueryTest {
         void inputKeyAggregationTest(QueryEvaluationHint hint) {
                 var person = new Symbol<>("Person", 1, Boolean.class, false);
                 var symbol = new Symbol<>("symbol", 4, Integer.class, null);
-                var personView = new KeyOnlyRelationView<>(person);
-                var symbolView = new FunctionalRelationView<>(symbol);
+                var personView = new KeyOnlyView<>(person);
+                var symbolView = new FunctionView<>(symbol);
 
                 var p1 = Variable.of("p1");
                 var p2 = Variable.of("p2");
@@ -306,8 +306,8 @@ class DiagonalQueryTest {
         void subQueryAggregationTest(QueryEvaluationHint hint) {
                 var person = new Symbol<>("Person", 1, Boolean.class, false);
                 var symbol = new Symbol<>("symbol", 4, Integer.class, null);
-                var personView = new KeyOnlyRelationView<>(person);
-                var symbolView = new FunctionalRelationView<>(symbol);
+                var personView = new KeyOnlyView<>(person);
+                var symbolView = new FunctionView<>(symbol);
 
                 var p1 = Variable.of("p1");
                 var p2 = Variable.of("p2");
@@ -374,8 +374,8 @@ class DiagonalQueryTest {
         void inputKeyTransitiveTest(QueryEvaluationHint hint) {
                 var person = new Symbol<>("Person", 1, Boolean.class, false);
                 var symbol = new Symbol<>("symbol", 2, Boolean.class, false);
-                var personView = new KeyOnlyRelationView<>(person);
-                var symbolView = new KeyOnlyRelationView<>(symbol);
+                var personView = new KeyOnlyView<>(person);
+                var symbolView = new KeyOnlyView<>(symbol);
 
                 var p1 = Variable.of("p1");
                 var query = Query.builder("Diagonal")
@@ -420,8 +420,8 @@ class DiagonalQueryTest {
         void subQueryTransitiveTest(QueryEvaluationHint hint) {
                 var person = new Symbol<>("Person", 1, Boolean.class, false);
                 var symbol = new Symbol<>("symbol", 2, Boolean.class, false);
-                var personView = new KeyOnlyRelationView<>(person);
-                var symbolView = new KeyOnlyRelationView<>(symbol);
+                var personView = new KeyOnlyView<>(person);
+                var symbolView = new KeyOnlyView<>(symbol);
 
                 var p1 = Variable.of("p1");
                 var p2 = Variable.of("p2");
diff --git a/subprojects/store-query-viatra/src/test/java/tools/refinery/store/query/viatra/FunctionalQueryTest.java b/subprojects/store-query-viatra/src/test/java/tools/refinery/store/query/viatra/FunctionalQueryTest.java
index 3af67a50..19584273 100644
--- a/subprojects/store-query-viatra/src/test/java/tools/refinery/store/query/viatra/FunctionalQueryTest.java
+++ b/subprojects/store-query-viatra/src/test/java/tools/refinery/store/query/viatra/FunctionalQueryTest.java
@@ -13,9 +13,9 @@ import tools.refinery.store.query.dnf.Dnf;
 import tools.refinery.store.query.dnf.Query;
 import tools.refinery.store.query.term.Variable;
 import tools.refinery.store.query.viatra.tests.QueryEngineTest;
-import tools.refinery.store.query.view.FilteredRelationView;
-import tools.refinery.store.query.view.FunctionalRelationView;
-import tools.refinery.store.query.view.KeyOnlyRelationView;
+import tools.refinery.store.query.view.FilteredView;
+import tools.refinery.store.query.view.FunctionView;
+import tools.refinery.store.query.view.KeyOnlyView;
 import tools.refinery.store.representation.Symbol;
 import tools.refinery.store.representation.TruthValue;
 import tools.refinery.store.tuple.Tuple;
@@ -38,8 +38,8 @@ class FunctionalQueryTest {
         void inputKeyTest(QueryEvaluationHint hint) {
                 var person = new Symbol<>("Person", 1, Boolean.class, false);
                 var age = new Symbol<>("age", 1, Integer.class, null);
-                var personView = new KeyOnlyRelationView<>(person);
-                var ageView = new FunctionalRelationView<>(age);
+                var personView = new KeyOnlyView<>(person);
+                var ageView = new FunctionView<>(age);
 
                 var p1 = Variable.of("p1");
                 var x = Variable.of("x", Integer.class);
@@ -84,8 +84,8 @@ class FunctionalQueryTest {
         void predicateTest(QueryEvaluationHint hint) {
                 var person = new Symbol<>("Person", 1, Boolean.class, false);
                 var age = new Symbol<>("age", 1, Integer.class, null);
-                var personView = new KeyOnlyRelationView<>(person);
-                var ageView = new FunctionalRelationView<>(age);
+                var personView = new KeyOnlyView<>(person);
+                var ageView = new FunctionView<>(age);
 
                 var p1 = Variable.of("p1");
                 var x = Variable.of("x", Integer.class);
@@ -137,8 +137,8 @@ class FunctionalQueryTest {
         void computationTest(QueryEvaluationHint hint) {
                 var person = new Symbol<>("Person", 1, Boolean.class, false);
                 var age = new Symbol<>("age", 1, Integer.class, null);
-                var personView = new KeyOnlyRelationView<>(person);
-                var ageView = new FunctionalRelationView<>(age);
+                var personView = new KeyOnlyView<>(person);
+                var ageView = new FunctionView<>(age);
 
                 var p1 = Variable.of("p1");
                 var x = Variable.of("x", Integer.class);
@@ -184,8 +184,8 @@ class FunctionalQueryTest {
         void inputKeyCountTest(QueryEvaluationHint hint) {
                 var person = new Symbol<>("Person", 1, Boolean.class, false);
                 var friend = new Symbol<>("friend", 2, TruthValue.class, TruthValue.FALSE);
-                var personView = new KeyOnlyRelationView<>(person);
-                var friendMustView = new FilteredRelationView<>(friend, "must", TruthValue::must);
+                var personView = new KeyOnlyView<>(person);
+                var friendMustView = new FilteredView<>(friend, "must", TruthValue::must);
 
                 var p1 = Variable.of("p1");
                 var p2 = Variable.of("p2");
@@ -233,8 +233,8 @@ class FunctionalQueryTest {
         void predicateCountTest(QueryEvaluationHint hint) {
                 var person = new Symbol<>("Person", 1, Boolean.class, false);
                 var friend = new Symbol<>("friend", 2, TruthValue.class, TruthValue.FALSE);
-                var personView = new KeyOnlyRelationView<>(person);
-                var friendMustView = new FilteredRelationView<>(friend, "must", TruthValue::must);
+                var personView = new KeyOnlyView<>(person);
+                var friendMustView = new FilteredView<>(friend, "must", TruthValue::must);
 
                 var p1 = Variable.of("p1");
                 var p2 = Variable.of("p2");
@@ -289,7 +289,7 @@ class FunctionalQueryTest {
         @QueryEngineTest
         void inputKeyAggregationTest(QueryEvaluationHint hint) {
                 var age = new Symbol<>("age", 1, Integer.class, null);
-                var ageView = new FunctionalRelationView<>(age);
+                var ageView = new FunctionView<>(age);
 
                 var p1 = Variable.of("p1");
                 var x = Variable.of("x", Integer.class);
@@ -324,8 +324,8 @@ class FunctionalQueryTest {
         void predicateAggregationTest(QueryEvaluationHint hint) {
                 var person = new Symbol<>("Person", 1, Boolean.class, false);
                 var age = new Symbol<>("age", 1, Integer.class, null);
-                var personView = new KeyOnlyRelationView<>(person);
-                var ageView = new FunctionalRelationView<>(age);
+                var personView = new KeyOnlyView<>(person);
+                var ageView = new FunctionView<>(age);
 
                 var p1 = Variable.of("p1");
                 var x = Variable.of("x", Integer.class);
@@ -371,8 +371,8 @@ class FunctionalQueryTest {
         void extremeValueTest(QueryEvaluationHint hint) {
                 var person = new Symbol<>("Person", 1, Boolean.class, false);
                 var friend = new Symbol<>("friend", 2, TruthValue.class, TruthValue.FALSE);
-                var personView = new KeyOnlyRelationView<>(person);
-                var friendMustView = new FilteredRelationView<>(friend, "must", TruthValue::must);
+                var personView = new KeyOnlyView<>(person);
+                var friendMustView = new FilteredView<>(friend, "must", TruthValue::must);
 
                 var p1 = Variable.of("p1");
                 var p2 = Variable.of("p2");
@@ -447,8 +447,8 @@ class FunctionalQueryTest {
         void invalidComputationTest(QueryEvaluationHint hint) {
                 var person = new Symbol<>("Person", 1, Boolean.class, false);
                 var age = new Symbol<>("age", 1, Integer.class, null);
-                var personView = new KeyOnlyRelationView<>(person);
-                var ageView = new FunctionalRelationView<>(age);
+                var personView = new KeyOnlyView<>(person);
+                var ageView = new FunctionView<>(age);
 
                 var p1 = Variable.of("p1");
                 var x = Variable.of("x", Integer.class);
@@ -494,8 +494,8 @@ class FunctionalQueryTest {
         void invalidAssumeTest(QueryEvaluationHint hint) {
                 var person = new Symbol<>("Person", 1, Boolean.class, false);
                 var age = new Symbol<>("age", 1, Integer.class, null);
-                var personView = new KeyOnlyRelationView<>(person);
-                var ageView = new FunctionalRelationView<>(age);
+                var personView = new KeyOnlyView<>(person);
+                var ageView = new FunctionView<>(age);
 
                 var p1 = Variable.of("p1");
                 var x = Variable.of("x", Integer.class);
@@ -543,9 +543,9 @@ class FunctionalQueryTest {
                 var person = new Symbol<>("Person", 1, Boolean.class, false);
                 var age = new Symbol<>("age", 1, Integer.class, null);
                 var friend = new Symbol<>("friend", 2, TruthValue.class, TruthValue.FALSE);
-                var personView = new KeyOnlyRelationView<>(person);
-                var ageView = new FunctionalRelationView<>(age);
-                var friendMustView = new FilteredRelationView<>(friend, "must", TruthValue::must);
+                var personView = new KeyOnlyView<>(person);
+                var ageView = new FunctionView<>(age);
+                var friendMustView = new FilteredView<>(friend, "must", TruthValue::must);
 
                 var p1 = Variable.of("p1");
                 var p2 = Variable.of("p2");
diff --git a/subprojects/store-query-viatra/src/test/java/tools/refinery/store/query/viatra/QueryTest.java b/subprojects/store-query-viatra/src/test/java/tools/refinery/store/query/viatra/QueryTest.java
index e82f0a15..11ee98f5 100644
--- a/subprojects/store-query-viatra/src/test/java/tools/refinery/store/query/viatra/QueryTest.java
+++ b/subprojects/store-query-viatra/src/test/java/tools/refinery/store/query/viatra/QueryTest.java
@@ -13,9 +13,9 @@ import tools.refinery.store.query.dnf.Dnf;
 import tools.refinery.store.query.dnf.Query;
 import tools.refinery.store.query.term.Variable;
 import tools.refinery.store.query.viatra.tests.QueryEngineTest;
-import tools.refinery.store.query.view.FilteredRelationView;
-import tools.refinery.store.query.view.FunctionalRelationView;
-import tools.refinery.store.query.view.KeyOnlyRelationView;
+import tools.refinery.store.query.view.FilteredView;
+import tools.refinery.store.query.view.FunctionView;
+import tools.refinery.store.query.view.KeyOnlyView;
 import tools.refinery.store.representation.Symbol;
 import tools.refinery.store.representation.TruthValue;
 import tools.refinery.store.tuple.Tuple;
@@ -34,7 +34,7 @@ class QueryTest {
         void typeConstraintTest(QueryEvaluationHint hint) {
                 var person = new Symbol<>("Person", 1, Boolean.class, false);
                 var asset = new Symbol<>("Asset", 1, Boolean.class, false);
-                var personView = new KeyOnlyRelationView<>(person);
+                var personView = new KeyOnlyView<>(person);
 
                 var p1 = Variable.of("p1");
                 var predicate = Query.builder("TypeConstraint")
@@ -73,8 +73,8 @@ class QueryTest {
         void relationConstraintTest(QueryEvaluationHint hint) {
                 var person = new Symbol<>("Person", 1, Boolean.class, false);
                 var friend = new Symbol<>("friend", 2, TruthValue.class, TruthValue.FALSE);
-                var personView = new KeyOnlyRelationView<>(person);
-                var friendMustView = new FilteredRelationView<>(friend, "must", TruthValue::must);
+                var personView = new KeyOnlyView<>(person);
+                var friendMustView = new FilteredView<>(friend, "must", TruthValue::must);
 
                 var p1 = Variable.of("p1");
                 var p2 = Variable.of("p2");
@@ -122,8 +122,8 @@ class QueryTest {
         void existTest(QueryEvaluationHint hint) {
                 var person = new Symbol<>("Person", 1, Boolean.class, false);
                 var friend = new Symbol<>("friend", 2, TruthValue.class, TruthValue.FALSE);
-                var personView = new KeyOnlyRelationView<>(person);
-                var friendMustView = new FilteredRelationView<>(friend, "must", TruthValue::must);
+                var personView = new KeyOnlyView<>(person);
+                var friendMustView = new FilteredView<>(friend, "must", TruthValue::must);
 
                 var p1 = Variable.of("p1");
                 var p2 = Variable.of("p2");
@@ -172,9 +172,9 @@ class QueryTest {
                 var person = new Symbol<>("Person", 1, Boolean.class, false);
                 var animal = new Symbol<>("Animal", 1, Boolean.class, false);
                 var friend = new Symbol<>("friend", 2, TruthValue.class, TruthValue.FALSE);
-                var personView = new KeyOnlyRelationView<>(person);
-                var animalView = new KeyOnlyRelationView<>(animal);
-                var friendMustView = new FilteredRelationView<>(friend, "must", TruthValue::must);
+                var personView = new KeyOnlyView<>(person);
+                var animalView = new KeyOnlyView<>(animal);
+                var friendMustView = new FilteredView<>(friend, "must", TruthValue::must);
 
                 var p1 = Variable.of("p1");
                 var p2 = Variable.of("p2");
@@ -230,7 +230,7 @@ class QueryTest {
         @QueryEngineTest
         void equalityTest(QueryEvaluationHint hint) {
                 var person = new Symbol<>("Person", 1, Boolean.class, false);
-                var personView = new KeyOnlyRelationView<>(person);
+                var personView = new KeyOnlyView<>(person);
 
                 var p1 = Variable.of("p1");
                 var p2 = Variable.of("p2");
@@ -273,8 +273,8 @@ class QueryTest {
         void inequalityTest(QueryEvaluationHint hint) {
                 var person = new Symbol<>("Person", 1, Boolean.class, false);
                 var friend = new Symbol<>("friend", 2, TruthValue.class, TruthValue.FALSE);
-                var personView = new KeyOnlyRelationView<>(person);
-                var friendMustView = new FilteredRelationView<>(friend, "must", TruthValue::must);
+                var personView = new KeyOnlyView<>(person);
+                var friendMustView = new FilteredView<>(friend, "must", TruthValue::must);
 
                 var p1 = Variable.of("p1");
                 var p2 = Variable.of("p2");
@@ -322,8 +322,8 @@ class QueryTest {
         void patternCallTest(QueryEvaluationHint hint) {
                 var person = new Symbol<>("Person", 1, Boolean.class, false);
                 var friend = new Symbol<>("friend", 2, TruthValue.class, TruthValue.FALSE);
-                var personView = new KeyOnlyRelationView<>(person);
-                var friendMustView = new FilteredRelationView<>(friend, "must", TruthValue::must);
+                var personView = new KeyOnlyView<>(person);
+                var friendMustView = new FilteredView<>(friend, "must", TruthValue::must);
 
                 var p1 = Variable.of("p1");
                 var p2 = Variable.of("p2");
@@ -381,8 +381,8 @@ class QueryTest {
         void negativeRelationViewTest(QueryEvaluationHint hint) {
                 var person = new Symbol<>("Person", 1, Boolean.class, false);
                 var friend = new Symbol<>("friend", 2, TruthValue.class, TruthValue.FALSE);
-                var personView = new KeyOnlyRelationView<>(person);
-                var friendMustView = new FilteredRelationView<>(friend, "must", TruthValue::must);
+                var personView = new KeyOnlyView<>(person);
+                var friendMustView = new FilteredView<>(friend, "must", TruthValue::must);
 
                 var p1 = Variable.of("p1");
                 var p2 = Variable.of("p2");
@@ -435,8 +435,8 @@ class QueryTest {
         void negativePatternCallTest(QueryEvaluationHint hint) {
                 var person = new Symbol<>("Person", 1, Boolean.class, false);
                 var friend = new Symbol<>("friend", 2, TruthValue.class, TruthValue.FALSE);
-                var personView = new KeyOnlyRelationView<>(person);
-                var friendMustView = new FilteredRelationView<>(friend, "must", TruthValue::must);
+                var personView = new KeyOnlyView<>(person);
+                var friendMustView = new FilteredView<>(friend, "must", TruthValue::must);
 
                 var p1 = Variable.of("p1");
                 var p2 = Variable.of("p2");
@@ -500,8 +500,8 @@ class QueryTest {
         void negativeRelationViewWithQuantificationTest(QueryEvaluationHint hint) {
                 var person = new Symbol<>("Person", 1, Boolean.class, false);
                 var friend = new Symbol<>("friend", 2, TruthValue.class, TruthValue.FALSE);
-                var personView = new KeyOnlyRelationView<>(person);
-                var friendMustView = new FilteredRelationView<>(friend, "must", TruthValue::must);
+                var personView = new KeyOnlyView<>(person);
+                var friendMustView = new FilteredView<>(friend, "must", TruthValue::must);
 
                 var p1 = Variable.of("p1");
                 var p2 = Variable.of("p2");
@@ -547,8 +547,8 @@ class QueryTest {
         void negativeWithQuantificationTest(QueryEvaluationHint hint) {
                 var person = new Symbol<>("Person", 1, Boolean.class, false);
                 var friend = new Symbol<>("friend", 2, TruthValue.class, TruthValue.FALSE);
-                var personView = new KeyOnlyRelationView<>(person);
-                var friendMustView = new FilteredRelationView<>(friend, "must", TruthValue::must);
+                var personView = new KeyOnlyView<>(person);
+                var friendMustView = new FilteredView<>(friend, "must", TruthValue::must);
 
                 var p1 = Variable.of("p1");
                 var p2 = Variable.of("p2");
@@ -603,8 +603,8 @@ class QueryTest {
         void transitiveRelationViewTest(QueryEvaluationHint hint) {
                 var person = new Symbol<>("Person", 1, Boolean.class, false);
                 var friend = new Symbol<>("friend", 2, TruthValue.class, TruthValue.FALSE);
-                var personView = new KeyOnlyRelationView<>(person);
-                var friendMustView = new FilteredRelationView<>(friend, "must", TruthValue::must);
+                var personView = new KeyOnlyView<>(person);
+                var friendMustView = new FilteredView<>(friend, "must", TruthValue::must);
 
                 var p1 = Variable.of("p1");
                 var p2 = Variable.of("p2");
@@ -656,8 +656,8 @@ class QueryTest {
         void transitivePatternCallTest(QueryEvaluationHint hint) {
                 var person = new Symbol<>("Person", 1, Boolean.class, false);
                 var friend = new Symbol<>("friend", 2, TruthValue.class, TruthValue.FALSE);
-                var personView = new KeyOnlyRelationView<>(person);
-                var friendMustView = new FilteredRelationView<>(friend, "must", TruthValue::must);
+                var personView = new KeyOnlyView<>(person);
+                var friendMustView = new FilteredView<>(friend, "must", TruthValue::must);
 
                 var p1 = Variable.of("p1");
                 var p2 = Variable.of("p2");
@@ -720,8 +720,8 @@ class QueryTest {
         void assumeTest(QueryEvaluationHint hint) {
                 var person = new Symbol<>("Person", 1, Boolean.class, false);
                 var age = new Symbol<>("age", 1, Integer.class, null);
-                var personView = new KeyOnlyRelationView<>(person);
-                var ageView = new FunctionalRelationView<>(age);
+                var personView = new KeyOnlyView<>(person);
+                var ageView = new FunctionView<>(age);
 
                 var p1 = Variable.of("p1");
                 var x = Variable.of("x", Integer.class);
diff --git a/subprojects/store-query-viatra/src/test/java/tools/refinery/store/query/viatra/QueryTransactionTest.java b/subprojects/store-query-viatra/src/test/java/tools/refinery/store/query/viatra/QueryTransactionTest.java
index 07b799ac..bd6b6b81 100644
--- a/subprojects/store-query-viatra/src/test/java/tools/refinery/store/query/viatra/QueryTransactionTest.java
+++ b/subprojects/store-query-viatra/src/test/java/tools/refinery/store/query/viatra/QueryTransactionTest.java
@@ -12,9 +12,9 @@ import tools.refinery.store.model.ModelStore;
 import tools.refinery.store.query.ModelQuery;
 import tools.refinery.store.query.dnf.Query;
 import tools.refinery.store.query.term.Variable;
-import tools.refinery.store.query.view.FilteredRelationView;
-import tools.refinery.store.query.view.FunctionalRelationView;
-import tools.refinery.store.query.view.KeyOnlyRelationView;
+import tools.refinery.store.query.view.FilteredView;
+import tools.refinery.store.query.view.FunctionView;
+import tools.refinery.store.query.view.KeyOnlyView;
 import tools.refinery.store.representation.Symbol;
 import tools.refinery.store.tuple.Tuple;
 
@@ -30,7 +30,7 @@ class QueryTransactionTest {
         @Test
         void flushTest() {
                 var person = new Symbol<>("Person", 1, Boolean.class, false);
-                var personView = new KeyOnlyRelationView<>(person);
+                var personView = new KeyOnlyView<>(person);
 
                 var p1 = Variable.of("p1");
                 var predicate = Query.builder("TypeConstraint")
@@ -101,7 +101,7 @@ class QueryTransactionTest {
         @Test
         void localSearchTest() {
                 var person = new Symbol<>("Person", 1, Boolean.class, false);
-                var personView = new KeyOnlyRelationView<>(person);
+                var personView = new KeyOnlyView<>(person);
 
                 var p1 = Variable.of("p1");
                 var predicate = Query.builder("TypeConstraint")
@@ -156,7 +156,7 @@ class QueryTransactionTest {
         void unrelatedChangesTest() {
                 var person = new Symbol<>("Person", 1, Boolean.class, false);
                 var asset = new Symbol<>("Asset", 1, Boolean.class, false);
-                var personView = new KeyOnlyRelationView<>(person);
+                var personView = new KeyOnlyView<>(person);
 
                 var p1 = Variable.of("p1");
                 var predicate = Query.builder("TypeConstraint")
@@ -229,8 +229,8 @@ class QueryTransactionTest {
         void tupleChangingChangeTest() {
                 var person = new Symbol<>("Person", 1, Boolean.class, false);
                 var age = new Symbol<>("age", 1, Integer.class, null);
-                var personView = new KeyOnlyRelationView<>(person);
-                var ageView = new FunctionalRelationView<>(age);
+                var personView = new KeyOnlyView<>(person);
+                var ageView = new FunctionView<>(age);
 
                 var p1 = Variable.of("p1");
                 var x = Variable.of("x", Integer.class);
@@ -277,8 +277,8 @@ class QueryTransactionTest {
         void tuplePreservingUnchangedTest() {
                 var person = new Symbol<>("Person", 1, Boolean.class, false);
                 var age = new Symbol<>("age", 1, Integer.class, null);
-                var personView = new KeyOnlyRelationView<>(person);
-                var adultView = new FilteredRelationView<>(age, "adult", n -> n != null && n >= 18);
+                var personView = new KeyOnlyView<>(person);
+                var adultView = new FilteredView<>(age, "adult", n -> n != null && n >= 18);
 
                 var p1 = Variable.of("p1");
                 var x = Variable.of("x", Integer.class);
@@ -324,7 +324,7 @@ class QueryTransactionTest {
         @Test
         void commitAfterFlushTest() {
                 var person = new Symbol<>("Person", 1, Boolean.class, false);
-                var personView = new KeyOnlyRelationView<>(person);
+                var personView = new KeyOnlyView<>(person);
 
                 var p1 = Variable.of("p1");
                 var predicate = Query.builder("TypeConstraint")
@@ -382,7 +382,7 @@ class QueryTransactionTest {
         @Test
         void commitWithoutFlushTest() {
                 var person = new Symbol<>("Person", 1, Boolean.class, false);
-                var personView = new KeyOnlyRelationView<>(person);
+                var personView = new KeyOnlyView<>(person);
 
                 var p1 = Variable.of("p1");
                 var predicate = Query.builder("TypeConstraint")