Views works as keys + they can be instantiated without model

12 files changed, 100 insertions, 119 deletions

diff --git a/model-data/src/main/java/org/eclipse/viatra/solver/data/query/RelationalQuery.java b/model-data/src/main/java/org/eclipse/viatra/solver/data/query/RelationalQuery.java
index bbff5563..39fc2482 100644
--- a/model-data/src/main/java/org/eclipse/viatra/solver/data/query/RelationalQuery.java
+++ b/model-data/src/main/java/org/eclipse/viatra/solver/data/query/RelationalQuery.java
@@ -10,9 +10,7 @@ import java.util.Set;
 
 import org.eclipse.viatra.query.runtime.api.GenericPatternMatcher;
 import org.eclipse.viatra.query.runtime.api.GenericQuerySpecification;
-import org.eclipse.viatra.query.runtime.api.IQuerySpecification;
 import org.eclipse.viatra.query.runtime.api.ViatraQueryEngine;
-import org.eclipse.viatra.query.runtime.api.ViatraQueryMatcher;
 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;
@@ -27,7 +25,6 @@ import org.eclipse.viatra.query.runtime.matchers.psystem.basicenumerables.Positi
 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.PParameterDirection;
 import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PQuery;
 import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PVisibility;
 import org.eclipse.viatra.query.runtime.matchers.tuple.Tuples;
@@ -80,7 +77,7 @@ public class RelationalQuery extends BasePQuery {
                 for(int i = 0; i<name.length; i++) {
                         variables[i] = body.getOrCreateVariableByName(name[i]);
                 }
-                new TypeConstraint(body, Tuples.flatTupleOf(variables), view.getKey());
+                new TypeConstraint(body, Tuples.flatTupleOf(variables), view);
                 return this;
         }
 
