refactor: remove TupleLike

* Directly transform VIATRA tuples into Refinery tuples, since creating
  the additional wrapper object doesn't save any memory.
* Adds static arity Tuple3 and Tuple4 implementations to be more
  aligned with VIATRA internals and save memory for queries with up to
  4 parameters.
* Makes sure no new objects are allocated (for varargs handling) when a
  static arity tuple is hashed.

10 files changed, 326 insertions, 86 deletions

diff --git a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/matcher/FunctionalCursor.java b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/matcher/FunctionalCursor.java
index 4daa14a1..52a83f69 100644
--- a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/matcher/FunctionalCursor.java
+++ b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/matcher/FunctionalCursor.java
@@ -1,17 +1,16 @@
 package tools.refinery.store.query.viatra.internal.matcher;
 
-import org.eclipse.viatra.query.runtime.matchers.tuple.Tuple;
 import org.eclipse.viatra.query.runtime.rete.index.IterableIndexer;
 import tools.refinery.store.map.Cursor;
-import tools.refinery.store.tuple.TupleLike;
+import tools.refinery.store.tuple.Tuple;
 
 import java.util.Iterator;
 
-class FunctionalCursor<T> implements Cursor<TupleLike, T> {
+class FunctionalCursor<T> implements Cursor<Tuple, T> {
         private final IterableIndexer indexer;
-        private final Iterator<Tuple> iterator;
+        private final Iterator<org.eclipse.viatra.query.runtime.matchers.tuple.Tuple> iterator;
         private boolean terminated;
-        private TupleLike key;
+        private Tuple key;
         private T value;
 
         public FunctionalCursor(IterableIndexer indexer) {
@@ -20,7 +19,7 @@ class FunctionalCursor<T> implements Cursor<TupleLike, T> {
         }
 
         @Override
-        public TupleLike getKey() {
+        public Tuple getKey() {
                 return key;
         }
 
@@ -38,7 +37,7 @@ class FunctionalCursor<T> implements Cursor<TupleLike, T> {
         public boolean move() {
                 if (!terminated && iterator.hasNext()) {
                         var match = iterator.next();
-                        key = new ViatraTupleLike(match);
+                        key = MatcherUtils.toRefineryTuple(match);
                         value = MatcherUtils.getSingleValue(indexer.get(match));
                         return true;
                 }
diff --git a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/matcher/FunctionalViatraMatcher.java b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/matcher/FunctionalViatraMatcher.java
index 6aa45af2..adb34b8b 100644
--- a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/matcher/FunctionalViatraMatcher.java
+++ b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/matcher/FunctionalViatraMatcher.java
@@ -11,7 +11,7 @@ import tools.refinery.store.query.ResultSet;
 import tools.refinery.store.query.dnf.FunctionalQuery;
 import tools.refinery.store.query.dnf.Query;
 import tools.refinery.store.query.viatra.internal.ViatraModelQueryAdapterImpl;
-import tools.refinery.store.tuple.TupleLike;
+import tools.refinery.store.tuple.Tuple;
 
 /**
  * Directly access the tuples inside a VIATRA pattern matcher.<p>
@@ -63,7 +63,7 @@ public class FunctionalViatraMatcher<T> implements ResultSet<T> {
         }
 
         @Override
-        public T get(TupleLike parameters) {
+        public T get(Tuple parameters) {
                 var tuple = MatcherUtils.toViatraTuple(parameters);
                 if (omitOutputIndexer == null) {
                         return MatcherUtils.getSingleValue(backend.getAllMatches(omitOutputMask, tuple).iterator());
@@ -73,7 +73,7 @@ public class FunctionalViatraMatcher<T> implements ResultSet<T> {
         }
 
         @Override
-        public Cursor<TupleLike, T> getAll() {
+        public Cursor<Tuple, T> getAll() {
                 if (omitOutputIndexer == null) {
                         var allMatches = backend.getAllMatches(emptyMask, Tuples.staticArityFlatTupleOf());
                         return new UnsafeFunctionalCursor<>(allMatches.iterator());
diff --git a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/matcher/MatcherUtils.java b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/matcher/MatcherUtils.java
index 5d4be95d..d327c537 100644
--- a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/matcher/MatcherUtils.java
+++ b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/matcher/MatcherUtils.java
@@ -3,8 +3,7 @@ package tools.refinery.store.query.viatra.internal.matcher;
 import org.eclipse.viatra.query.runtime.matchers.tuple.ITuple;
 import org.eclipse.viatra.query.runtime.matchers.tuple.Tuples;
 import org.jetbrains.annotations.Nullable;
-import tools.refinery.store.tuple.Tuple;
-import tools.refinery.store.tuple.TupleLike;
+import tools.refinery.store.tuple.*;
 
 import java.util.Iterator;
 
@@ -13,25 +12,80 @@ final class MatcherUtils {
                 throw new IllegalStateException("This is a static utility class and should not be instantiated directly");
         }
 
-        public static org.eclipse.viatra.query.runtime.matchers.tuple.Tuple toViatraTuple(TupleLike tuple) {
-                if (tuple instanceof ViatraTupleLike viatraTupleLike) {
-                        return viatraTupleLike.wrappedTuple().toImmutable();
+        public static org.eclipse.viatra.query.runtime.matchers.tuple.Tuple toViatraTuple(Tuple refineryTuple) {
+                if (refineryTuple instanceof Tuple0) {
+                        return Tuples.staticArityFlatTupleOf();
+                } else if (refineryTuple instanceof Tuple1) {
+                        return Tuples.staticArityFlatTupleOf(refineryTuple);
+                } else if (refineryTuple instanceof Tuple2 tuple2) {
+                        return Tuples.staticArityFlatTupleOf(Tuple.of(tuple2.value0()), Tuple.of(tuple2.value1()));
+                } else if (refineryTuple instanceof Tuple3 tuple3) {
+                        return Tuples.staticArityFlatTupleOf(Tuple.of(tuple3.value0()), Tuple.of(tuple3.value1()),
+                                        Tuple.of(tuple3.value2()));
+                } else if (refineryTuple instanceof Tuple4 tuple4) {
+                        return Tuples.staticArityFlatTupleOf(Tuple.of(tuple4.value0()), Tuple.of(tuple4.value1()),
+                                        Tuple.of(tuple4.value2()), Tuple.of(tuple4.value3()));
+                } else {
+                        int arity = refineryTuple.getSize();
+                        var values = new Object[arity];
+                        for (int i = 0; i < arity; i++) {
+                                values[i] = Tuple.of(refineryTuple.get(i));
+                        }
+                        return Tuples.flatTupleOf(values);
                 }
-                int size = tuple.getSize();
-                var array = new Object[size];
-                for (int i = 0; i < size; i++) {
-                        var value = tuple.get(i);
-                        array[i] = Tuple.of(value);
+        }
+
+        public static Tuple toRefineryTuple(ITuple viatraTuple) {
+                int arity = viatraTuple.getSize();
+                if (arity == 1) {
+                        return getWrapper(viatraTuple, 0);
                 }
-                return Tuples.flatTupleOf(array);
+                return prefixToRefineryTuple(viatraTuple, viatraTuple.getSize());
+        }
+
+        public static Tuple keyToRefineryTuple(ITuple viatraTuple) {
+                return prefixToRefineryTuple(viatraTuple, viatraTuple.getSize() - 1);
         }
 
+        private static Tuple prefixToRefineryTuple(ITuple viatraTuple, int targetArity) {
+                if (targetArity < 0) {
+                        throw new IllegalArgumentException("Requested negative prefix %d of %s"
+                                        .formatted(targetArity, viatraTuple));
+                }
+                return switch (targetArity) {
+                        case 0 -> Tuple.of();
+                        case 1 -> Tuple.of(unwrap(viatraTuple, 0));
+                        case 2 -> Tuple.of(unwrap(viatraTuple, 0), unwrap(viatraTuple, 1));
+                        case 3 -> Tuple.of(unwrap(viatraTuple, 0), unwrap(viatraTuple, 1), unwrap(viatraTuple, 2));
+                        case 4 -> Tuple.of(unwrap(viatraTuple, 0), unwrap(viatraTuple, 1), unwrap(viatraTuple, 2),
+                                        unwrap(viatraTuple, 3));
+                        default -> {
+                                var entries = new int[targetArity];
+                                for (int i = 0; i < targetArity; i++) {
+                                        entries[i] = unwrap(viatraTuple, i);
+                                }
+                                yield Tuple.of(entries);
+                        }
+                };
+        }
+
+        private static Tuple1 getWrapper(ITuple viatraTuple, int index) {
+                if (!((viatraTuple.get(index)) instanceof Tuple1 wrappedObjectId)) {
+                        throw new IllegalArgumentException("Element %d of tuple %s is not an object id"
+                                        .formatted(index, viatraTuple));
+                }
+                return wrappedObjectId;
+        }
+
+        private static int unwrap(ITuple viatraTuple, int index) {
+                return getWrapper(viatraTuple, index).value0();
+        }
 
-        public static <T> T getSingleValue(@Nullable Iterable<? extends ITuple> tuples) {
-                if (tuples == null) {
+        public static <T> T getSingleValue(@Nullable Iterable<? extends ITuple> viatraTuples) {
+                if (viatraTuples == null) {
                         return null;
                 }
-                return getSingleValue(tuples.iterator());
+                return getSingleValue(viatraTuples.iterator());
         }
 
         public static <T> T getSingleValue(Iterator<? extends ITuple> iterator) {
@@ -42,7 +96,7 @@ final class MatcherUtils {
                 @SuppressWarnings("unchecked")
                 var result = (T) match.get(match.getSize() - 1);
                 if (iterator.hasNext()) {
-                        var input = new OmitOutputViatraTupleLike(match);
+                        var input = keyToRefineryTuple(match);
                         throw new IllegalStateException("Query is not functional for input tuple: " + input);
                 }
                 return result;
diff --git a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/matcher/OmitOutputViatraTupleLike.java b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/matcher/OmitOutputViatraTupleLike.java
deleted file mode 100644
index bd9301ba..00000000
--- a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/matcher/OmitOutputViatraTupleLike.java
+++ /dev/null
@@ -1,23 +0,0 @@
-package tools.refinery.store.query.viatra.internal.matcher;
-
-import org.eclipse.viatra.query.runtime.matchers.tuple.ITuple;
-import tools.refinery.store.tuple.Tuple1;
-import tools.refinery.store.tuple.TupleLike;
-
-record OmitOutputViatraTupleLike(ITuple wrappedTuple) implements TupleLike {
-        @Override
-        public int getSize() {
-                return wrappedTuple.getSize() - 1;
-        }
-
-        @Override
-        public int get(int element) {
-                var wrappedValue = (Tuple1) wrappedTuple.get(element);
-                return wrappedValue.value0();
-        }
-
-        @Override
-        public String toString() {
-                return TupleLike.toString(this);
-        }
-}
diff --git a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/matcher/RelationalCursor.java b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/matcher/RelationalCursor.java
index c2dcc565..e3df0441 100644
--- a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/matcher/RelationalCursor.java
+++ b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/matcher/RelationalCursor.java
@@ -2,21 +2,21 @@ package tools.refinery.store.query.viatra.internal.matcher;
 
 import org.eclipse.viatra.query.runtime.matchers.tuple.ITuple;
 import tools.refinery.store.map.Cursor;
-import tools.refinery.store.tuple.TupleLike;
+import tools.refinery.store.tuple.Tuple;
 
 import java.util.Iterator;
 
-class RelationalCursor implements Cursor<TupleLike, Boolean> {
+class RelationalCursor implements Cursor<Tuple, Boolean> {
     private final Iterator<? extends ITuple> tuplesIterator;
     private boolean terminated;
-    private TupleLike key;
+    private Tuple key;
 
     public RelationalCursor(Iterator<? extends ITuple> tuplesIterator) {
         this.tuplesIterator = tuplesIterator;
     }
 
     @Override
-    public TupleLike getKey() {
+    public Tuple getKey() {
         return key;
     }
 
@@ -33,7 +33,7 @@ class RelationalCursor implements Cursor<TupleLike, Boolean> {
     @Override
     public boolean move() {
         if (!terminated && tuplesIterator.hasNext()) {
-            key = new ViatraTupleLike(tuplesIterator.next());
+            key = MatcherUtils.toRefineryTuple(tuplesIterator.next());
             return true;
         }
         terminated = true;
diff --git a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/matcher/RelationalViatraMatcher.java b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/matcher/RelationalViatraMatcher.java
index b9bc3f1e..9373709d 100644
--- a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/matcher/RelationalViatraMatcher.java
+++ b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/matcher/RelationalViatraMatcher.java
@@ -12,7 +12,7 @@ import tools.refinery.store.query.ResultSet;
 import tools.refinery.store.query.dnf.Query;
 import tools.refinery.store.query.dnf.RelationalQuery;
 import tools.refinery.store.query.viatra.internal.ViatraModelQueryAdapterImpl;
-import tools.refinery.store.tuple.TupleLike;
+import tools.refinery.store.tuple.Tuple;
 
 /**
  * Directly access the tuples inside a VIATRA pattern matcher.<p>
@@ -58,7 +58,7 @@ public class RelationalViatraMatcher implements ResultSet<Boolean> {
         }
 
         @Override
-        public Boolean get(TupleLike parameters) {
+        public Boolean get(Tuple parameters) {
                 var tuple = MatcherUtils.toViatraTuple(parameters);
                 if (emptyMaskIndexer == null) {
                         return backend.hasMatch(identityMask, tuple);
@@ -68,7 +68,7 @@ public class RelationalViatraMatcher implements ResultSet<Boolean> {
         }
 
         @Override
-        public Cursor<TupleLike, Boolean> getAll() {
+        public Cursor<Tuple, Boolean> getAll() {
                 if (emptyMaskIndexer == null) {
                         var allMatches = backend.getAllMatches(emptyMask, Tuples.staticArityFlatTupleOf());
                         return new RelationalCursor(allMatches.iterator());
@@ -85,5 +85,4 @@ public class RelationalViatraMatcher implements ResultSet<Boolean> {
                 var matches = emptyMaskIndexer.get(Tuples.staticArityFlatTupleOf());
                 return matches == null ? 0 : matches.size();
         }
-
 }
diff --git a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/matcher/UnsafeFunctionalCursor.java b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/matcher/UnsafeFunctionalCursor.java
index 6c53fff1..e9540d1d 100644
--- a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/matcher/UnsafeFunctionalCursor.java
+++ b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/matcher/UnsafeFunctionalCursor.java
@@ -2,7 +2,7 @@ package tools.refinery.store.query.viatra.internal.matcher;
 
 import org.eclipse.viatra.query.runtime.matchers.tuple.ITuple;
 import tools.refinery.store.map.Cursor;
-import tools.refinery.store.tuple.TupleLike;
+import tools.refinery.store.tuple.Tuple;
 
 import java.util.Iterator;
 
@@ -11,10 +11,10 @@ import java.util.Iterator;
  * functional dependency of the output on the inputs is obeyed.
  * @param <T> The output type.
  */
-class UnsafeFunctionalCursor<T> implements Cursor<TupleLike, T> {
+class UnsafeFunctionalCursor<T> implements Cursor<Tuple, T> {
         private final Iterator<? extends ITuple> tuplesIterator;
         private boolean terminated;
-        private TupleLike key;
+        private Tuple key;
         private T value;
 
         public UnsafeFunctionalCursor(Iterator<? extends ITuple> tuplesIterator) {
@@ -22,7 +22,7 @@ class UnsafeFunctionalCursor<T> implements Cursor<TupleLike, T> {
         }
 
         @Override
-        public TupleLike getKey() {
+        public Tuple getKey() {
                 return key;
         }
 
@@ -40,7 +40,7 @@ class UnsafeFunctionalCursor<T> implements Cursor<TupleLike, T> {
         public boolean move() {
                 if (!terminated && tuplesIterator.hasNext()) {
                         var match = tuplesIterator.next();
-                        key = new OmitOutputViatraTupleLike(match);
+                        key = MatcherUtils.keyToRefineryTuple(match);
                         @SuppressWarnings("unchecked")
                         var typedValue = (T) match.get(match.getSize() - 1);
                         value = typedValue;
diff --git a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/matcher/ViatraTupleLike.java b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/matcher/ViatraTupleLike.java
deleted file mode 100644
index 76a3e40b..00000000
--- a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/matcher/ViatraTupleLike.java
+++ /dev/null
@@ -1,23 +0,0 @@
-package tools.refinery.store.query.viatra.internal.matcher;
-
-import org.eclipse.viatra.query.runtime.matchers.tuple.ITuple;
-import tools.refinery.store.tuple.Tuple1;
-import tools.refinery.store.tuple.TupleLike;
-
-record ViatraTupleLike(ITuple wrappedTuple) implements TupleLike {
-        @Override
-        public int getSize() {
-                return wrappedTuple.getSize();
-        }
-
-        @Override
-        public int get(int element) {
-                var wrappedValue = (Tuple1) wrappedTuple.get(element);
-                return wrappedValue.value0();
-        }
-
-        @Override
-        public String toString() {
-                return TupleLike.toString(this);
-        }
-}
diff --git a/subprojects/store-query-viatra/src/test/java/tools/refinery/store/query/viatra/internal/matcher/MatcherUtilsTest.java b/subprojects/store-query-viatra/src/test/java/tools/refinery/store/query/viatra/internal/matcher/MatcherUtilsTest.java
new file mode 100644
index 00000000..ea0b15ec
--- /dev/null
+++ b/subprojects/store-query-viatra/src/test/java/tools/refinery/store/query/viatra/internal/matcher/MatcherUtilsTest.java
@@ -0,0 +1,234 @@
+package tools.refinery.store.query.viatra.internal.matcher;
+
+import org.eclipse.viatra.query.runtime.matchers.tuple.*;
+import org.junit.jupiter.api.Test;
+import tools.refinery.store.tuple.Tuple;
+import tools.refinery.store.tuple.*;
+
+import java.util.List;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.*;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+class MatcherUtilsTest {
+        @Test
+        void toViatra0Test() {
+                var viatraTuple = MatcherUtils.toViatraTuple(Tuple.of());
+                assertThat(viatraTuple.getSize(), is(0));
+                assertThat(viatraTuple, instanceOf(FlatTuple0.class));
+        }
+
+        @Test
+        void toViatra1Test() {
+                var viatraTuple = MatcherUtils.toViatraTuple(Tuple.of(2));
+                assertThat(viatraTuple.getSize(), is(1));
+                assertThat(viatraTuple.get(0), is(Tuple.of(2)));
+                assertThat(viatraTuple, instanceOf(FlatTuple1.class));
+        }
+
+        @Test
+        void toViatra2Test() {
+                var viatraTuple = MatcherUtils.toViatraTuple(Tuple.of(2, 3));
+                assertThat(viatraTuple.getSize(), is(2));
+                assertThat(viatraTuple.get(0), is(Tuple.of(2)));
+                assertThat(viatraTuple.get(1), is(Tuple.of(3)));
+                assertThat(viatraTuple, instanceOf(FlatTuple2.class));
+        }
+
+        @Test
+        void toViatra3Test() {
+                var viatraTuple = MatcherUtils.toViatraTuple(Tuple.of(2, 3, 5));
+                assertThat(viatraTuple.getSize(), is(3));
+                assertThat(viatraTuple.get(0), is(Tuple.of(2)));
+                assertThat(viatraTuple.get(1), is(Tuple.of(3)));
+                assertThat(viatraTuple.get(2), is(Tuple.of(5)));
+                assertThat(viatraTuple, instanceOf(FlatTuple3.class));
+        }
+
+        @Test
+        void toViatra4Test() {
+                var viatraTuple = MatcherUtils.toViatraTuple(Tuple.of(2, 3, 5, 8));
+                assertThat(viatraTuple.getSize(), is(4));
+                assertThat(viatraTuple.get(0), is(Tuple.of(2)));
+                assertThat(viatraTuple.get(1), is(Tuple.of(3)));
+                assertThat(viatraTuple.get(2), is(Tuple.of(5)));
+                assertThat(viatraTuple.get(3), is(Tuple.of(8)));
+                assertThat(viatraTuple, instanceOf(FlatTuple4.class));
+        }
+
+        @Test
+        void toViatra5Test() {
+                var viatraTuple = MatcherUtils.toViatraTuple(Tuple.of(2, 3, 5, 8, 13));
+                assertThat(viatraTuple.getSize(), is(5));
+                assertThat(viatraTuple.get(0), is(Tuple.of(2)));
+                assertThat(viatraTuple.get(1), is(Tuple.of(3)));
+                assertThat(viatraTuple.get(2), is(Tuple.of(5)));
+                assertThat(viatraTuple.get(3), is(Tuple.of(8)));
+                assertThat(viatraTuple.get(4), is(Tuple.of(13)));
+                assertThat(viatraTuple, instanceOf(FlatTuple.class));
+        }
+
+        @Test
+        void toRefinery0Test() {
+                var refineryTuple = MatcherUtils.toRefineryTuple(Tuples.flatTupleOf());
+                assertThat(refineryTuple.getSize(), is(0));
+                assertThat(refineryTuple, instanceOf(Tuple0.class));
+        }
+
+        @Test
+        void toRefinery1Test() {
+                var refineryTuple = MatcherUtils.toRefineryTuple(Tuples.flatTupleOf(Tuple.of(2)));
+                assertThat(refineryTuple.getSize(), is(1));
+                assertThat(refineryTuple.get(0), is(2));
+                assertThat(refineryTuple, instanceOf(Tuple1.class));
+        }
+
+        @Test
+        void toRefinery2Test() {
+                var refineryTuple = MatcherUtils.toRefineryTuple(Tuples.flatTupleOf(Tuple.of(2), Tuple.of(3)));
+                assertThat(refineryTuple.getSize(), is(2));
+                assertThat(refineryTuple.get(0), is(2));
+                assertThat(refineryTuple.get(1), is(3));
+                assertThat(refineryTuple, instanceOf(Tuple2.class));
+        }
+
+        @Test
+        void toRefinery3Test() {
+                var refineryTuple = MatcherUtils.toRefineryTuple(Tuples.flatTupleOf(Tuple.of(2), Tuple.of(3), Tuple.of(5)));
+                assertThat(refineryTuple.getSize(), is(3));
+                assertThat(refineryTuple.get(0), is(2));
+                assertThat(refineryTuple.get(1), is(3));
+                assertThat(refineryTuple.get(2), is(5));
+                assertThat(refineryTuple, instanceOf(Tuple3.class));
+        }
+
+        @Test
+        void toRefinery4Test() {
+                var refineryTuple = MatcherUtils.toRefineryTuple(Tuples.flatTupleOf(Tuple.of(2), Tuple.of(3), Tuple.of(5),
+                                Tuple.of(8)));
+                assertThat(refineryTuple.getSize(), is(4));
+                assertThat(refineryTuple.get(0), is(2));
+                assertThat(refineryTuple.get(1), is(3));
+                assertThat(refineryTuple.get(2), is(5));
+                assertThat(refineryTuple.get(3), is(8));
+                assertThat(refineryTuple, instanceOf(Tuple4.class));
+        }
+
+        @Test
+        void toRefinery5Test() {
+                var refineryTuple = MatcherUtils.toRefineryTuple(Tuples.flatTupleOf(Tuple.of(2), Tuple.of(3), Tuple.of(5),
+                                Tuple.of(8), Tuple.of(13)));
+                assertThat(refineryTuple.getSize(), is(5));
+                assertThat(refineryTuple.get(0), is(2));
+                assertThat(refineryTuple.get(1), is(3));
+                assertThat(refineryTuple.get(2), is(5));
+                assertThat(refineryTuple.get(3), is(8));
+                assertThat(refineryTuple.get(4), is(13));
+                assertThat(refineryTuple, instanceOf(TupleN.class));
+        }
+
+        @Test
+        void toRefineryInvalidValueTest() {
+                var viatraTuple = Tuples.flatTupleOf(Tuple.of(2), -98);
+                assertThrows(IllegalArgumentException.class, () -> MatcherUtils.toRefineryTuple(viatraTuple));
+        }
+
+        @Test
+        void keyToRefinery0Test() {
+                var refineryTuple = MatcherUtils.keyToRefineryTuple(Tuples.flatTupleOf(-99));
+                assertThat(refineryTuple.getSize(), is(0));
+                assertThat(refineryTuple, instanceOf(Tuple0.class));
+        }
+
+        @Test
+        void keyToRefinery1Test() {
+                var refineryTuple = MatcherUtils.keyToRefineryTuple(Tuples.flatTupleOf(Tuple.of(2), -99));
+                assertThat(refineryTuple.getSize(), is(1));
+                assertThat(refineryTuple.get(0), is(2));
+                assertThat(refineryTuple, instanceOf(Tuple1.class));
+        }
+
+        @Test
+        void keyToRefinery2Test() {
+                var refineryTuple = MatcherUtils.keyToRefineryTuple(Tuples.flatTupleOf(Tuple.of(2), Tuple.of(3), -99));
+                assertThat(refineryTuple.getSize(), is(2));
+                assertThat(refineryTuple.get(0), is(2));
+                assertThat(refineryTuple.get(1), is(3));
+                assertThat(refineryTuple, instanceOf(Tuple2.class));
+        }
+
+        @Test
+        void keyToRefinery3Test() {
+                var refineryTuple = MatcherUtils.keyToRefineryTuple(Tuples.flatTupleOf(Tuple.of(2), Tuple.of(3), Tuple.of(5),
+                                -99));
+                assertThat(refineryTuple.getSize(), is(3));
+                assertThat(refineryTuple.get(0), is(2));
+                assertThat(refineryTuple.get(1), is(3));
+                assertThat(refineryTuple.get(2), is(5));
+                assertThat(refineryTuple, instanceOf(Tuple3.class));
+        }
+
+        @Test
+        void keyToRefinery4Test() {
+                var refineryTuple = MatcherUtils.keyToRefineryTuple(Tuples.flatTupleOf(Tuple.of(2), Tuple.of(3), Tuple.of(5),
+                                Tuple.of(8), -99));
+                assertThat(refineryTuple.getSize(), is(4));
+                assertThat(refineryTuple.get(0), is(2));
+                assertThat(refineryTuple.get(1), is(3));
+                assertThat(refineryTuple.get(2), is(5));
+                assertThat(refineryTuple.get(3), is(8));
+                assertThat(refineryTuple, instanceOf(Tuple4.class));
+        }
+
+        @Test
+        void keyToRefinery5Test() {
+                var refineryTuple = MatcherUtils.keyToRefineryTuple(Tuples.flatTupleOf(Tuple.of(2), Tuple.of(3), Tuple.of(5),
+                                Tuple.of(8), Tuple.of(13), -99));
+                assertThat(refineryTuple.getSize(), is(5));
+                assertThat(refineryTuple.get(0), is(2));
+                assertThat(refineryTuple.get(1), is(3));
+                assertThat(refineryTuple.get(2), is(5));
+                assertThat(refineryTuple.get(3), is(8));
+                assertThat(refineryTuple.get(4), is(13));
+                assertThat(refineryTuple, instanceOf(TupleN.class));
+        }
+
+        @Test
+        void keyToRefineryTooShortTest() {
+                var viatraTuple = Tuples.flatTupleOf();
+                assertThrows(IllegalArgumentException.class, () -> MatcherUtils.keyToRefineryTuple(viatraTuple));
+        }
+
+        @Test
+        void keyToRefineryInvalidValueTest() {
+                var viatraTuple = Tuples.flatTupleOf(Tuple.of(2), -98, -99);
+                assertThrows(IllegalArgumentException.class, () -> MatcherUtils.keyToRefineryTuple(viatraTuple));
+        }
+
+        @Test
+        void getSingleValueTest() {
+                var value = MatcherUtils.getSingleValue(List.of(Tuples.flatTupleOf(Tuple.of(2), -99)));
+                assertThat(value, is(-99));
+        }
+
+        // Static analysis accurately determines that the result is always {@code null}, but we check anyways.
+        @SuppressWarnings("ConstantValue")
+        @Test
+        void getSingleValueNullTest() {
+                var value = MatcherUtils.getSingleValue((Iterable<? extends ITuple>) null);
+                assertThat(value, nullValue());
+        }
+
+        @Test
+        void getSingleValueEmptyTest() {
+                var value = MatcherUtils.getSingleValue(List.of());
+                assertThat(value, nullValue());
+        }
+
+        @Test
+        void getSingleValueMultipleTest() {
+                var viatraTuples = List.of(Tuples.flatTupleOf(Tuple.of(2), -98), Tuples.flatTupleOf(Tuple.of(2), -99));
+                assertThrows(IllegalStateException.class, () -> MatcherUtils.getSingleValue(viatraTuples));
+        }
+}
diff --git a/subprojects/store-query-viatra/src/test/java/tools/refinery/store/query/viatra/tests/QueryAssertions.java b/subprojects/store-query-viatra/src/test/java/tools/refinery/store/query/viatra/tests/QueryAssertions.java
index 6f50ec73..2769621d 100644
--- a/subprojects/store-query-viatra/src/test/java/tools/refinery/store/query/viatra/tests/QueryAssertions.java
+++ b/subprojects/store-query-viatra/src/test/java/tools/refinery/store/query/viatra/tests/QueryAssertions.java
@@ -42,7 +42,7 @@ public final class QueryAssertions {
                 var cursor = resultSet.getAll();
                 while (cursor.move()) {
                         var key = cursor.getKey();
-                        var previous = actual.put(key.toTuple(), cursor.getValue());
+                        var previous = actual.put(key, cursor.getValue());
                         assertThat("duplicate value for key " + key, previous, nullValue());
                 }
                 executables.add(() -> assertThat("results cursor", actual, is(filteredExpected)));