diff --git a/model-data/src/main/java/org/eclipse/viatra/solver/data/query/RelationalScope.java b/model-data/src/main/java/org/eclipse/viatra/solver/data/query/RelationalScope.java
index f0a390aa..97b33935 100644
--- a/model-data/src/main/java/org/eclipse/viatra/solver/data/query/RelationalScope.java
+++ b/model-data/src/main/java/org/eclipse/viatra/solver/data/query/RelationalScope.java
@@ -7,15 +7,18 @@ 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 org.eclipse.viatra.solver.data.model.Model;
 import org.eclipse.viatra.solver.data.model.Tuple;
 import org.eclipse.viatra.solver.data.query.internal.RelationUpdateListener;
 import org.eclipse.viatra.solver.data.query.internal.RelationalEngineContext;
 import org.eclipse.viatra.solver.data.query.view.RelationView;
 
 public class RelationalScope extends QueryScope{
+        private final Model model;
         private final RelationUpdateListener updateListener;
         
-        public RelationalScope(Set<RelationView<?>> relationViews) {
+        public RelationalScope(Model model, Set<RelationView<?>> relationViews) {
+                this.model = model;
                 updateListener = new RelationUpdateListener(relationViews);
         }
         
@@ -26,6 +29,6 @@ public class RelationalScope extends QueryScope{
         @Override
         protected IEngineContext createEngineContext(ViatraQueryEngine engine, IIndexingErrorListener errorListener,
                         Logger logger) {
-                return new RelationalEngineContext(this.updateListener);
+                return new RelationalEngineContext(model, updateListener);
         }
 }
diff --git a/model-data/src/main/java/org/eclipse/viatra/solver/data/query/internal/RelationUpdateListener.java b/model-data/src/main/java/org/eclipse/viatra/solver/data/query/internal/RelationUpdateListener.java
index de814936..c6d12614 100644
--- a/model-data/src/main/java/org/eclipse/viatra/solver/data/query/internal/RelationUpdateListener.java
+++ b/model-data/src/main/java/org/eclipse/viatra/solver/data/query/internal/RelationUpdateListener.java
@@ -19,18 +19,18 @@ public class RelationUpdateListener {
                         view2Listeners.put(relationView, new HashSet<>());
                 }
         }
-        public boolean containsRelationalView(RelationViewKey<?> relationalKey) {
+        public boolean containsRelationalView(RelationView<?> relationalKey) {
                 RelationView<?> relationView = relationalKey.getWrappedKey();
                 return view2Listeners.containsKey(relationView);
         }
-        public void addListener(RelationViewKey<?> relationalKey, ITuple seed, IQueryRuntimeContextListener listener) {
+        public void addListener(RelationView<?> relationalKey, ITuple seed, IQueryRuntimeContextListener listener) {
                 RelationView<?> relationView = relationalKey.getWrappedKey();
                 if(view2Listeners.containsKey(relationView)) {
                         RelationUpdateListenerEntry<?> entry = new RelationUpdateListenerEntry<>(relationalKey, seed, listener);
                         view2Listeners.get(relationView).add(entry);
                 } else throw new IllegalArgumentException();
         }
-        public void removeListener(RelationViewKey<?> relationalKey, ITuple seed, IQueryRuntimeContextListener listener) {
+        public void removeListener(RelationView<?> relationalKey, ITuple seed, IQueryRuntimeContextListener listener) {
                 RelationView<?> relationView = relationalKey.getWrappedKey();
                 if(view2Listeners.containsKey(relationView)) {
                         RelationUpdateListenerEntry<?> entry = new RelationUpdateListenerEntry<>(relationalKey, seed, listener);
diff --git a/model-data/src/main/java/org/eclipse/viatra/solver/data/query/internal/RelationUpdateListenerEntry.java b/model-data/src/main/java/org/eclipse/viatra/solver/data/query/internal/RelationUpdateListenerEntry.java
index def02aa5..55aed7c8 100644
--- a/model-data/src/main/java/org/eclipse/viatra/solver/data/query/internal/RelationUpdateListenerEntry.java
+++ b/model-data/src/main/java/org/eclipse/viatra/solver/data/query/internal/RelationUpdateListenerEntry.java
@@ -7,13 +7,14 @@ import org.eclipse.viatra.query.runtime.matchers.context.IQueryRuntimeContextLis
 import org.eclipse.viatra.query.runtime.matchers.tuple.ITuple;
 import org.eclipse.viatra.query.runtime.matchers.tuple.Tuples;
 import org.eclipse.viatra.solver.data.model.Tuple;
+import org.eclipse.viatra.solver.data.query.view.RelationView;
 
 public class RelationUpdateListenerEntry<D> {
-        final RelationViewKey<D> key;
+        final RelationView<D> key;
         final ITuple filter;
         final IQueryRuntimeContextListener listener;
         
-        public RelationUpdateListenerEntry(RelationViewKey<D> key, ITuple filter, IQueryRuntimeContextListener listener) {
+        public RelationUpdateListenerEntry(RelationView<D> key, ITuple filter, IQueryRuntimeContextListener listener) {
                 super();
                 this.key = key;
                 this.filter = filter;
diff --git a/model-data/src/main/java/org/eclipse/viatra/solver/data/query/internal/RelationViewKey.java b/model-data/src/main/java/org/eclipse/viatra/solver/data/query/internal/RelationViewKey.java
deleted file mode 100644
index bae0af45..00000000
--- a/model-data/src/main/java/org/eclipse/viatra/solver/data/query/internal/RelationViewKey.java
+++ /dev/null
@@ -1,60 +0,0 @@
-package org.eclipse.viatra.solver.data.query.internal;
-
-import java.util.Objects;
-import java.util.UUID;
-
-import org.eclipse.viatra.query.runtime.matchers.context.common.BaseInputKeyWrapper;
-import org.eclipse.viatra.solver.data.query.view.RelationView;
-
-public class RelationViewKey<D> extends BaseInputKeyWrapper<RelationView<D>>{
-        private final String uniqueName;
-        private final int arity;
-        
-        public RelationViewKey(RelationView<D> wrappedKey, int arity) {
-                super(wrappedKey);
-                this.uniqueName = wrappedKey.getRepresentation().getName() + "-"+UUID.randomUUID();
-                this.arity = arity;
-        }
-
-        @Override
-        public String getPrettyPrintableName() {
-                return wrappedKey.getRepresentation().getName();
-        }
-
-        @Override
-        public String getStringID() {
-                return uniqueName;
-        }
-
-        @Override
-        public int getArity() {
-                return arity;
-        }
-
-        @Override
-        public boolean isEnumerable() {
-                return true;
-        }
-
-        @Override
-        public int hashCode() {
-                final int prime = 31;
-                int result = super.hashCode();
-                result = prime * result + Objects.hash(uniqueName);
-                return result;
-        }
-
-        @Override
-        public boolean equals(Object obj) {
-                if (this == obj)
-                        return true;
-                if (!super.equals(obj))
-                        return false;
-                if (!(obj instanceof RelationViewKey))
-                        return false;
-                RelationViewKey<?> other = (RelationViewKey<?>) obj;
-                return Objects.equals(uniqueName, other.uniqueName);
-        }
-        
-        
-}
diff --git a/model-data/src/main/java/org/eclipse/viatra/solver/data/query/internal/RelationalEngineContext.java b/model-data/src/main/java/org/eclipse/viatra/solver/data/query/internal/RelationalEngineContext.java
index c46da1bb..01948828 100644
--- a/model-data/src/main/java/org/eclipse/viatra/solver/data/query/internal/RelationalEngineContext.java
+++ b/model-data/src/main/java/org/eclipse/viatra/solver/data/query/internal/RelationalEngineContext.java
@@ -3,14 +3,15 @@ package org.eclipse.viatra.solver.data.query.internal;
 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 org.eclipse.viatra.solver.data.model.Model;
 
 public class RelationalEngineContext implements IEngineContext{
         private final IBaseIndex baseIndex = new DummyBaseIndexer();
         private final RelationalRuntimeContext runtimeContext;
         
 
-        public RelationalEngineContext(RelationUpdateListener updateListener) {
-                runtimeContext = new RelationalRuntimeContext(updateListener);
+        public RelationalEngineContext(Model model, RelationUpdateListener updateListener) {
+                runtimeContext = new RelationalRuntimeContext(model, updateListener);
         }
 
         @Override
diff --git a/model-data/src/main/java/org/eclipse/viatra/solver/data/query/internal/RelationalQueryMetaContext.java b/model-data/src/main/java/org/eclipse/viatra/solver/data/query/internal/RelationalQueryMetaContext.java
index 457ed6fd..de500fc9 100644
--- a/model-data/src/main/java/org/eclipse/viatra/solver/data/query/internal/RelationalQueryMetaContext.java
+++ b/model-data/src/main/java/org/eclipse/viatra/solver/data/query/internal/RelationalQueryMetaContext.java
@@ -10,6 +10,7 @@ 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 org.eclipse.viatra.solver.data.query.view.RelationView;
 
 /**
  * The meta context information for String scopes.
@@ -25,7 +26,7 @@ public final class RelationalQueryMetaContext extends AbstractQueryMetaContext {
         @Override
         public boolean isStateless(IInputKey key) {
         ensureValidKey(key);
-        return key instanceof RelationViewKey<?>;
+        return key instanceof RelationView<?>;
         }
 
         @Override
@@ -37,7 +38,7 @@ public final class RelationalQueryMetaContext extends AbstractQueryMetaContext {
         @Override
     public Map<Set<Integer>, Set<Integer>> getFunctionalDependencies(IInputKey key) {
         ensureValidKey(key);
-        if (key instanceof RelationViewKey) {
+        if (key instanceof RelationView) {
             return new HashMap<Set<Integer>, Set<Integer>>();
         } else {
             return Collections.emptyMap();
@@ -45,7 +46,7 @@ public final class RelationalQueryMetaContext extends AbstractQueryMetaContext {
     }
 
     public void ensureValidKey(IInputKey key) {
-        if (! (key instanceof RelationViewKey<?>))
+        if (! (key instanceof RelationView<?>))
             illegalInputKey(key);
     }
 
diff --git a/model-data/src/main/java/org/eclipse/viatra/solver/data/query/internal/RelationalRuntimeContext.java b/model-data/src/main/java/org/eclipse/viatra/solver/data/query/internal/RelationalRuntimeContext.java
index 8f6fb8dd..7d1682b2 100644
--- a/model-data/src/main/java/org/eclipse/viatra/solver/data/query/internal/RelationalRuntimeContext.java
+++ b/model-data/src/main/java/org/eclipse/viatra/solver/data/query/internal/RelationalRuntimeContext.java
@@ -19,12 +19,16 @@ 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 org.eclipse.viatra.solver.data.model.Model;
+import org.eclipse.viatra.solver.data.query.view.RelationView;
 
 public class RelationalRuntimeContext implements IQueryRuntimeContext {
         private final RelationalQueryMetaContext metaContext = new RelationalQueryMetaContext();
         private final RelationUpdateListener relationUpdateListener;
+        private final Model model;
         
-        public RelationalRuntimeContext(RelationUpdateListener relationUpdateListener) {
+        public RelationalRuntimeContext(Model model, RelationUpdateListener relationUpdateListener) {
+                this.model = model;
                 this.relationUpdateListener = relationUpdateListener;
         }
         
@@ -53,8 +57,8 @@ public class RelationalRuntimeContext implements IQueryRuntimeContext {
 
         @Override
         public boolean isIndexed(IInputKey key, IndexingService service) {
-                if(key instanceof RelationViewKey<?>) {
-                        RelationViewKey<?> relationalKey = (RelationViewKey<?>) key;
+                if(key instanceof RelationView<?>) {
+                        RelationView<?> relationalKey = (RelationView<?>) key;
                         return this.relationUpdateListener.containsRelationalView(relationalKey);
                 } else {
                         return false;
@@ -68,9 +72,9 @@ public class RelationalRuntimeContext implements IQueryRuntimeContext {
                 }
         }
         
-        RelationViewKey<?> checkKey(IInputKey key) {
-                if(key instanceof RelationViewKey) {
-                        RelationViewKey<?> relationViewKey = (RelationViewKey<?>) key;
+        RelationView<?> checkKey(IInputKey key) {
+                if(key instanceof RelationView) {
+                        RelationView<?> relationViewKey = (RelationView<?>) key;
                         if(relationUpdateListener.containsRelationalView(relationViewKey)) {
                                 return relationViewKey;
                         } else {
@@ -83,8 +87,8 @@ public class RelationalRuntimeContext implements IQueryRuntimeContext {
         
         @Override
         public int countTuples(IInputKey key, TupleMask seedMask, ITuple seed) {
-                RelationViewKey<?> relationalViewKey = checkKey(key);
-                Iterable<Object[]> allObjects = relationalViewKey.getWrappedKey().getAll();
+                RelationView<?> relationalViewKey = checkKey(key);
+                Iterable<Object[]> allObjects = relationalViewKey.getAll(model);
                 Iterable<Object[]> filteredBySeed = filter(allObjects,objectArray -> isMatching(objectArray,seedMask,seed));
                 Iterator<Object[]> iterator = filteredBySeed.iterator();
                 int result = 0;
@@ -102,8 +106,8 @@ public class RelationalRuntimeContext implements IQueryRuntimeContext {
 
         @Override
         public Iterable<Tuple> enumerateTuples(IInputKey key, TupleMask seedMask, ITuple seed) {
-                RelationViewKey<?> relationalViewKey = checkKey(key);
-                Iterable<Object[]> allObjects = relationalViewKey.getWrappedKey().getAll();
+                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);
         }
@@ -134,20 +138,20 @@ public class RelationalRuntimeContext implements IQueryRuntimeContext {
 
         @Override
         public boolean containsTuple(IInputKey key, ITuple seed) {
-                RelationViewKey<?> relationalViewKey = checkKey(key);
-                return relationalViewKey.getWrappedKey().get(seed.getElements());
+                RelationView<?> relationalViewKey = checkKey(key);
+                return relationalViewKey.get(model,seed.getElements());
         }
 
         @Override
         public void addUpdateListener(IInputKey key, Tuple seed, IQueryRuntimeContextListener listener) {
-                RelationViewKey<?> relationalKey = checkKey(key);
+                RelationView<?> relationalKey = checkKey(key);
                 this.relationUpdateListener.addListener(relationalKey, seed, listener);
                 
         }
 
         @Override
         public void removeUpdateListener(IInputKey key, Tuple seed, IQueryRuntimeContextListener listener) {
-                RelationViewKey<?> relationalKey = checkKey(key);
+                RelationView<?> relationalKey = checkKey(key);
                 this.relationUpdateListener.removeListener(relationalKey, seed, listener);
         }
 
diff --git a/model-data/src/main/java/org/eclipse/viatra/solver/data/query/view/FilteredRelationView.java b/model-data/src/main/java/org/eclipse/viatra/solver/data/query/view/FilteredRelationView.java
index 4602af21..bfa3d13a 100644
--- a/model-data/src/main/java/org/eclipse/viatra/solver/data/query/view/FilteredRelationView.java
+++ b/model-data/src/main/java/org/eclipse/viatra/solver/data/query/view/FilteredRelationView.java
@@ -11,7 +11,7 @@ public class FilteredRelationView<D> extends RelationView<D>{
         private final BiPredicate<Tuple,D> predicate;
 
         public FilteredRelationView(Model model, Relation<D> representation, BiPredicate<Tuple,D> predicate) {
-                super(model, representation);
+                super(representation);
                 this.predicate = predicate;
         }
         @Override
@@ -19,13 +19,13 @@ public class FilteredRelationView<D> extends RelationView<D>{
                 return toTuple1Array(key);
         }
         @Override
-        public boolean get(Object[] tuple) {
+        public boolean get(Model model, Object[] tuple) {
                 int[] content = new int[tuple.length];
                 for(int i = 0; i<tuple.length; i++) {
                         content[i] =((Tuple1)tuple[i]).get(0);
                 }
                 Tuple key = Tuple.of(content);
-                D value = this.model.get(representation, key);
+                D value = model.get(representation, key);
                 return filter(key, value);
         }
         
diff --git a/model-data/src/main/java/org/eclipse/viatra/solver/data/query/view/FunctionalRelationView.java b/model-data/src/main/java/org/eclipse/viatra/solver/data/query/view/FunctionalRelationView.java
index b8d0ef72..71759bc5 100644
--- a/model-data/src/main/java/org/eclipse/viatra/solver/data/query/view/FunctionalRelationView.java
+++ b/model-data/src/main/java/org/eclipse/viatra/solver/data/query/view/FunctionalRelationView.java
@@ -8,7 +8,7 @@ import org.eclipse.viatra.solver.data.model.representation.Relation;
 public class FunctionalRelationView<D> extends RelationView<D> {
 
         public FunctionalRelationView(Model model, Relation<D> representation) {
-                super(model, representation);
+                super(representation);
         }
 
         @Override
@@ -22,7 +22,7 @@ public class FunctionalRelationView<D> extends RelationView<D> {
         }
 
         @Override
-        public boolean get(Object[] tuple) {
+        public boolean get(Model model, Object[] tuple) {
                 int[] content = new int[tuple.length-1];
                 for(int i = 0; i<tuple.length-1; i++) {
                         content[i] =((Tuple1)tuple[i]).get(0);
@@ -30,7 +30,7 @@ public class FunctionalRelationView<D> extends RelationView<D> {
                 Tuple key = Tuple.of(content);
                 @SuppressWarnings("unchecked")
                 D valueInTuple = (D) tuple[tuple.length-1];
-                D valueInMap = this.model.get(representation, key);
+                D valueInMap = model.get(representation, key);
                 return valueInTuple.equals(valueInMap);
         }
         
diff --git a/model-data/src/main/java/org/eclipse/viatra/solver/data/query/view/RelationView.java b/model-data/src/main/java/org/eclipse/viatra/solver/data/query/view/RelationView.java
index 18d2692d..c5bc5228 100644
--- a/model-data/src/main/java/org/eclipse/viatra/solver/data/query/view/RelationView.java
+++ b/model-data/src/main/java/org/eclipse/viatra/solver/data/query/view/RelationView.java
@@ -1,51 +1,85 @@
 package org.eclipse.viatra.solver.data.query.view;
 
+import java.util.Objects;
+
+import org.eclipse.viatra.query.runtime.matchers.context.common.BaseInputKeyWrapper;
 import org.eclipse.viatra.solver.data.map.CursorAsIterator;
 import org.eclipse.viatra.solver.data.model.Model;
 import org.eclipse.viatra.solver.data.model.Tuple;
 import org.eclipse.viatra.solver.data.model.representation.Relation;
-import org.eclipse.viatra.solver.data.query.internal.RelationViewKey;
 
 /**
  * Represents a view of a {@link Relation} that can be queried.
+ * 
  * @author Oszkar Semerath
  *
  * @param <D>
  */
-public abstract class RelationView<D>{
-        protected final Model model;
+public abstract class RelationView<D> extends BaseInputKeyWrapper<RelationView<D>> {
         protected final Relation<D> representation;
-        private final RelationViewKey<D> key;
-        
-        protected RelationView(Model model, Relation<D> representation) {
-                this.model = model;
+
+        protected RelationView(Relation<D> representation) {
+                super(null);
+                this.wrappedKey = this;
                 this.representation = representation;
-                key = new RelationViewKey<>(this, getArity());
         }
-        
-        public Model getModel() {
-                return model;
+
+        @Override
+        public String getPrettyPrintableName() {
+                return representation.getName();
+        }
+
+        @Override
+        public String getStringID() {
+                return representation.getName() + this.getClass().getName();
         }
+
         public Relation<D> getRepresentation() {
                 return representation;
         }
-        
-        public abstract int getArity();
+
+        @Override
+        public boolean isEnumerable() {
+                return true;
+        }
+
         protected abstract boolean filter(Tuple key, D value);
+
         protected abstract Object[] forwardMap(Tuple key, D value);
-        public abstract boolean get(Object[] tuple);
+
+        public abstract boolean get(Model model, Object[] tuple);
 
         public Object[] transform(Tuple tuple, D value) {
-                if(filter(tuple, value)) {
+                if (filter(tuple, value)) {
                         return forwardMap(tuple, value);
-                } else return null;
+                } else
+                        return null;
         }
 
-        public Iterable<Object[]> getAll() {
-                return (()->new CursorAsIterator<>(model.getAll(representation), (k,v)->forwardMap(k,v), (k,v)->filter(k,v)));
+        public Iterable<Object[]> getAll(Model model) {
+                return (() -> new CursorAsIterator<>(model.getAll(representation), (k, v) -> forwardMap(k, v),
+                                (k, v) -> filter(k, v)));
         }
-        
-        public RelationViewKey<D> getKey() {
-                return key;
+
+        @Override
+        public int hashCode() {
+                final int prime = 31;
+                int result = 1;
+                result = prime * result + Objects.hash(representation);
+                return result;
         }
+
+        @Override
+        public boolean equals(Object obj) {
+                if (this == obj)
+                        return true;
+                if (!super.equals(obj))
+                        return false;
+                if (!(obj instanceof RelationView))
+                        return false;
+                @SuppressWarnings("unchecked")
+                RelationView<D> other = ((RelationView<D>) obj);
+                return Objects.equals(representation, other.representation);
+        }
+
 }
diff --git a/model-data/src/test/java/org/eclipse/viatra/solver/data/query/test/QueryTest.java b/model-data/src/test/java/org/eclipse/viatra/solver/data/query/test/QueryTest.java
index ca73b103..1e0c1d5c 100644
--- a/model-data/src/test/java/org/eclipse/viatra/solver/data/query/test/QueryTest.java
+++ b/model-data/src/test/java/org/eclipse/viatra/solver/data/query/test/QueryTest.java
@@ -39,7 +39,7 @@ class QueryTest {
 
                 RelationView<Boolean> persionView = new TupleRelationView(model, person);
 
-                RelationalScope scope = new RelationalScope(Set.of(persionView));
+                RelationalScope scope = new RelationalScope(model,Set.of(persionView));
 
                 GenericQuerySpecification<GenericPatternMatcher> personQuery = (new RelationalQuery("PersonQuery"))
                                 .addParameter("p", persionView).addConstraint(persionView, "p").build();
@@ -76,7 +76,7 @@ class QueryTest {
                                 (k, v) -> v.must());
                 RelationView<TruthValue> friendMayView = new FilteredRelationView<TruthValue>(model, friend, (k, v) -> v.may());
 
-                RelationalScope scope = new RelationalScope(Set.of(persionView, ageView, friendMustView, friendMayView));
+                RelationalScope scope = new RelationalScope(model,Set.of(persionView, ageView, friendMustView, friendMayView));
 
                 GenericQuerySpecification<GenericPatternMatcher> personQuery = (new RelationalQuery("PersonQuery"))
                                 .addParameter("p", persionView).addConstraint(persionView, "p").build();