diff --git a/tests/tck/conftest.py b/tests/tck/conftest.py
index e86491d9d485b47af30c3295d6cd54ed4189da1c..d7f12760ea3ed8b584d826d7ceaf4e6c973c1482 100644
--- a/tests/tck/conftest.py
+++ b/tests/tck/conftest.py
@@ -11,6 +11,7 @@ import io
 import csv
 import re
 
+from nebula2.common.ttypes import Value
 from nebula2.graph.ttypes import ErrorCode
 from pytest_bdd import given, parsers, then, when
 
@@ -137,6 +138,24 @@ def line_number(steps, result):
             return step.line_number
     return -1
 
+# IN literal `1, 2, 3...'
+def parse_list(s: str):
+    numbers = s.split(',')
+    numbers_list = []
+    for num in numbers:
+        numbers_list.append(int(num))
+    return numbers_list
+
+def hash_columns(ds, hashed_columns):
+    if len(hashed_columns) == 0:
+        return ds
+    for col in hashed_columns:
+        assert col < len(ds.column_names), "The hashed column should in range."
+    for row in ds.rows:
+        for col in hashed_columns:
+            if row.values[col].getType() != Value.NVAL and row.values[col].getType() != Value.__EMPTY__:
+                row.values[col] = Value(iVal = murmurhash2(row.values[col]))
+    return ds
 
 def cmp_dataset(
         request,
@@ -145,6 +164,7 @@ def cmp_dataset(
         order: bool,
         strict: bool,
         included=False,
+        hashed_columns = [],
 ) -> None:
     rs = graph_spaces['result_set']
     ngql = graph_spaces['ngql']
@@ -157,6 +177,7 @@ def cmp_dataset(
         table(result, lambda x: normalize_outline_scenario(request, x)),
         graph_spaces.get("variables", {}),
     )
+    ds = hash_columns(ds, hashed_columns)
     dscmp = DataSetComparator(strict=strict,
                               order=order,
                               included=included,
@@ -210,21 +231,33 @@ def define_list_var_alias(text, graph_spaces):
 def result_should_be_in_order(request, result, graph_spaces):
     cmp_dataset(request, graph_spaces, result, order=True, strict=True)
 
+@then(parse("the result should be, in order, and the columns {hashed_columns} should be hashed:\n{result}"))
+def result_should_be_in_order_and_hash(request, result, graph_spaces, hashed_columns):
+    cmp_dataset(request, graph_spaces, result, order=True, strict=True, hashed_columns=parse_list(hashed_columns))
 
 @then(parse("the result should be, in order, with relax comparison:\n{result}"))
 def result_should_be_in_order_relax_cmp(request, result, graph_spaces):
     cmp_dataset(request, graph_spaces, result, order=True, strict=False)
 
+@then(parse("the result should be, in order, with relax comparison, and the columns {hashed_columns} should be hashed:\n{result}"))
+def result_should_be_in_order_relax_cmp_and_hash(request, result, graph_spaces, hashed_columns):
+    cmp_dataset(request, graph_spaces, result, order=True, strict=False, hashed_columns=parse_list(hashed_columns))
 
 @then(parse("the result should be, in any order:\n{result}"))
 def result_should_be(request, result, graph_spaces):
     cmp_dataset(request, graph_spaces, result, order=False, strict=True)
 
+@then(parse("the result should be, in any order, and the columns {hashed_columns} should be hashed:\n{result}"))
+def result_should_be_and_hash(request, result, graph_spaces, hashed_columns):
+    cmp_dataset(request, graph_spaces, result, order=False, strict=True, hashed_columns=parse_list(hashed_columns))
 
 @then(parse("the result should be, in any order, with relax comparison:\n{result}"))
 def result_should_be_relax_cmp(request, result, graph_spaces):
     cmp_dataset(request, graph_spaces, result, order=False, strict=False)
 
+@then(parse("the result should be, in any order, with relax comparison, and the columns {hashed_columns} should be hashed:\n{result}"))
+def result_should_be_relax_cmp_and_hash(request, result, graph_spaces, hashed_columns):
+    cmp_dataset(request, graph_spaces, result, order=False, strict=False, hashed_columns=parse_list(hashed_columns))
 
 @then(parse("the result should include:\n{result}"))
 def result_should_include(request, result, graph_spaces):
@@ -235,6 +268,16 @@ def result_should_include(request, result, graph_spaces):
                 strict=True,
                 included=True)
 
+@then(parse("the result should include, and the columns {hashed_columns} should be hashed:\n{result}"))
+def result_should_include_and_hash(request, result, graph_spaces, hashed_columns):
+    cmp_dataset(request,
+                graph_spaces,
+                result,
+                order=False,
+                strict=True,
+                included=True,
+                hashed_columns=parse_list(hashed_columns))
+
 
 @then("no side effects")
 def no_side_effects():
diff --git a/tests/tck/features/delete/DeleteEdge.IntVid.feature b/tests/tck/features/delete/DeleteEdge.IntVid.feature
index 7d2f000c7c8d0b3447815ccc7ded65ba902c2ec2..7a67682aa350b0b93e0cd25dfd1c1bb1b1f6d456 100644
--- a/tests/tck/features/delete/DeleteEdge.IntVid.feature
+++ b/tests/tck/features/delete/DeleteEdge.IntVid.feature
@@ -45,31 +45,31 @@ Feature: Delete int vid of edge
       GO FROM hash("Zhangsan"), hash("Jack") OVER friend
       YIELD $^.person.name, friend.intimacy, friend._dst
       """
-    Then the result should be, in any order:
-      | $^.person.name | friend.intimacy | friend._dst  |
-      | "Zhangsan"     | 90              | hash("Lisi") |
-      | "Zhangsan"     | 50              | hash("Jack") |
-      | "Jack"         | 100             | hash("Rose") |
+    Then the result should be, in any order, and the columns 2 should be hashed:
+      | $^.person.name | friend.intimacy | friend._dst |
+      | "Zhangsan"     | 90              | "Lisi"      |
+      | "Zhangsan"     | 50              | "Jack"      |
+      | "Jack"         | 100             | "Rose"      |
     # before delete edge to check value by go
     When executing query:
       """
       GO FROM hash("Zhangsan"), hash("Lisi") OVER schoolmate
       YIELD $^.person.name, schoolmate.likeness, schoolmate._dst
       """
-    Then the result should be, in any order:
+    Then the result should be, in any order, and the columns 2 should be hashed:
       | $^.person.name | schoolmate.likeness | schoolmate._dst |
-      | "Zhangsan"     | 60                  | hash("Jack")    |
-      | "Lisi"         | 70                  | hash("Rose")    |
+      | "Zhangsan"     | 60                  | "Jack"          |
+      | "Lisi"         | 70                  | "Rose"          |
     # before delete edge to check value by go
     When executing query:
       """
       GO FROM hash("Zhangsan") OVER transfer
       YIELD $^.person.name,transfer._rank, transfer.money, transfer._dst
       """
-    Then the result should be, in any order:
+    Then the result should be, in any order, and the columns 3 should be hashed:
       | $^.person.name | transfer._rank | transfer.money | transfer._dst |
-      | "Zhangsan"     | 1561013236     | 33             | hash("Lisi")  |
-      | "Zhangsan"     | 1561013237     | 77             | hash("Lisi")  |
+      | "Zhangsan"     | 1561013236     | 33             | "Lisi"        |
+      | "Zhangsan"     | 1561013237     | 77             | "Lisi"        |
     # delete edge friend
     When executing query:
       """
@@ -94,27 +94,27 @@ Feature: Delete int vid of edge
       GO FROM hash("Zhangsan"), hash("Jack") OVER friend
       YIELD $^.person.name, friend.intimacy, friend._dst
       """
-    Then the result should be, in any order:
-      | $^.person.name | friend.intimacy | friend._dst  |
-      | "Zhangsan"     | 50              | hash("Jack") |
+    Then the result should be, in any order, and the columns 2 should be hashed:
+      | $^.person.name | friend.intimacy | friend._dst |
+      | "Zhangsan"     | 50              | "Jack"      |
     # after delete edge to check value by go
     When executing query:
       """
       GO FROM hash("Zhangsan"), hash("Lisi") OVER schoolmate
       YIELD $^.person.name, schoolmate.likeness, schoolmate._dst
       """
-    Then the result should be, in any order:
+    Then the result should be, in any order, and the columns 2 should be hashed:
       | $^.person.name | schoolmate.likeness | schoolmate._dst |
-      | "Zhangsan"     | 60                  | hash("Jack")    |
+      | "Zhangsan"     | 60                  | "Jack"          |
     # after delete edge to check value by go
     When executing query:
       """
       GO FROM hash("Zhangsan") OVER transfer
       YIELD $^.person.name,transfer._rank, transfer.money, transfer._dst
       """
-    Then the result should be, in any order:
+    Then the result should be, in any order, and the columns 3 should be hashed:
       | $^.person.name | transfer._rank | transfer.money | transfer._dst |
-      | "Zhangsan"     | 1561013236     | 33             | hash("Lisi")  |
+      | "Zhangsan"     | 1561013236     | 33             | "Lisi"        |
     # delete non-existing edges and a same edge
     When executing query:
       """
@@ -127,7 +127,7 @@ Feature: Delete int vid of edge
       GO FROM hash("Zhangsan"),hash("Jack") OVER friend
       YIELD $^.person.name, friend.intimacy, friend._dst
       """
-    Then the result should be, in any order:
-      | $^.person.name | friend.intimacy | friend._dst  |
-      | "Zhangsan"     | 50              | hash("Jack") |
+    Then the result should be, in any order, and the columns 2 should be hashed:
+      | $^.person.name | friend.intimacy | friend._dst |
+      | "Zhangsan"     | 50              | "Jack"      |
     Then drop the used space
diff --git a/tests/tck/features/delete/DeleteVertex.IntVid.feature b/tests/tck/features/delete/DeleteVertex.IntVid.feature
index 8d7f76a1f212ae282d2b48693d8d4cac3c6fa37e..c8127b12eab8f18c68eb704ef38fba732cb8dfe5 100644
--- a/tests/tck/features/delete/DeleteVertex.IntVid.feature
+++ b/tests/tck/features/delete/DeleteVertex.IntVid.feature
@@ -13,37 +13,37 @@ Feature: Delete int vid of vertex
       """
       GO FROM hash("Boris Diaw") OVER like
       """
-    Then the result should be, in any order:
-      | like._dst           |
-      | hash("Tony Parker") |
-      | hash("Tim Duncan")  |
+    Then the result should be, in any order, and the columns 0 should be hashed:
+      | like._dst     |
+      | "Tony Parker" |
+      | "Tim Duncan"  |
     When executing query:
       """
       GO FROM hash("Tony Parker") OVER like REVERSELY
       """
-    Then the result should be, in any order:
-      | like._dst                 |
-      | hash("LaMarcus Aldridge") |
-      | hash("Boris Diaw")        |
-      | hash("Dejounte Murray")   |
-      | hash("Marco Belinelli")   |
-      | hash("Tim Duncan")        |
+    Then the result should be, in any order, and the columns 0 should be hashed:
+      | like._dst           |
+      | "LaMarcus Aldridge" |
+      | "Boris Diaw"        |
+      | "Dejounte Murray"   |
+      | "Marco Belinelli"   |
+      | "Tim Duncan"        |
     # get value by fetch
     When executing query:
       """
       FETCH PROP ON player hash("Tony Parker") YIELD player.name, player.age
       """
-    Then the result should be, in any order:
-      | VertexID            | player.name   | player.age |
-      | hash("Tony Parker") | "Tony Parker" | 36         |
+    Then the result should be, in any order, and the columns 0 should be hashed:
+      | VertexID      | player.name   | player.age |
+      | "Tony Parker" | "Tony Parker" | 36         |
     # check value by fetch
     When executing query:
       """
       FETCH PROP ON serve hash("Tony Parker")->hash("Spurs") YIELD serve.start_year, serve.end_year
       """
-    Then the result should be, in any order:
-      | serve._src          | serve._dst    | serve._rank | serve.start_year | serve.end_year |
-      | hash('Tony Parker') | hash('Spurs') | 0           | 1999             | 2018           |
+    Then the result should be, in any order, and the columns 0,1 should be hashed:
+      | serve._src    | serve._dst | serve._rank | serve.start_year | serve.end_year |
+      | 'Tony Parker' | 'Spurs'    | 0           | 1999             | 2018           |
     # delete one vertex
     When executing query:
       """
@@ -69,9 +69,9 @@ Feature: Delete int vid of vertex
       """
       GO FROM hash("Boris Diaw") OVER like
       """
-    Then the result should be, in any order:
-      | like._dst          |
-      | hash("Tim Duncan") |
+    Then the result should be, in any order, and the columns 0 should be hashed:
+      | like._dst    |
+      | "Tim Duncan" |
     # after delete to check value by go
     When executing query:
       """
@@ -84,11 +84,11 @@ Feature: Delete int vid of vertex
       """
       GO FROM hash("Chris Paul") OVER like
       """
-    Then the result should be, in any order:
-      | like._dst               |
-      | hash("LeBron James")    |
-      | hash("Dwyane Wade")     |
-      | hash("Carmelo Anthony") |
+    Then the result should be, in any order, and the columns 0 should be hashed:
+      | like._dst         |
+      | "LeBron James"    |
+      | "Dwyane Wade"     |
+      | "Carmelo Anthony" |
     # delete multi vertexes
     When executing query:
       """
@@ -147,10 +147,10 @@ Feature: Delete int vid of vertex
       """
       GO FROM hash("Tracy McGrady") OVER like
       """
-    Then the result should be, in any order:
-      | like._dst           |
-      | hash("Kobe Bryant") |
-      | hash("Rudy Gay")    |
+    Then the result should be, in any order, and the columns 0 should be hashed:
+      | like._dst     |
+      | "Kobe Bryant" |
+      | "Rudy Gay"    |
     # after delete hash id vertex to check value by go
     When executing query:
       """
diff --git a/tests/tck/features/fetch/FetchEdges.intVid.feature b/tests/tck/features/fetch/FetchEdges.intVid.feature
index 25aa9f9611c1c6a5c423e7dffd9c97ce58c85b8c..a73c6e84f7298b13839aa62035be76e63df9798a 100644
--- a/tests/tck/features/fetch/FetchEdges.intVid.feature
+++ b/tests/tck/features/fetch/FetchEdges.intVid.feature
@@ -8,72 +8,72 @@ Feature: Fetch Int Vid Edges
       """
       FETCH PROP ON serve hash('Boris Diaw') -> hash('Hawks') YIELD serve.start_year, serve.end_year
       """
-    Then the result should be, in any order:
-      | serve._src         | serve._dst    | serve._rank | serve.start_year | serve.end_year |
-      | hash("Boris Diaw") | hash("Hawks") | 0           | 2003             | 2005           |
+    Then the result should be, in any order, and the columns 0,1 should be hashed:
+      | serve._src   | serve._dst | serve._rank | serve.start_year | serve.end_year |
+      | "Boris Diaw" | "Hawks"    | 0           | 2003             | 2005           |
 
   Scenario: [2] Fetch prop on an edge
     When executing query:
       """
       FETCH PROP ON serve hash('Boris Diaw')->hash('Hawks') YIELD serve.start_year > 2001, serve.end_year
       """
-    Then the result should be, in any order:
-      | serve._src         | serve._dst    | serve._rank | (serve.start_year>2001) | serve.end_year |
-      | hash("Boris Diaw") | hash("Hawks") | 0           | True                    | 2005           |
+    Then the result should be, in any order, and the columns 0,1 should be hashed:
+      | serve._src   | serve._dst | serve._rank | (serve.start_year>2001) | serve.end_year |
+      | "Boris Diaw" | "Hawks"    | 0           | True                    | 2005           |
 
   Scenario: [3] Fetch prop on the edgetype of a edge with ranking
     When executing query:
       """
       FETCH PROP ON serve hash('Boris Diaw')->hash('Hawks')@0 YIELD serve.start_year, serve.end_year
       """
-    Then the result should be, in any order:
-      | serve._src         | serve._dst    | serve._rank | serve.start_year | serve.end_year |
-      | hash("Boris Diaw") | hash("Hawks") | 0           | 2003             | 2005           |
+    Then the result should be, in any order, and the columns 0,1 should be hashed:
+      | serve._src   | serve._dst | serve._rank | serve.start_year | serve.end_year |
+      | "Boris Diaw" | "Hawks"    | 0           | 2003             | 2005           |
 
   Scenario: [4] Fetch prop on multiple edges
     When executing query:
       """
       FETCH PROP ON serve hash('Boris Diaw')->hash('Hawks'),hash('Boris Diaw')->hash('Suns') YIELD serve.start_year, serve.end_year
       """
-    Then the result should be, in any order:
-      | serve._src         | serve._dst    | serve._rank | serve.start_year | serve.end_year |
-      | hash("Boris Diaw") | hash("Hawks") | 0           | 2003             | 2005           |
-      | hash("Boris Diaw") | hash("Suns")  | 0           | 2005             | 2008           |
+    Then the result should be, in any order, and the columns 0,1 should be hashed:
+      | serve._src   | serve._dst | serve._rank | serve.start_year | serve.end_year |
+      | "Boris Diaw" | "Hawks"    | 0           | 2003             | 2005           |
+      | "Boris Diaw" | "Suns"     | 0           | 2005             | 2008           |
 
   Scenario: [5] Fetch prop works with pipeline
     When executing query:
       """
       GO FROM hash('Boris Diaw') OVER serve YIELD serve._src AS src, serve._dst AS dst | FETCH PROP ON serve $-.src->$-.dst YIELD serve.start_year, serve.end_year
       """
-    Then the result should be, in any order:
-      | serve._src         | serve._dst      | serve._rank | serve.start_year | serve.end_year |
-      | hash("Boris Diaw") | hash("Suns")    | 0           | 2005             | 2008           |
-      | hash("Boris Diaw") | hash("Hawks")   | 0           | 2003             | 2005           |
-      | hash("Boris Diaw") | hash("Spurs")   | 0           | 2012             | 2016           |
-      | hash("Boris Diaw") | hash("Hornets") | 0           | 2008             | 2012           |
-      | hash("Boris Diaw") | hash("Jazz")    | 0           | 2016             | 2017           |
+    Then the result should be, in any order, and the columns 0,1 should be hashed:
+      | serve._src   | serve._dst | serve._rank | serve.start_year | serve.end_year |
+      | "Boris Diaw" | "Suns"     | 0           | 2005             | 2008           |
+      | "Boris Diaw" | "Hawks"    | 0           | 2003             | 2005           |
+      | "Boris Diaw" | "Spurs"    | 0           | 2012             | 2016           |
+      | "Boris Diaw" | "Hornets"  | 0           | 2008             | 2012           |
+      | "Boris Diaw" | "Jazz"     | 0           | 2016             | 2017           |
 
   Scenario: [6] Fetch prop works with user define variable
     When executing query:
       """
       $var = GO FROM hash('Boris Diaw') OVER serve YIELD serve._src AS src, serve._dst AS dst; FETCH PROP ON serve $var.src->$var.dst YIELD serve.start_year, serve.end_year
       """
-    Then the result should be, in any order:
-      | serve._src         | serve._dst      | serve._rank | serve.start_year | serve.end_year |
-      | hash("Boris Diaw") | hash("Suns")    | 0           | 2005             | 2008           |
-      | hash("Boris Diaw") | hash("Hawks")   | 0           | 2003             | 2005           |
-      | hash("Boris Diaw") | hash("Spurs")   | 0           | 2012             | 2016           |
-      | hash("Boris Diaw") | hash("Hornets") | 0           | 2008             | 2012           |
-      | hash("Boris Diaw") | hash("Jazz")    | 0           | 2016             | 2017           |
+    Then the result should be, in any order, and the columns 0,1 should be hashed:
+      | serve._src   | serve._dst | serve._rank | serve.start_year | serve.end_year |
+      | "Boris Diaw" | "Suns"     | 0           | 2005             | 2008           |
+      | "Boris Diaw" | "Hawks"    | 0           | 2003             | 2005           |
+      | "Boris Diaw" | "Spurs"    | 0           | 2012             | 2016           |
+      | "Boris Diaw" | "Hornets"  | 0           | 2008             | 2012           |
+      | "Boris Diaw" | "Jazz"     | 0           | 2016             | 2017           |
 
   Scenario: [7] Fetch prop works with hash function
     When executing query:
       """
       FETCH PROP ON serve hash('Boris Diaw')->hash('Hawks') YIELD serve.start_year, serve.end_year
       """
-    Then the result should be, in any order:
-      | serve._src         | serve._dst    | serve._rank | serve.start_year | serve.end_year |
-      | hash("Boris Diaw") | hash("Hawks") | 0           | 2003             | 2005           |
+    Then the result should be, in any order, and the columns 0,1 should be hashed:
+      | serve._src   | serve._dst | serve._rank | serve.start_year | serve.end_year |
+      | "Boris Diaw" | "Hawks"    | 0           | 2003             | 2005           |
 
   @skip
   Scenario: [8] Fetch prop works with uuid
@@ -90,27 +90,27 @@ Feature: Fetch Int Vid Edges
       """
       FETCH PROP ON serve hash('Boris Diaw')->hash('Hawks')
       """
-    Then the result should be, in any order:
-      | serve._src         | serve._dst    | serve._rank | serve.start_year | serve.end_year |
-      | hash("Boris Diaw") | hash("Hawks") | 0           | 2003             | 2005           |
+    Then the result should be, in any order, and the columns 0,1 should be hashed:
+      | serve._src   | serve._dst | serve._rank | serve.start_year | serve.end_year |
+      | "Boris Diaw" | "Hawks"    | 0           | 2003             | 2005           |
 
   Scenario: [10] Fetch prop on a edge with a rank,but without yield
     When executing query:
       """
       FETCH PROP ON serve hash('Boris Diaw')->hash('Hawks')@0
       """
-    Then the result should be, in any order:
-      | serve._src         | serve._dst    | serve._rank | serve.start_year | serve.end_year |
-      | hash("Boris Diaw") | hash("Hawks") | 0           | 2003             | 2005           |
+    Then the result should be, in any order, and the columns 0,1 should be hashed:
+      | serve._src   | serve._dst | serve._rank | serve.start_year | serve.end_year |
+      | "Boris Diaw" | "Hawks"    | 0           | 2003             | 2005           |
 
   Scenario: [11] Fetch prop on a edge
     When executing query:
       """
       FETCH PROP ON serve hash('Boris Diaw')->hash('Hawks')
       """
-    Then the result should be, in any order:
-      | serve._src         | serve._dst    | serve._rank | serve.start_year | serve.end_year |
-      | hash("Boris Diaw") | hash("Hawks") | 0           | 2003             | 2005           |
+    Then the result should be, in any order, and the columns 0,1 should be hashed:
+      | serve._src   | serve._dst | serve._rank | serve.start_year | serve.end_year |
+      | "Boris Diaw" | "Hawks"    | 0           | 2003             | 2005           |
 
   @skip
   Scenario: [12] Fetch prop works with uuid, but without YIELD
@@ -127,46 +127,46 @@ Feature: Fetch Int Vid Edges
       """
       FETCH PROP ON serve hash('Boris Diaw')->hash('Hawks'),hash('Boris Diaw')->hash('Hawks') YIELD DISTINCT serve.start_year, serve.end_year
       """
-    Then the result should be, in any order:
-      | serve._src         | serve._dst    | serve._rank | serve.start_year | serve.end_year |
-      | hash("Boris Diaw") | hash("Hawks") | 0           | 2003             | 2005           |
+    Then the result should be, in any order, and the columns 0,1 should be hashed:
+      | serve._src   | serve._dst | serve._rank | serve.start_year | serve.end_year |
+      | "Boris Diaw" | "Hawks"    | 0           | 2003             | 2005           |
 
   Scenario: [14] Fetch prop works with DISTINCT and pipeline
     When executing query:
       """
       GO FROM hash('Boris Diaw'),hash('Boris Diaw') OVER serve YIELD serve._src AS src, serve._dst AS dst | FETCH PROP ON serve $-.src->$-.dst YIELD DISTINCT serve.start_year, serve.end_year
       """
-    Then the result should be, in any order:
-      | serve._src         | serve._dst      | serve._rank | serve.start_year | serve.end_year |
-      | hash("Boris Diaw") | hash("Suns")    | 0           | 2005             | 2008           |
-      | hash("Boris Diaw") | hash("Hawks")   | 0           | 2003             | 2005           |
-      | hash("Boris Diaw") | hash("Spurs")   | 0           | 2012             | 2016           |
-      | hash("Boris Diaw") | hash("Hornets") | 0           | 2008             | 2012           |
-      | hash("Boris Diaw") | hash("Jazz")    | 0           | 2016             | 2017           |
+    Then the result should be, in any order, and the columns 0,1 should be hashed:
+      | serve._src   | serve._dst | serve._rank | serve.start_year | serve.end_year |
+      | "Boris Diaw" | "Suns"     | 0           | 2005             | 2008           |
+      | "Boris Diaw" | "Hawks"    | 0           | 2003             | 2005           |
+      | "Boris Diaw" | "Spurs"    | 0           | 2012             | 2016           |
+      | "Boris Diaw" | "Hornets"  | 0           | 2008             | 2012           |
+      | "Boris Diaw" | "Jazz"     | 0           | 2016             | 2017           |
 
   Scenario: [15] Fetch prop works with DISTINCT and user define variable
     When executing query:
       """
       $var = GO FROM hash('Boris Diaw'),hash('Boris Diaw') OVER serve YIELD serve._src AS src, serve._dst AS dst; FETCH PROP ON serve $var.src->$var.dst YIELD DISTINCT serve.start_year, serve.end_year
       """
-    Then the result should be, in any order:
-      | serve._src         | serve._dst      | serve._rank | serve.start_year | serve.end_year |
-      | hash("Boris Diaw") | hash("Suns")    | 0           | 2005             | 2008           |
-      | hash("Boris Diaw") | hash("Hawks")   | 0           | 2003             | 2005           |
-      | hash("Boris Diaw") | hash("Spurs")   | 0           | 2012             | 2016           |
-      | hash("Boris Diaw") | hash("Hornets") | 0           | 2008             | 2012           |
-      | hash("Boris Diaw") | hash("Jazz")    | 0           | 2016             | 2017           |
+    Then the result should be, in any order, and the columns 0,1 should be hashed:
+      | serve._src   | serve._dst | serve._rank | serve.start_year | serve.end_year |
+      | "Boris Diaw" | "Suns"     | 0           | 2005             | 2008           |
+      | "Boris Diaw" | "Hawks"    | 0           | 2003             | 2005           |
+      | "Boris Diaw" | "Spurs"    | 0           | 2012             | 2016           |
+      | "Boris Diaw" | "Hornets"  | 0           | 2008             | 2012           |
+      | "Boris Diaw" | "Jazz"     | 0           | 2016             | 2017           |
 
   Scenario: [16] Fetch prop works with DISTINCT
     When executing query:
       """
       GO FROM hash('Tim Duncan'),hash('Tony Parker') OVER serve YIELD serve._src AS src, serve._dst AS dst | FETCH PROP ON serve $-.src->$-.dst YIELD DISTINCT serve._dst as dst
       """
-    Then the result should be, in any order:
-      | serve._src          | serve._dst      | serve._rank | dst             |
-      | hash('Tim Duncan')  | hash('Spurs')   | 0           | hash('Spurs')   |
-      | hash('Tony Parker') | hash('Spurs')   | 0           | hash('Spurs')   |
-      | hash('Tony Parker') | hash('Hornets') | 0           | hash('Hornets') |
+    Then the result should be, in any order, and the columns 0,1,3 should be hashed:
+      | serve._src    | serve._dst | serve._rank | dst       |
+      | 'Tim Duncan'  | 'Spurs'    | 0           | 'Spurs'   |
+      | 'Tony Parker' | 'Spurs'    | 0           | 'Spurs'   |
+      | 'Tony Parker' | 'Hornets'  | 0           | 'Hornets' |
 
   Scenario: [17] Fetch prop on not existing vertex
     When executing query:
@@ -227,18 +227,18 @@ Feature: Fetch Int Vid Edges
       """
       FETCH PROP ON serve hash('Boris Diaw')->hash("Spurs") YIELD serve.start_year, serve.start_year
       """
-    Then the result should be, in any order:
-      | serve._src         | serve._dst    | serve._rank | serve.start_year | serve.start_year |
-      | hash("Boris Diaw") | hash("Spurs") | 0           | 2012             | 2012             |
+    Then the result should be, in any order, and the columns 0,1 should be hashed:
+      | serve._src   | serve._dst | serve._rank | serve.start_year | serve.start_year |
+      | "Boris Diaw" | "Spurs"    | 0           | 2012             | 2012             |
 
   Scenario: [25] Fetch prop on an edge and return duplicate _src, _dst and _rank
     When executing query:
       """
       FETCH PROP ON serve hash('Boris Diaw')->hash("Spurs") YIELD serve._src, serve._dst, serve._rank
       """
-    Then the result should be, in any order:
-      | serve._src         | serve._dst    | serve._rank | serve._src         | serve._dst    | serve._rank |
-      | hash("Boris Diaw") | hash("Spurs") | 0           | hash("Boris Diaw") | hash("Spurs") | 0           |
+    Then the result should be, in any order, and the columns 0,1,3,4 should be hashed:
+      | serve._src   | serve._dst | serve._rank | serve._src   | serve._dst | serve._rank |
+      | "Boris Diaw" | "Spurs"    | 0           | "Boris Diaw" | "Spurs"    | 0           |
 
   Scenario: [26] Fetch prop on illegal input
     When executing query:
diff --git a/tests/tck/features/fetch/FetchVertices.intVid.feature b/tests/tck/features/fetch/FetchVertices.intVid.feature
index df88fa0fb15169f46f1a9eaddcb98105bb72e308..2b27b92ee148668b86a3772eda43f55e42eef423 100644
--- a/tests/tck/features/fetch/FetchVertices.intVid.feature
+++ b/tests/tck/features/fetch/FetchVertices.intVid.feature
@@ -8,28 +8,28 @@ Feature: Fetch Int Vid Vertices
       """
       FETCH PROP ON player hash('Boris Diaw') YIELD player.name, player.age
       """
-    Then the result should be, in any order:
-      | VertexID           | player.name  | player.age |
-      | hash("Boris Diaw") | "Boris Diaw" | 36         |
+    Then the result should be, in any order, and the columns 0 should be hashed:
+      | VertexID     | player.name  | player.age |
+      | "Boris Diaw" | "Boris Diaw" | 36         |
 
   Scenario: [2] Fetch Vertices
     When executing query:
       """
       FETCH PROP ON player hash('Boris Diaw') YIELD player.name, player.age, player.age > 30
       """
-    Then the result should be, in any order:
-      | VertexID           | player.name  | player.age | (player.age>30) |
-      | hash("Boris Diaw") | "Boris Diaw" | 36         | True            |
+    Then the result should be, in any order, and the columns 0 should be hashed:
+      | VertexID     | player.name  | player.age | (player.age>30) |
+      | "Boris Diaw" | "Boris Diaw" | 36         | True            |
 
   Scenario: [3] Fetch dst vertices' props of go traversal.
     When executing query:
       """
       GO FROM hash('Boris Diaw') over like YIELD like._dst as id | FETCH PROP ON player $-.id YIELD player.name, player.age
       """
-    Then the result should be, in any order:
-      | VertexID            | player.name   | player.age |
-      | hash("Tony Parker") | "Tony Parker" | 36         |
-      | hash("Tim Duncan")  | "Tim Duncan"  | 42         |
+    Then the result should be, in any order, and the columns 0 should be hashed:
+      | VertexID      | player.name   | player.age |
+      | "Tony Parker" | "Tony Parker" | 36         |
+      | "Tim Duncan"  | "Tim Duncan"  | 42         |
 
   Scenario: [4] Fetch Vertices, different from v1.x
     When executing query:
@@ -43,10 +43,10 @@ Feature: Fetch Int Vid Vertices
       """
       $var = GO FROM hash('Boris Diaw') over like YIELD like._dst as id; FETCH PROP ON player $var.id YIELD player.name, player.age
       """
-    Then the result should be, in any order, with relax comparison:
-      | VertexID            | player.name   | player.age |
-      | hash("Tony Parker") | "Tony Parker" | 36         |
-      | hash("Tim Duncan")  | "Tim Duncan"  | 42         |
+    Then the result should be, in any order, with relax comparison, and the columns 0 should be hashed:
+      | VertexID      | player.name   | player.age |
+      | "Tony Parker" | "Tony Parker" | 36         |
+      | "Tim Duncan"  | "Tim Duncan"  | 42         |
 
   Scenario: [6] Fetch Vertices works with ORDER BY
     When executing query:
@@ -55,19 +55,19 @@ Feature: Fetch Int Vid Vertices
       FETCH PROP ON player $var.id YIELD player.name as name, player.age |
       ORDER BY name
       """
-    Then the result should be, in order:
-      | VertexID            | name          | player.age |
-      | hash("Tim Duncan")  | "Tim Duncan"  | 42         |
-      | hash("Tony Parker") | "Tony Parker" | 36         |
+    Then the result should be, in order, and the columns 0 should be hashed:
+      | VertexID      | name          | player.age |
+      | "Tim Duncan"  | "Tim Duncan"  | 42         |
+      | "Tony Parker" | "Tony Parker" | 36         |
 
   Scenario: [7] Fetch Vertices works with hash()
     When executing query:
       """
       FETCH PROP ON player hash('Boris Diaw') YIELD player.name, player.age
       """
-    Then the result should be, in any order, with relax comparison:
-      | VertexID           | player.name  | player.age |
-      | hash("Boris Diaw") | "Boris Diaw" | 36         |
+    Then the result should be, in any order, with relax comparison, and the columns 0 should be hashed:
+      | VertexID     | player.name  | player.age |
+      | "Boris Diaw" | "Boris Diaw" | 36         |
 
   @skip
   Scenario: [8] Fetch Vertices works with uuid() and YIELD
@@ -84,9 +84,9 @@ Feature: Fetch Int Vid Vertices
       """
       FETCH PROP ON player hash('Boris Diaw')
       """
-    Then the result should be, in any order, with relax comparison:
-      | VertexID           | player.name  | player.age |
-      | hash("Boris Diaw") | "Boris Diaw" | 36         |
+    Then the result should be, in any order, with relax comparison, and the columns 0 should be hashed:
+      | VertexID     | player.name  | player.age |
+      | "Boris Diaw" | "Boris Diaw" | 36         |
 
   @skip
   Scenario: [10] Fetch Vertices works with uuid(), without YIELD
@@ -103,18 +103,18 @@ Feature: Fetch Int Vid Vertices
       """
       FETCH PROP ON player hash('Boris Diaw'), hash('Boris Diaw') YIELD DISTINCT player.name, player.age
       """
-    Then the result should be, in any order, with relax comparison:
-      | VertexID           | player.name  | player.age |
-      | hash("Boris Diaw") | "Boris Diaw" | 36         |
+    Then the result should be, in any order, with relax comparison, and the columns 0 should be hashed:
+      | VertexID     | player.name  | player.age |
+      | "Boris Diaw" | "Boris Diaw" | 36         |
 
   Scenario: [13] Fetch Vertices
     When executing query:
       """
       FETCH PROP ON player hash('Boris Diaw'), hash('Boris Diaw') YIELD DISTINCT player.age
       """
-    Then the result should be, in any order, with relax comparison:
-      | VertexID           | player.age |
-      | hash("Boris Diaw") | 36         |
+    Then the result should be, in any order, with relax comparison, and the columns 0 should be hashed:
+      | VertexID     | player.age |
+      | "Boris Diaw" | 36         |
 
   Scenario: [14] Fetch Vertices not support get src property
     When executing query:
@@ -172,84 +172,84 @@ Feature: Fetch Int Vid Vertices
       """
       FETCH PROP ON * hash('Boris Diaw') yield player.name, player.age
       """
-    Then the result should be, in any order:
-      | VertexID           | player.name  | player.age |
-      | hash("Boris Diaw") | "Boris Diaw" | 36         |
+    Then the result should be, in any order, and the columns 0 should be hashed:
+      | VertexID     | player.name  | player.age |
+      | "Boris Diaw" | "Boris Diaw" | 36         |
 
   Scenario: [22] Fetch Vertices
     When executing query:
       """
       YIELD hash('Boris Diaw') as id | FETCH PROP ON * $-.id yield player.name, player.age
       """
-    Then the result should be, in any order:
-      | VertexID           | player.name  | player.age |
-      | hash("Boris Diaw") | "Boris Diaw" | 36         |
+    Then the result should be, in any order, and the columns 0 should be hashed:
+      | VertexID     | player.name  | player.age |
+      | "Boris Diaw" | "Boris Diaw" | 36         |
 
   Scenario: [23] Fetch Vertices
     When executing query:
       """
       FETCH PROP ON * hash('Boris Diaw'), hash('Boris Diaw') yield player.name, player.age
       """
-    Then the result should be, in any order:
-      | VertexID           | player.name  | player.age |
-      | hash("Boris Diaw") | "Boris Diaw" | 36         |
-      | hash("Boris Diaw") | "Boris Diaw" | 36         |
+    Then the result should be, in any order, and the columns 0 should be hashed:
+      | VertexID     | player.name  | player.age |
+      | "Boris Diaw" | "Boris Diaw" | 36         |
+      | "Boris Diaw" | "Boris Diaw" | 36         |
 
   Scenario: [24] Fetch Vertices
     When executing query:
       """
       FETCH PROP ON bachelor hash('Tim Duncan')
       """
-    Then the result should be, in any order:
-      | VertexID           | bachelor.name | bachelor.speciality |
-      | hash("Tim Duncan") | "Tim Duncan"  | "psychology"        |
+    Then the result should be, in any order, and the columns 0 should be hashed:
+      | VertexID     | bachelor.name | bachelor.speciality |
+      | "Tim Duncan" | "Tim Duncan"  | "psychology"        |
 
   Scenario: [25] Fetch Vertices
     When executing query:
       """
       FETCH PROP ON * hash('Tim Duncan') yield player.name, player.age, bachelor.name, bachelor.speciality
       """
-    Then the result should be, in any order:
-      | VertexID           | player.name  | player.age | bachelor.name | bachelor.speciality |
-      | hash("Tim Duncan") | "Tim Duncan" | 42         | "Tim Duncan"  | "psychology"        |
+    Then the result should be, in any order, and the columns 0 should be hashed:
+      | VertexID     | player.name  | player.age | bachelor.name | bachelor.speciality |
+      | "Tim Duncan" | "Tim Duncan" | 42         | "Tim Duncan"  | "psychology"        |
 
   Scenario: [26] Fetch Vertices
     When executing query:
       """
       YIELD hash('Tim Duncan') as id | FETCH PROP ON * $-.id yield player.name, player.age, bachelor.name, bachelor.speciality
       """
-    Then the result should be, in any order:
-      | VertexID           | player.name  | player.age | bachelor.name | bachelor.speciality |
-      | hash("Tim Duncan") | "Tim Duncan" | 42         | "Tim Duncan"  | "psychology"        |
+    Then the result should be, in any order, and the columns 0 should be hashed:
+      | VertexID     | player.name  | player.age | bachelor.name | bachelor.speciality |
+      | "Tim Duncan" | "Tim Duncan" | 42         | "Tim Duncan"  | "psychology"        |
 
   Scenario: [27] Fetch Vertices
     When executing query:
       """
       FETCH PROP ON * hash('Tim Duncan'), hash('Tim Duncan') yield player.name, bachelor.name
       """
-    Then the result should be, in any order:
-      | VertexID           | player.name  | bachelor.name |
-      | hash("Tim Duncan") | "Tim Duncan" | "Tim Duncan"  |
-      | hash("Tim Duncan") | "Tim Duncan" | "Tim Duncan"  |
+    Then the result should be, in any order, and the columns 0 should be hashed:
+      | VertexID     | player.name  | bachelor.name |
+      | "Tim Duncan" | "Tim Duncan" | "Tim Duncan"  |
+      | "Tim Duncan" | "Tim Duncan" | "Tim Duncan"  |
 
   Scenario: [28] Fetch Vertices
     When executing query:
       """
       FETCH PROP ON * hash('Tim Duncan'), hash('Tim Duncan') YIELD player.name, player.age
       """
-    Then the result should be, in any order:
-      | VertexID           | player.name  | player.age |
-      | hash("Tim Duncan") | "Tim Duncan" | 42         |
-      | hash("Tim Duncan") | "Tim Duncan" | 42         |
+    Then the result should be, in any order, and the columns 0 should be hashed:
+      | VertexID     | player.name  | player.age |
+      | "Tim Duncan" | "Tim Duncan" | 42         |
+      | "Tim Duncan" | "Tim Duncan" | 42         |
 
   Scenario: [29] Fetch Vertices
     When executing query:
       """
       FETCH PROP ON player hash('Boris Diaw') YIELD player.name, player.name
       """
-    Then the result should be, in any order:
-      | VertexID           | player.name  | player.name  |
-      | hash("Boris Diaw") | "Boris Diaw" | "Boris Diaw" |
+    Then the result should be, in any order, and the columns 0 should be hashed:
+      | VertexID     | player.name  | player.name  |
+      | "Boris Diaw" | "Boris Diaw" | "Boris Diaw" |
 
   Scenario: [30] Fetch Vertices
     When executing query:
diff --git a/tests/tck/features/go/GO.IntVid.feature b/tests/tck/features/go/GO.IntVid.feature
index ae6ace1fed835a7018583651af1748674931c21b..4a39f352e97e684cd5da5646df35b3d85fa83e44 100644
--- a/tests/tck/features/go/GO.IntVid.feature
+++ b/tests/tck/features/go/GO.IntVid.feature
@@ -12,24 +12,24 @@ Feature: IntegerVid Go  Sentence
       """
       GO FROM hash("Tim Duncan") OVER serve
       """
-    Then the result should be, in any order, with relax comparison:
-      | serve._dst    |
-      | hash("Spurs") |
+    Then the result should be, in any order, with relax comparison, and the columns 0 should be hashed:
+      | serve._dst |
+      | "Spurs"    |
     When executing query:
       """
       GO FROM hash("Tim Duncan"), hash("Tim Duncan") OVER serve
       """
-    Then the result should be, in any order, with relax comparison:
-      | serve._dst    |
-      | hash("Spurs") |
-      | hash("Spurs") |
+    Then the result should be, in any order, with relax comparison, and the columns 0 should be hashed:
+      | serve._dst |
+      | "Spurs"    |
+      | "Spurs"    |
     When executing query:
       """
       YIELD hash("Tim Duncan") as vid | GO FROM $-.vid OVER serve
       """
-    Then the result should be, in any order, with relax comparison:
-      | serve._dst    |
-      | hash("Spurs") |
+    Then the result should be, in any order, with relax comparison, and the columns 0 should be hashed:
+      | serve._dst |
+      | "Spurs"    |
     When executing query:
       """
       GO FROM hash("Boris Diaw") OVER serve YIELD $^.player.name, serve.start_year, serve.end_year, $$.team.name
@@ -57,41 +57,41 @@ Feature: IntegerVid Go  Sentence
       GO FROM hash("Boris Diaw") OVER like YIELD like._dst as id
       | GO FROM $-.id OVER like YIELD like._dst as id | GO FROM $-.id OVER serve
       """
-    Then the result should be, in any order, with relax comparison:
-      | serve._dst            |
-      | hash("Spurs")         |
-      | hash("Spurs")         |
-      | hash("Spurs")         |
-      | hash("Spurs")         |
-      | hash("Spurs")         |
-      | hash("Hornets")       |
-      | hash("Trail Blazers") |
+    Then the result should be, in any order, with relax comparison, and the columns 0 should be hashed:
+      | serve._dst      |
+      | "Spurs"         |
+      | "Spurs"         |
+      | "Spurs"         |
+      | "Spurs"         |
+      | "Spurs"         |
+      | "Hornets"       |
+      | "Trail Blazers" |
     When executing query:
       """
       GO FROM hash('Thunders') OVER serve REVERSELY
       """
-    Then the result should be, in any order, with relax comparison:
-      | serve._dst                |
-      | hash("Russell Westbrook") |
-      | hash("Kevin Durant")      |
-      | hash("James Harden")      |
-      | hash("Carmelo Anthony")   |
-      | hash("Paul George")       |
-      | hash("Ray Allen")         |
+    Then the result should be, in any order, with relax comparison, and the columns 0 should be hashed:
+      | serve._dst          |
+      | "Russell Westbrook" |
+      | "Kevin Durant"      |
+      | "James Harden"      |
+      | "Carmelo Anthony"   |
+      | "Paul George"       |
+      | "Ray Allen"         |
     When executing query:
       """
       GO FROM hash("Boris Diaw") OVER like YIELD like._dst as id
       |(GO FROM $-.id OVER like YIELD like._dst as id | GO FROM $-.id OVER serve)
       """
-    Then the result should be, in any order, with relax comparison:
-      | serve._dst            |
-      | hash("Spurs")         |
-      | hash("Spurs")         |
-      | hash("Spurs")         |
-      | hash("Spurs")         |
-      | hash("Spurs")         |
-      | hash("Hornets")       |
-      | hash("Trail Blazers") |
+    Then the result should be, in any order, with relax comparison, and the columns 0 should be hashed:
+      | serve._dst      |
+      | "Spurs"         |
+      | "Spurs"         |
+      | "Spurs"         |
+      | "Spurs"         |
+      | "Spurs"         |
+      | "Hornets"       |
+      | "Trail Blazers" |
     When executing query:
       """
       GO FROM hash("No Exist Vertex Id") OVER like YIELD like._dst as id
@@ -104,25 +104,25 @@ Feature: IntegerVid Go  Sentence
       GO FROM hash("Boris Diaw") OVER like, serve YIELD like._dst as id
       |(GO FROM $-.id OVER like YIELD like._dst as id | GO FROM $-.id OVER serve)
       """
-    Then the result should be, in any order, with relax comparison:
-      | serve._dst            |
-      | hash("Spurs")         |
-      | hash("Spurs")         |
-      | hash("Spurs")         |
-      | hash("Spurs")         |
-      | hash("Spurs")         |
-      | hash("Hornets")       |
-      | hash("Trail Blazers") |
+    Then the result should be, in any order, with relax comparison, and the columns 0 should be hashed:
+      | serve._dst      |
+      | "Spurs"         |
+      | "Spurs"         |
+      | "Spurs"         |
+      | "Spurs"         |
+      | "Spurs"         |
+      | "Hornets"       |
+      | "Trail Blazers" |
 
   Scenario: Integer Vid assignment simple
     When executing query:
       """
       $var = GO FROM hash("Tracy McGrady") OVER like YIELD like._dst as id; GO FROM $var.id OVER like
       """
-    Then the result should be, in any order, with relax comparison:
-      | like._dst                 |
-      | hash("Tracy McGrady")     |
-      | hash("LaMarcus Aldridge") |
+    Then the result should be, in any order, with relax comparison, and the columns 0 should be hashed:
+      | like._dst           |
+      | "Tracy McGrady"     |
+      | "LaMarcus Aldridge" |
 
   Scenario: Integer Vid assignment pipe
     When executing query:
@@ -130,24 +130,24 @@ Feature: IntegerVid Go  Sentence
       $var = (GO FROM hash("Tracy McGrady") OVER like YIELD like._dst as id | GO FROM $-.id OVER like YIELD like._dst as id);
       GO FROM $var.id OVER like
       """
-    Then the result should be, in any order, with relax comparison:
-      | like._dst           |
-      | hash("Kobe Bryant") |
-      | hash("Grant Hill")  |
-      | hash("Rudy Gay")    |
-      | hash("Tony Parker") |
-      | hash("Tim Duncan")  |
+    Then the result should be, in any order, with relax comparison, and the columns 0 should be hashed:
+      | like._dst     |
+      | "Kobe Bryant" |
+      | "Grant Hill"  |
+      | "Rudy Gay"    |
+      | "Tony Parker" |
+      | "Tim Duncan"  |
 
   Scenario: Integer Vid pipe only yield input prop
     When executing query:
       """
       GO FROM hash("Tracy McGrady") OVER like YIELD like._dst as vid | GO FROM $-.vid OVER like YIELD $-.vid as id
       """
-    Then the result should be, in any order, with relax comparison:
-      | id                  |
-      | hash("Kobe Bryant") |
-      | hash("Grant Hill")  |
-      | hash("Rudy Gay")    |
+    Then the result should be, in any order, with relax comparison, and the columns 0 should be hashed:
+      | id            |
+      | "Kobe Bryant" |
+      | "Grant Hill"  |
+      | "Rudy Gay"    |
 
   Scenario: Integer Vid pipe only yield constant
     When executing query:
@@ -189,20 +189,20 @@ Feature: IntegerVid Go  Sentence
       | GO FROM $-.id OVER serve
       YIELD DISTINCT serve._dst, $$.team.name
       """
-    Then the result should be, in any order, with relax comparison:
-      | serve._dst            | $$.team.name    |
-      | hash("Spurs")         | "Spurs"         |
-      | hash("Hornets")       | "Hornets"       |
-      | hash("Trail Blazers") | "Trail Blazers" |
+    Then the result should be, in any order, with relax comparison, and the columns 0 should be hashed:
+      | serve._dst      | $$.team.name    |
+      | "Spurs"         | "Spurs"         |
+      | "Hornets"       | "Hornets"       |
+      | "Trail Blazers" | "Trail Blazers" |
     When executing query:
       """
       GO 2 STEPS FROM hash("Tony Parker") OVER like YIELD DISTINCT like._dst
       """
-    Then the result should be, in any order, with relax comparison:
-      | like._dst             |
-      | hash("Tim Duncan")    |
-      | hash("Tony Parker")   |
-      | hash("Manu Ginobili") |
+    Then the result should be, in any order, with relax comparison, and the columns 0 should be hashed:
+      | like._dst       |
+      | "Tim Duncan"    |
+      | "Tony Parker"   |
+      | "Manu Ginobili" |
 
   Scenario: Integer Vid vertex noexist
     When executing query:
@@ -247,52 +247,52 @@ Feature: IntegerVid Go  Sentence
       """
       GO FROM hash("Russell Westbrook") OVER * REVERSELY YIELD serve._dst, like._dst
       """
-    Then the result should be, in any order, with relax comparison:
-      | serve._dst | like._dst               |
-      | EMPTY      | hash("James Harden")    |
-      | EMPTY      | hash("Dejounte Murray") |
-      | EMPTY      | hash("Paul George")     |
+    Then the result should be, in any order, with relax comparison, and the columns 0,1 should be hashed:
+      | serve._dst | like._dst         |
+      | EMPTY      | "James Harden"    |
+      | EMPTY      | "Dejounte Murray" |
+      | EMPTY      | "Paul George"     |
     When executing query:
       """
       GO FROM hash("Russell Westbrook") OVER * REVERSELY YIELD serve._src, like._src
       """
-    Then the result should be, in any order, with relax comparison:
-      | serve._src | like._src                 |
-      | EMPTY      | hash("Russell Westbrook") |
-      | EMPTY      | hash("Russell Westbrook") |
-      | EMPTY      | hash("Russell Westbrook") |
+    Then the result should be, in any order, with relax comparison, and the columns 0,1 should be hashed:
+      | serve._src | like._src           |
+      | EMPTY      | "Russell Westbrook" |
+      | EMPTY      | "Russell Westbrook" |
+      | EMPTY      | "Russell Westbrook" |
     When executing query:
       """
       GO FROM hash("Russell Westbrook") OVER * REVERSELY
       """
-    Then the result should be, in any order, with relax comparison:
-      | like._dst               | serve._dst | teammate._dst |
-      | hash("James Harden")    | EMPTY      | EMPTY         |
-      | hash("Dejounte Murray") | EMPTY      | EMPTY         |
-      | hash("Paul George")     | EMPTY      | EMPTY         |
+    Then the result should be, in any order, with relax comparison, and the columns 0,1,2 should be hashed:
+      | like._dst         | serve._dst | teammate._dst |
+      | "James Harden"    | EMPTY      | EMPTY         |
+      | "Dejounte Murray" | EMPTY      | EMPTY         |
+      | "Paul George"     | EMPTY      | EMPTY         |
     When executing query:
       """
       GO FROM hash("Dirk Nowitzki") OVER * YIELD serve._dst, like._dst
       """
-    Then the result should be, in any order, with relax comparison:
-      | serve._dst        | like._dst           |
-      | hash("Mavericks") | EMPTY               |
-      | EMPTY             | hash("Steve Nash")  |
-      | EMPTY             | hash("Jason Kidd")  |
-      | EMPTY             | hash("Dwyane Wade") |
+    Then the result should be, in any order, with relax comparison, and the columns 0,1 should be hashed:
+      | serve._dst  | like._dst     |
+      | "Mavericks" | EMPTY         |
+      | EMPTY       | "Steve Nash"  |
+      | EMPTY       | "Jason Kidd"  |
+      | EMPTY       | "Dwyane Wade" |
     When executing query:
       """
       GO FROM hash("Paul Gasol") OVER *
       """
-    Then the result should be, in any order, with relax comparison:
-      | like._dst           | serve._dst        | teammate._dst |
-      | EMPTY               | hash("Grizzlies") | EMPTY         |
-      | EMPTY               | hash("Lakers")    | EMPTY         |
-      | EMPTY               | hash("Bulls")     | EMPTY         |
-      | EMPTY               | hash("Spurs")     | EMPTY         |
-      | EMPTY               | hash("Bucks")     | EMPTY         |
-      | hash("Kobe Bryant") | EMPTY             | EMPTY         |
-      | hash("Marc Gasol")  | EMPTY             | EMPTY         |
+    Then the result should be, in any order, with relax comparison, and the columns 0,1,2 should be hashed:
+      | like._dst     | serve._dst  | teammate._dst |
+      | EMPTY         | "Grizzlies" | EMPTY         |
+      | EMPTY         | "Lakers"    | EMPTY         |
+      | EMPTY         | "Bulls"     | EMPTY         |
+      | EMPTY         | "Spurs"     | EMPTY         |
+      | EMPTY         | "Bucks"     | EMPTY         |
+      | "Kobe Bryant" | EMPTY       | EMPTY         |
+      | "Marc Gasol"  | EMPTY       | EMPTY         |
     When executing query:
       """
       GO FROM hash("Manu Ginobili") OVER * REVERSELY YIELD like.likeness, teammate.start_year, serve.start_year, $$.player.name
@@ -320,15 +320,15 @@ Feature: IntegerVid Go  Sentence
       GO FROM hash("Boris Diaw") OVER * YIELD like._dst as id
       | ( GO FROM $-.id OVER like YIELD like._dst as id | GO FROM $-.id OVER serve )
       """
-    Then the result should be, in any order, with relax comparison:
-      | serve._dst            |
-      | hash("Spurs")         |
-      | hash("Spurs")         |
-      | hash("Spurs")         |
-      | hash("Spurs")         |
-      | hash("Spurs")         |
-      | hash("Hornets")       |
-      | hash("Trail Blazers") |
+    Then the result should be, in any order, with relax comparison, and the columns 0 should be hashed:
+      | serve._dst      |
+      | "Spurs"         |
+      | "Spurs"         |
+      | "Spurs"         |
+      | "Spurs"         |
+      | "Spurs"         |
+      | "Hornets"       |
+      | "Trail Blazers" |
 
   @skip
   Scenario: Integer Vid edge type
@@ -346,11 +346,11 @@ Feature: IntegerVid Go  Sentence
       GO FROM hash("Russell Westbrook") OVER serve, like REVERSELY
       YIELD serve._dst, like._dst, serve._type, like._type
       """
-    Then the result should be, in any order, with relax comparison:
-      | serve._dst | like._dst               | serve._type | like._type |
-      | EMPTY      | hash("James Harden")    | EMPTY       | -5         |
-      | EMPTY      | hash("Dejounte Murray") | EMPTY       | -5         |
-      | EMPTY      | hash("Paul George")     | EMPTY       | -5         |
+    Then the result should be, in any order, with relax comparison, and the columns 0,1 should be hashed:
+      | serve._dst | like._dst         | serve._type | like._type |
+      | EMPTY      | "James Harden"    | EMPTY       | -5         |
+      | EMPTY      | "Dejounte Murray" | EMPTY       | -5         |
+      | EMPTY      | "Paul George"     | EMPTY       | -5         |
 
   Scenario: Integer Vid multi edges
     When executing query:
@@ -366,53 +366,53 @@ Feature: IntegerVid Go  Sentence
       """
       GO FROM hash("Shaquile O\'Neal") OVER serve, like
       """
-    Then the result should be, in any order, with relax comparison:
-      | serve._dst        | like._dst            |
-      | hash("Magic")     | EMPTY                |
-      | hash("Lakers")    | EMPTY                |
-      | hash("Heat")      | EMPTY                |
-      | hash("Suns")      | EMPTY                |
-      | hash("Cavaliers") | EMPTY                |
-      | hash("Celtics")   | EMPTY                |
-      | EMPTY             | hash("JaVale McGee") |
-      | EMPTY             | hash("Tim Duncan")   |
+    Then the result should be, in any order, with relax comparison, and the columns 0,1 should be hashed:
+      | serve._dst  | like._dst      |
+      | "Magic"     | EMPTY          |
+      | "Lakers"    | EMPTY          |
+      | "Heat"      | EMPTY          |
+      | "Suns"      | EMPTY          |
+      | "Cavaliers" | EMPTY          |
+      | "Celtics"   | EMPTY          |
+      | EMPTY       | "JaVale McGee" |
+      | EMPTY       | "Tim Duncan"   |
     When executing query:
       """
       GO FROM hash('Russell Westbrook') OVER serve, like
       """
-    Then the result should be, in any order, with relax comparison:
-      | serve._dst       | like._dst            |
-      | hash("Thunders") | EMPTY                |
-      | EMPTY            | hash("Paul George")  |
-      | EMPTY            | hash("James Harden") |
+    Then the result should be, in any order, with relax comparison, and the columns 0,1 should be hashed:
+      | serve._dst | like._dst      |
+      | "Thunders" | EMPTY          |
+      | EMPTY      | "Paul George"  |
+      | EMPTY      | "James Harden" |
     When executing query:
       """
       GO FROM hash("Russell Westbrook") OVER serve, like REVERSELY
       YIELD serve._dst, like._dst, serve.start_year, like.likeness
       """
-    Then the result should be, in any order, with relax comparison:
-      | serve._dst | like._dst               | serve.start_year | like.likeness |
-      | EMPTY      | hash("James Harden")    | EMPTY            | 80            |
-      | EMPTY      | hash("Dejounte Murray") | EMPTY            | 99            |
-      | EMPTY      | hash("Paul George")     | EMPTY            | 95            |
+    Then the result should be, in any order, with relax comparison, and the columns 0,1 should be hashed:
+      | serve._dst | like._dst         | serve.start_year | like.likeness |
+      | EMPTY      | "James Harden"    | EMPTY            | 80            |
+      | EMPTY      | "Dejounte Murray" | EMPTY            | 99            |
+      | EMPTY      | "Paul George"     | EMPTY            | 95            |
     When executing query:
       """
       GO FROM hash("Russell Westbrook") OVER serve, like REVERSELY YIELD serve._src, like._src
       """
-    Then the result should be, in any order, with relax comparison:
-      | serve._src | like._src                 |
-      | EMPTY      | hash("Russell Westbrook") |
-      | EMPTY      | hash("Russell Westbrook") |
-      | EMPTY      | hash("Russell Westbrook") |
+    Then the result should be, in any order, with relax comparison, and the columns 0,1 should be hashed:
+      | serve._src | like._src           |
+      | EMPTY      | "Russell Westbrook" |
+      | EMPTY      | "Russell Westbrook" |
+      | EMPTY      | "Russell Westbrook" |
     When executing query:
       """
       GO FROM hash("Russell Westbrook") OVER serve, like REVERSELY
       """
-    Then the result should be, in any order, with relax comparison:
-      | serve._dst | like._dst               |
-      | EMPTY      | hash("James Harden")    |
-      | EMPTY      | hash("Dejounte Murray") |
-      | EMPTY      | hash("Paul George")     |
+    Then the result should be, in any order, with relax comparison, and the columns 0,1 should be hashed:
+      | serve._dst | like._dst         |
+      | EMPTY      | "James Harden"    |
+      | EMPTY      | "Dejounte Murray" |
+      | EMPTY      | "Paul George"     |
     When executing query:
       """
       GO FROM hash("Manu Ginobili") OVER like, teammate REVERSELY YIELD like.likeness, teammate.start_year, $$.player.name
@@ -605,19 +605,19 @@ Feature: IntegerVid Go  Sentence
       GO FROM hash('Tim Duncan') OVER like YIELD like._dst AS id
       | GO FROM  $-.id OVER serve WHERE udf_is_in($-.id, 'Tony Parker', 123)
       """
-    Then the result should be, in any order, with relax comparison:
-      | serve._dst      |
-      | hash("Spurs")   |
-      | hash("Hornets") |
+    Then the result should be, in any order, with relax comparison, and the columns 0 should be hashed:
+      | serve._dst |
+      | "Spurs"    |
+      | "Hornets"  |
     When executing query:
       """
       GO FROM hash('Tim Duncan') OVER like YIELD like._dst AS id
       | GO FROM  $-.id OVER serve WHERE udf_is_in($-.id, 'Tony Parker', 123) AND 1 == 1
       """
-    Then the result should be, in any order, with relax comparison:
-      | serve._dst      |
-      | hash("Spurs")   |
-      | hash("Hornets") |
+    Then the result should be, in any order, with relax comparison, and the columns 0 should be hashed:
+      | serve._dst |
+      | "Spurs"    |
+      | "Hornets"  |
 
   @skip
   Scenario: Integer Vid return test (reason = "return not implement")
@@ -628,11 +628,11 @@ Feature: IntegerVid Go  Sentence
       RETURN $rA IF $rA IS NOT NULL;
       GO FROM $A.dst OVER serve
       """
-    Then the result should be, in any order, with relax comparison:
-      | serve._dst      |
-      | hash("Spurs")   |
-      | hash("Spurs")   |
-      | hash("Hornets") |
+    Then the result should be, in any order, with relax comparison, and the columns 0 should be hashed:
+      | serve._dst |
+      | "Spurs"    |
+      | "Spurs"    |
+      | "Hornets"  |
     When executing query:
       """
       $A = GO FROM hash('Tim Duncan') OVER like YIELD like._dst AS dst;
@@ -640,10 +640,10 @@ Feature: IntegerVid Go  Sentence
       RETURN $rA IF $rA IS NOT NULL;
       GO FROM $A.dst OVER serve
       """
-    Then the result should be, in any order, with relax comparison:
-      | serve._dst            |
-      | hash("Tony Parker")   |
-      | hash("Manu Ginobili") |
+    Then the result should be, in any order, with relax comparison, and the columns 0 should be hashed:
+      | serve._dst      |
+      | "Tony Parker"   |
+      | "Manu Ginobili" |
     When executing query:
       """
       $A = GO FROM hash('Tim Duncan') OVER like YIELD like._dst AS dstA;
@@ -654,13 +654,13 @@ Feature: IntegerVid Go  Sentence
       RETURN $rB IF $rB IS NOT NULL;
       GO FROM $B.dstB OVER serve
       """
-    Then the result should be, in any order, with relax comparison:
-      | serve._dst            |
-      | hash("Spurs")         |
-      | hash("Spurs")         |
-      | hash("Trail Blazers") |
-      | hash("Spurs")         |
-      | hash("Spurs")         |
+    Then the result should be, in any order, with relax comparison, and the columns 0 should be hashed:
+      | serve._dst      |
+      | "Spurs"         |
+      | "Spurs"         |
+      | "Trail Blazers" |
+      | "Spurs"         |
+      | "Spurs"         |
     When executing query:
       """
       $A = GO FROM hash('Tim Duncan') OVER like YIELD like._dst AS dst;
@@ -675,10 +675,10 @@ Feature: IntegerVid Go  Sentence
       $rA = YIELD $A.* WHERE 1 == 1;
       RETURN $rA IF $rA IS NOT NULL;
       """
-    Then the result should be, in any order, with relax comparison:
-      | serve._dst            |
-      | hash("Tony Parker")   |
-      | hash("Manu Ginobili") |
+    Then the result should be, in any order, with relax comparison, and the columns 0 should be hashed:
+      | serve._dst      |
+      | "Tony Parker"   |
+      | "Manu Ginobili" |
     When executing query:
       """
       $A = GO FROM hash('Tim Duncan') OVER like YIELD like._dst AS dst;
@@ -704,18 +704,18 @@ Feature: IntegerVid Go  Sentence
       """
       GO FROM hash('Tim Duncan') OVER like REVERSELY YIELD like._dst
       """
-    Then the result should be, in any order, with relax comparison:
-      | like._dst                 |
-      | hash("Tony Parker")       |
-      | hash("Manu Ginobili")     |
-      | hash("LaMarcus Aldridge") |
-      | hash("Marco Belinelli")   |
-      | hash("Danny Green")       |
-      | hash("Aron Baynes")       |
-      | hash("Boris Diaw")        |
-      | hash("Tiago Splitter")    |
-      | hash("Dejounte Murray")   |
-      | hash("Shaquile O'Neal")   |
+    Then the result should be, in any order, with relax comparison, and the columns 0 should be hashed:
+      | like._dst           |
+      | "Tony Parker"       |
+      | "Manu Ginobili"     |
+      | "LaMarcus Aldridge" |
+      | "Marco Belinelli"   |
+      | "Danny Green"       |
+      | "Aron Baynes"       |
+      | "Boris Diaw"        |
+      | "Tiago Splitter"    |
+      | "Dejounte Murray"   |
+      | "Shaquile O'Neal"   |
     When executing query:
       """
       GO FROM hash('Tim Duncan') OVER like REVERSELY YIELD $$.player.name
@@ -748,63 +748,63 @@ Feature: IntegerVid Go  Sentence
       """
       GO FROM hash('Tim Duncan') OVER * REVERSELY YIELD like._dst
       """
-    Then the result should be, in any order, with relax comparison:
-      | like._dst                 |
-      | hash("Tony Parker")       |
-      | hash("Manu Ginobili")     |
-      | hash("LaMarcus Aldridge") |
-      | hash("Marco Belinelli")   |
-      | hash("Danny Green")       |
-      | hash("Aron Baynes")       |
-      | hash("Boris Diaw")        |
-      | hash("Tiago Splitter")    |
-      | hash("Dejounte Murray")   |
-      | hash("Shaquile O'Neal")   |
-      | EMPTY                     |
-      | EMPTY                     |
+    Then the result should be, in any order, with relax comparison, and the columns 0 should be hashed:
+      | like._dst           |
+      | "Tony Parker"       |
+      | "Manu Ginobili"     |
+      | "LaMarcus Aldridge" |
+      | "Marco Belinelli"   |
+      | "Danny Green"       |
+      | "Aron Baynes"       |
+      | "Boris Diaw"        |
+      | "Tiago Splitter"    |
+      | "Dejounte Murray"   |
+      | "Shaquile O'Neal"   |
+      | EMPTY               |
+      | EMPTY               |
 
   Scenario: Integer Vid only id n steps
     When executing query:
       """
       GO 2 STEPS FROM hash('Tony Parker') OVER like YIELD like._dst
       """
-    Then the result should be, in any order, with relax comparison:
-      | like._dst             |
-      | hash("Tim Duncan")    |
-      | hash("Tim Duncan")    |
-      | hash("Tony Parker")   |
-      | hash("Tony Parker")   |
-      | hash("Manu Ginobili") |
+    Then the result should be, in any order, with relax comparison, and the columns 0 should be hashed:
+      | like._dst       |
+      | "Tim Duncan"    |
+      | "Tim Duncan"    |
+      | "Tony Parker"   |
+      | "Tony Parker"   |
+      | "Manu Ginobili" |
     When executing query:
       """
       GO 3 STEPS FROM hash('Tony Parker') OVER like YIELD like._dst
       """
-    Then the result should be, in any order, with relax comparison:
-      | like._dst                 |
-      | hash("Tony Parker")       |
-      | hash("Manu Ginobili")     |
-      | hash("Manu Ginobili")     |
-      | hash("Tim Duncan")        |
-      | hash("Tim Duncan")        |
-      | hash("LaMarcus Aldridge") |
+    Then the result should be, in any order, with relax comparison, and the columns 0 should be hashed:
+      | like._dst           |
+      | "Tony Parker"       |
+      | "Manu Ginobili"     |
+      | "Manu Ginobili"     |
+      | "Tim Duncan"        |
+      | "Tim Duncan"        |
+      | "LaMarcus Aldridge" |
     When executing query:
       """
       GO 1 STEPS FROM hash('Tony Parker') OVER like YIELD like._dst AS id
       | GO 2 STEPS FROM $-.id OVER like YIELD like._dst
       """
-    Then the result should be, in any order, with relax comparison:
-      | like._dst                 |
-      | hash("LaMarcus Aldridge") |
-      | hash("LaMarcus Aldridge") |
-      | hash("Manu Ginobili")     |
-      | hash("Manu Ginobili")     |
-      | hash("Tim Duncan")        |
-      | hash("Tim Duncan")        |
-      | hash("Tim Duncan")        |
-      | hash("Manu Ginobili")     |
-      | hash("Manu Ginobili")     |
-      | hash("Tony Parker")       |
-      | hash("Tony Parker")       |
+    Then the result should be, in any order, with relax comparison, and the columns 0 should be hashed:
+      | like._dst           |
+      | "LaMarcus Aldridge" |
+      | "LaMarcus Aldridge" |
+      | "Manu Ginobili"     |
+      | "Manu Ginobili"     |
+      | "Tim Duncan"        |
+      | "Tim Duncan"        |
+      | "Tim Duncan"        |
+      | "Manu Ginobili"     |
+      | "Manu Ginobili"     |
+      | "Tony Parker"       |
+      | "Tony Parker"       |
 
   Scenario: Integer Vid reverse two steps
     When executing query:
@@ -822,15 +822,15 @@ Feature: IntegerVid Go  Sentence
       GO FROM hash('Manu Ginobili') OVER * REVERSELY YIELD like._dst AS id
       | GO FROM $-.id OVER serve
       """
-    Then the result should be, in any order, with relax comparison:
-      | serve._dst      |
-      | hash("Spurs")   |
-      | hash("Spurs")   |
-      | hash("Hornets") |
-      | hash("Spurs")   |
-      | hash("Hawks")   |
-      | hash("76ers")   |
-      | hash("Spurs")   |
+    Then the result should be, in any order, with relax comparison, and the columns 0 should be hashed:
+      | serve._dst |
+      | "Spurs"    |
+      | "Spurs"    |
+      | "Hornets"  |
+      | "Spurs"    |
+      | "Hawks"    |
+      | "76ers"    |
+      | "Spurs"    |
 
   Scenario: Integer Vid reverse with pipe
     When executing query:
@@ -899,61 +899,61 @@ Feature: IntegerVid Go  Sentence
       GO FROM hash('Manu Ginobili') OVER like REVERSELY YIELD like._dst AS id
       | GO FROM $-.id OVER serve
       """
-    Then the result should be, in any order, with relax comparison:
-      | serve._dst      |
-      | hash("Spurs")   |
-      | hash("Spurs")   |
-      | hash("Spurs")   |
-      | hash("Spurs")   |
-      | hash("Hornets") |
-      | hash("Hawks")   |
-      | hash("76ers")   |
+    Then the result should be, in any order, with relax comparison, and the columns 0 should be hashed:
+      | serve._dst |
+      | "Spurs"    |
+      | "Spurs"    |
+      | "Spurs"    |
+      | "Spurs"    |
+      | "Hornets"  |
+      | "Hawks"    |
+      | "76ers"    |
 
   Scenario: Integer Vid bidirect
     When executing query:
       """
       GO FROM hash('Tim Duncan') OVER serve bidirect
       """
-    Then the result should be, in any order, with relax comparison:
-      | serve._dst    |
-      | hash("Spurs") |
+    Then the result should be, in any order, with relax comparison, and the columns 0 should be hashed:
+      | serve._dst |
+      | "Spurs"    |
     When executing query:
       """
       GO FROM hash('Tim Duncan') OVER like bidirect
       """
-    Then the result should be, in any order, with relax comparison:
-      | like._dst                 |
-      | hash("Tony Parker")       |
-      | hash("Manu Ginobili")     |
-      | hash("Tony Parker")       |
-      | hash("Manu Ginobili")     |
-      | hash("LaMarcus Aldridge") |
-      | hash("Marco Belinelli")   |
-      | hash("Danny Green")       |
-      | hash("Aron Baynes")       |
-      | hash("Boris Diaw")        |
-      | hash("Tiago Splitter")    |
-      | hash("Dejounte Murray")   |
-      | hash("Shaquile O'Neal")   |
+    Then the result should be, in any order, with relax comparison, and the columns 0 should be hashed:
+      | like._dst           |
+      | "Tony Parker"       |
+      | "Manu Ginobili"     |
+      | "Tony Parker"       |
+      | "Manu Ginobili"     |
+      | "LaMarcus Aldridge" |
+      | "Marco Belinelli"   |
+      | "Danny Green"       |
+      | "Aron Baynes"       |
+      | "Boris Diaw"        |
+      | "Tiago Splitter"    |
+      | "Dejounte Murray"   |
+      | "Shaquile O'Neal"   |
     When executing query:
       """
       GO FROM hash('Tim Duncan') OVER serve, like bidirect
       """
-    Then the result should be, in any order, with relax comparison:
-      | serve._dst    | like._dst                 |
-      | hash("Spurs") | EMPTY                     |
-      | EMPTY         | hash("Tony Parker")       |
-      | EMPTY         | hash("Manu Ginobili")     |
-      | EMPTY         | hash("Tony Parker")       |
-      | EMPTY         | hash("Manu Ginobili")     |
-      | EMPTY         | hash("LaMarcus Aldridge") |
-      | EMPTY         | hash("Marco Belinelli")   |
-      | EMPTY         | hash("Danny Green")       |
-      | EMPTY         | hash("Aron Baynes")       |
-      | EMPTY         | hash("Boris Diaw")        |
-      | EMPTY         | hash("Tiago Splitter")    |
-      | EMPTY         | hash("Dejounte Murray")   |
-      | EMPTY         | hash("Shaquile O'Neal")   |
+    Then the result should be, in any order, with relax comparison, and the columns 0,1 should be hashed:
+      | serve._dst | like._dst           |
+      | "Spurs"    | EMPTY               |
+      | EMPTY      | "Tony Parker"       |
+      | EMPTY      | "Manu Ginobili"     |
+      | EMPTY      | "Tony Parker"       |
+      | EMPTY      | "Manu Ginobili"     |
+      | EMPTY      | "LaMarcus Aldridge" |
+      | EMPTY      | "Marco Belinelli"   |
+      | EMPTY      | "Danny Green"       |
+      | EMPTY      | "Aron Baynes"       |
+      | EMPTY      | "Boris Diaw"        |
+      | EMPTY      | "Tiago Splitter"    |
+      | EMPTY      | "Dejounte Murray"   |
+      | EMPTY      | "Shaquile O'Neal"   |
     When executing query:
       """
       GO FROM hash('Tim Duncan') OVER serve bidirect YIELD $$.team.name
@@ -984,73 +984,73 @@ Feature: IntegerVid Go  Sentence
       GO FROM hash('Tim Duncan') OVER like bidirect WHERE like.likeness > 90
       YIELD $^.player.name, like._dst, $$.player.name, like.likeness
       """
-    Then the result should be, in any order, with relax comparison:
-      | $^.player.name | like._dst               | $$.player.name    | like.likeness |
-      | "Tim Duncan"   | hash("Tony Parker")     | "Tony Parker"     | 95            |
-      | "Tim Duncan"   | hash("Manu Ginobili")   | "Manu Ginobili"   | 95            |
-      | "Tim Duncan"   | hash("Tony Parker")     | "Tony Parker"     | 95            |
-      | "Tim Duncan"   | hash("Dejounte Murray") | "Dejounte Murray" | 99            |
+    Then the result should be, in any order, with relax comparison, and the columns 1 should be hashed:
+      | $^.player.name | like._dst         | $$.player.name    | like.likeness |
+      | "Tim Duncan"   | "Tony Parker"     | "Tony Parker"     | 95            |
+      | "Tim Duncan"   | "Manu Ginobili"   | "Manu Ginobili"   | 95            |
+      | "Tim Duncan"   | "Tony Parker"     | "Tony Parker"     | 95            |
+      | "Tim Duncan"   | "Dejounte Murray" | "Dejounte Murray" | 99            |
 
   Scenario: Integer Vid bidirect_over_all
     When executing query:
       """
       GO FROM hash('Tim Duncan') OVER * bidirect YIELD $^.player.name, serve._dst, $$.team.name, like._dst, $$.player.name
       """
-    Then the result should be, in any order, with relax comparison:
-      | $^.player.name | serve._dst    | $$.team.name | like._dst                 | $$.player.name      |
-      | "Tim Duncan"   | hash("Spurs") | "Spurs"      | EMPTY                     | EMPTY               |
-      | "Tim Duncan"   | EMPTY         | EMPTY        | hash("Tony Parker")       | "Tony Parker"       |
-      | "Tim Duncan"   | EMPTY         | EMPTY        | hash("Manu Ginobili")     | "Manu Ginobili"     |
-      | "Tim Duncan"   | EMPTY         | EMPTY        | hash("Tony Parker")       | "Tony Parker"       |
-      | "Tim Duncan"   | EMPTY         | EMPTY        | hash("Manu Ginobili")     | "Manu Ginobili"     |
-      | "Tim Duncan"   | EMPTY         | EMPTY        | hash("LaMarcus Aldridge") | "LaMarcus Aldridge" |
-      | "Tim Duncan"   | EMPTY         | EMPTY        | hash("Marco Belinelli")   | "Marco Belinelli"   |
-      | "Tim Duncan"   | EMPTY         | EMPTY        | hash("Danny Green")       | "Danny Green"       |
-      | "Tim Duncan"   | EMPTY         | EMPTY        | hash("Aron Baynes")       | "Aron Baynes"       |
-      | "Tim Duncan"   | EMPTY         | EMPTY        | hash("Boris Diaw")        | "Boris Diaw"        |
-      | "Tim Duncan"   | EMPTY         | EMPTY        | hash("Tiago Splitter")    | "Tiago Splitter"    |
-      | "Tim Duncan"   | EMPTY         | EMPTY        | hash("Dejounte Murray")   | "Dejounte Murray"   |
-      | "Tim Duncan"   | EMPTY         | EMPTY        | hash("Shaquile O'Neal")   | "Shaquile O'Neal"   |
-      | "Tim Duncan"   | EMPTY         | EMPTY        | EMPTY                     | "Tony Parker"       |
-      | "Tim Duncan"   | EMPTY         | EMPTY        | EMPTY                     | "Manu Ginobili"     |
-      | "Tim Duncan"   | EMPTY         | EMPTY        | EMPTY                     | "Danny Green"       |
-      | "Tim Duncan"   | EMPTY         | EMPTY        | EMPTY                     | "LaMarcus Aldridge" |
-      | "Tim Duncan"   | EMPTY         | EMPTY        | EMPTY                     | "Tony Parker"       |
-      | "Tim Duncan"   | EMPTY         | EMPTY        | EMPTY                     | "Manu Ginobili"     |
+    Then the result should be, in any order, with relax comparison, and the columns 1,3 should be hashed:
+      | $^.player.name | serve._dst | $$.team.name | like._dst           | $$.player.name      |
+      | "Tim Duncan"   | "Spurs"    | "Spurs"      | EMPTY               | EMPTY               |
+      | "Tim Duncan"   | EMPTY      | EMPTY        | "Tony Parker"       | "Tony Parker"       |
+      | "Tim Duncan"   | EMPTY      | EMPTY        | "Manu Ginobili"     | "Manu Ginobili"     |
+      | "Tim Duncan"   | EMPTY      | EMPTY        | "Tony Parker"       | "Tony Parker"       |
+      | "Tim Duncan"   | EMPTY      | EMPTY        | "Manu Ginobili"     | "Manu Ginobili"     |
+      | "Tim Duncan"   | EMPTY      | EMPTY        | "LaMarcus Aldridge" | "LaMarcus Aldridge" |
+      | "Tim Duncan"   | EMPTY      | EMPTY        | "Marco Belinelli"   | "Marco Belinelli"   |
+      | "Tim Duncan"   | EMPTY      | EMPTY        | "Danny Green"       | "Danny Green"       |
+      | "Tim Duncan"   | EMPTY      | EMPTY        | "Aron Baynes"       | "Aron Baynes"       |
+      | "Tim Duncan"   | EMPTY      | EMPTY        | "Boris Diaw"        | "Boris Diaw"        |
+      | "Tim Duncan"   | EMPTY      | EMPTY        | "Tiago Splitter"    | "Tiago Splitter"    |
+      | "Tim Duncan"   | EMPTY      | EMPTY        | "Dejounte Murray"   | "Dejounte Murray"   |
+      | "Tim Duncan"   | EMPTY      | EMPTY        | "Shaquile O'Neal"   | "Shaquile O'Neal"   |
+      | "Tim Duncan"   | EMPTY      | EMPTY        | EMPTY               | "Tony Parker"       |
+      | "Tim Duncan"   | EMPTY      | EMPTY        | EMPTY               | "Manu Ginobili"     |
+      | "Tim Duncan"   | EMPTY      | EMPTY        | EMPTY               | "Danny Green"       |
+      | "Tim Duncan"   | EMPTY      | EMPTY        | EMPTY               | "LaMarcus Aldridge" |
+      | "Tim Duncan"   | EMPTY      | EMPTY        | EMPTY               | "Tony Parker"       |
+      | "Tim Duncan"   | EMPTY      | EMPTY        | EMPTY               | "Manu Ginobili"     |
     When executing query:
       """
       GO FROM hash('Tim Duncan') OVER * bidirect
       """
-    Then the result should be, in any order, with relax comparison:
-      | like._dst                 | serve._dst    | teammate._dst             |
-      | EMPTY                     | hash("Spurs") | EMPTY                     |
-      | hash("Tony Parker")       | EMPTY         | EMPTY                     |
-      | hash("Manu Ginobili")     | EMPTY         | EMPTY                     |
-      | hash("Tony Parker")       | EMPTY         | EMPTY                     |
-      | hash("Manu Ginobili")     | EMPTY         | EMPTY                     |
-      | hash("LaMarcus Aldridge") | EMPTY         | EMPTY                     |
-      | hash("Marco Belinelli")   | EMPTY         | EMPTY                     |
-      | hash("Danny Green")       | EMPTY         | EMPTY                     |
-      | hash("Aron Baynes")       | EMPTY         | EMPTY                     |
-      | hash("Boris Diaw")        | EMPTY         | EMPTY                     |
-      | hash("Tiago Splitter")    | EMPTY         | EMPTY                     |
-      | hash("Dejounte Murray")   | EMPTY         | EMPTY                     |
-      | hash("Shaquile O'Neal")   | EMPTY         | EMPTY                     |
-      | EMPTY                     | EMPTY         | hash("Tony Parker")       |
-      | EMPTY                     | EMPTY         | hash("Manu Ginobili")     |
-      | EMPTY                     | EMPTY         | hash("LaMarcus Aldridge") |
-      | EMPTY                     | EMPTY         | hash("Danny Green")       |
-      | EMPTY                     | EMPTY         | hash("Tony Parker")       |
-      | EMPTY                     | EMPTY         | hash("Manu Ginobili")     |
+    Then the result should be, in any order, with relax comparison, and the columns 0,1,2 should be hashed:
+      | like._dst           | serve._dst | teammate._dst       |
+      | EMPTY               | "Spurs"    | EMPTY               |
+      | "Tony Parker"       | EMPTY      | EMPTY               |
+      | "Manu Ginobili"     | EMPTY      | EMPTY               |
+      | "Tony Parker"       | EMPTY      | EMPTY               |
+      | "Manu Ginobili"     | EMPTY      | EMPTY               |
+      | "LaMarcus Aldridge" | EMPTY      | EMPTY               |
+      | "Marco Belinelli"   | EMPTY      | EMPTY               |
+      | "Danny Green"       | EMPTY      | EMPTY               |
+      | "Aron Baynes"       | EMPTY      | EMPTY               |
+      | "Boris Diaw"        | EMPTY      | EMPTY               |
+      | "Tiago Splitter"    | EMPTY      | EMPTY               |
+      | "Dejounte Murray"   | EMPTY      | EMPTY               |
+      | "Shaquile O'Neal"   | EMPTY      | EMPTY               |
+      | EMPTY               | EMPTY      | "Tony Parker"       |
+      | EMPTY               | EMPTY      | "Manu Ginobili"     |
+      | EMPTY               | EMPTY      | "LaMarcus Aldridge" |
+      | EMPTY               | EMPTY      | "Danny Green"       |
+      | EMPTY               | EMPTY      | "Tony Parker"       |
+      | EMPTY               | EMPTY      | "Manu Ginobili"     |
 
   Scenario: Integer Vid duplicate column name
     When executing query:
       """
       GO FROM hash('Tim Duncan') OVER serve YIELD serve._dst, serve._dst
       """
-    Then the result should be, in any order, with relax comparison:
-      | serve._dst    | serve._dst    |
-      | hash("Spurs") | hash("Spurs") |
+    Then the result should be, in any order, with relax comparison, and the columns 0,1 should be hashed:
+      | serve._dst | serve._dst |
+      | "Spurs"    | "Spurs"    |
     When executing query:
       """
       GO FROM hash('Tim Duncan') OVER like YIELD like._dst AS id, like.likeness AS id
@@ -1126,55 +1126,55 @@ Feature: IntegerVid Go  Sentence
       """
       GO 1 TO 2 STEPS FROM hash('Tony Parker') OVER like YIELD DISTINCT like._dst
       """
-    Then the result should be, in any order, with relax comparison:
-      | like._dst                 |
-      | hash("Tony Parker")       |
-      | hash("Manu Ginobili")     |
-      | hash("LaMarcus Aldridge") |
-      | hash("Tim Duncan")        |
+    Then the result should be, in any order, with relax comparison, and the columns 0 should be hashed:
+      | like._dst           |
+      | "Tony Parker"       |
+      | "Manu Ginobili"     |
+      | "LaMarcus Aldridge" |
+      | "Tim Duncan"        |
     When executing query:
       """
       GO 0 TO 2 STEPS FROM hash('Tony Parker') OVER like YIELD DISTINCT like._dst
       """
-    Then the result should be, in any order, with relax comparison:
-      | like._dst                 |
-      | hash("Tony Parker")       |
-      | hash("Manu Ginobili")     |
-      | hash("LaMarcus Aldridge") |
-      | hash("Tim Duncan")        |
+    Then the result should be, in any order, with relax comparison, and the columns 0 should be hashed:
+      | like._dst           |
+      | "Tony Parker"       |
+      | "Manu Ginobili"     |
+      | "LaMarcus Aldridge" |
+      | "Tim Duncan"        |
     When executing query:
       """
       GO 1 TO 2 STEPS FROM hash('Tony Parker') OVER like YIELD DISTINCT like._dst, like.likeness, $$.player.name
       """
-    Then the result should be, in any order, with relax comparison:
-      | like._dst                 | like.likeness | $$.player.name      |
-      | hash("Manu Ginobili")     | 95            | "Manu Ginobili"     |
-      | hash("LaMarcus Aldridge") | 90            | "LaMarcus Aldridge" |
-      | hash("Tim Duncan")        | 95            | "Tim Duncan"        |
-      | hash("Tony Parker")       | 95            | "Tony Parker"       |
-      | hash("Tony Parker")       | 75            | "Tony Parker"       |
-      | hash("Tim Duncan")        | 75            | "Tim Duncan"        |
-      | hash("Tim Duncan")        | 90            | "Tim Duncan"        |
+    Then the result should be, in any order, with relax comparison, and the columns 0 should be hashed:
+      | like._dst           | like.likeness | $$.player.name      |
+      | "Manu Ginobili"     | 95            | "Manu Ginobili"     |
+      | "LaMarcus Aldridge" | 90            | "LaMarcus Aldridge" |
+      | "Tim Duncan"        | 95            | "Tim Duncan"        |
+      | "Tony Parker"       | 95            | "Tony Parker"       |
+      | "Tony Parker"       | 75            | "Tony Parker"       |
+      | "Tim Duncan"        | 75            | "Tim Duncan"        |
+      | "Tim Duncan"        | 90            | "Tim Duncan"        |
     When executing query:
       """
       GO 0 TO 2 STEPS FROM hash('Tony Parker') OVER like YIELD DISTINCT like._dst, like.likeness, $$.player.name
       """
-    Then the result should be, in any order, with relax comparison:
-      | like._dst                 | like.likeness | $$.player.name      |
-      | hash("Manu Ginobili")     | 95            | "Manu Ginobili"     |
-      | hash("LaMarcus Aldridge") | 90            | "LaMarcus Aldridge" |
-      | hash("Tim Duncan")        | 95            | "Tim Duncan"        |
-      | hash("Tony Parker")       | 95            | "Tony Parker"       |
-      | hash("Tony Parker")       | 75            | "Tony Parker"       |
-      | hash("Tim Duncan")        | 75            | "Tim Duncan"        |
-      | hash("Tim Duncan")        | 90            | "Tim Duncan"        |
+    Then the result should be, in any order, with relax comparison, and the columns 0 should be hashed:
+      | like._dst           | like.likeness | $$.player.name      |
+      | "Manu Ginobili"     | 95            | "Manu Ginobili"     |
+      | "LaMarcus Aldridge" | 90            | "LaMarcus Aldridge" |
+      | "Tim Duncan"        | 95            | "Tim Duncan"        |
+      | "Tony Parker"       | 95            | "Tony Parker"       |
+      | "Tony Parker"       | 75            | "Tony Parker"       |
+      | "Tim Duncan"        | 75            | "Tim Duncan"        |
+      | "Tim Duncan"        | 90            | "Tim Duncan"        |
     When executing query:
       """
       GO 0 TO 3 STEPS FROM hash('Tim Duncan') OVER serve
       """
-    Then the result should be, in any order, with relax comparison:
-      | serve._dst    |
-      | hash("Spurs") |
+    Then the result should be, in any order, with relax comparison, and the columns 0 should be hashed:
+      | serve._dst |
+      | "Spurs"    |
     When executing query:
       """
       GO 2 TO 3 STEPS FROM hash('Tim Duncan') OVER serve
@@ -1185,244 +1185,244 @@ Feature: IntegerVid Go  Sentence
       """
       GO 1 TO 2 STEPS FROM hash('Tony Parker') OVER like REVERSELY YIELD DISTINCT like._dst
       """
-    Then the result should be, in any order, with relax comparison:
-      | like._dst                 |
-      | hash("Tim Duncan")        |
-      | hash("LaMarcus Aldridge") |
-      | hash("Marco Belinelli")   |
-      | hash("Boris Diaw")        |
-      | hash("Dejounte Murray")   |
-      | hash("Tony Parker")       |
-      | hash("Manu Ginobili")     |
-      | hash("Danny Green")       |
-      | hash("Aron Baynes")       |
-      | hash("Tiago Splitter")    |
-      | hash("Shaquile O'Neal")   |
-      | hash("Rudy Gay")          |
-      | hash("Damian Lillard")    |
+    Then the result should be, in any order, with relax comparison, and the columns 0 should be hashed:
+      | like._dst           |
+      | "Tim Duncan"        |
+      | "LaMarcus Aldridge" |
+      | "Marco Belinelli"   |
+      | "Boris Diaw"        |
+      | "Dejounte Murray"   |
+      | "Tony Parker"       |
+      | "Manu Ginobili"     |
+      | "Danny Green"       |
+      | "Aron Baynes"       |
+      | "Tiago Splitter"    |
+      | "Shaquile O'Neal"   |
+      | "Rudy Gay"          |
+      | "Damian Lillard"    |
     When executing query:
       """
       GO 0 TO 2 STEPS FROM hash('Tony Parker') OVER like REVERSELY YIELD DISTINCT like._dst
       """
-    Then the result should be, in any order, with relax comparison:
-      | like._dst                 |
-      | hash("Tim Duncan")        |
-      | hash("LaMarcus Aldridge") |
-      | hash("Marco Belinelli")   |
-      | hash("Boris Diaw")        |
-      | hash("Dejounte Murray")   |
-      | hash("Tony Parker")       |
-      | hash("Manu Ginobili")     |
-      | hash("Danny Green")       |
-      | hash("Aron Baynes")       |
-      | hash("Tiago Splitter")    |
-      | hash("Shaquile O'Neal")   |
-      | hash("Rudy Gay")          |
-      | hash("Damian Lillard")    |
+    Then the result should be, in any order, with relax comparison, and the columns 0 should be hashed:
+      | like._dst           |
+      | "Tim Duncan"        |
+      | "LaMarcus Aldridge" |
+      | "Marco Belinelli"   |
+      | "Boris Diaw"        |
+      | "Dejounte Murray"   |
+      | "Tony Parker"       |
+      | "Manu Ginobili"     |
+      | "Danny Green"       |
+      | "Aron Baynes"       |
+      | "Tiago Splitter"    |
+      | "Shaquile O'Neal"   |
+      | "Rudy Gay"          |
+      | "Damian Lillard"    |
     When executing query:
       """
       GO 2 TO 2 STEPS FROM hash('Tony Parker') OVER like REVERSELY YIELD DISTINCT like._dst
       """
-    Then the result should be, in any order, with relax comparison:
-      | like._dst                 |
-      | hash("LaMarcus Aldridge") |
-      | hash("Marco Belinelli")   |
-      | hash("Boris Diaw")        |
-      | hash("Dejounte Murray")   |
-      | hash("Tony Parker")       |
-      | hash("Manu Ginobili")     |
-      | hash("Danny Green")       |
-      | hash("Aron Baynes")       |
-      | hash("Tiago Splitter")    |
-      | hash("Shaquile O'Neal")   |
-      | hash("Rudy Gay")          |
-      | hash("Damian Lillard")    |
+    Then the result should be, in any order, with relax comparison, and the columns 0 should be hashed:
+      | like._dst           |
+      | "LaMarcus Aldridge" |
+      | "Marco Belinelli"   |
+      | "Boris Diaw"        |
+      | "Dejounte Murray"   |
+      | "Tony Parker"       |
+      | "Manu Ginobili"     |
+      | "Danny Green"       |
+      | "Aron Baynes"       |
+      | "Tiago Splitter"    |
+      | "Shaquile O'Neal"   |
+      | "Rudy Gay"          |
+      | "Damian Lillard"    |
     When executing query:
       """
       GO 1 TO 3 STEPS FROM hash('Spurs') OVER serve REVERSELY
       """
-    Then the result should be, in any order, with relax comparison:
-      | serve._dst                |
-      | hash("Tim Duncan")        |
-      | hash("Tony Parker")       |
-      | hash("Manu Ginobili")     |
-      | hash("LaMarcus Aldridge") |
-      | hash("Rudy Gay")          |
-      | hash("Marco Belinelli")   |
-      | hash("Danny Green")       |
-      | hash("Kyle Anderson")     |
-      | hash("Aron Baynes")       |
-      | hash("Boris Diaw")        |
-      | hash("Tiago Splitter")    |
-      | hash("Cory Joseph")       |
-      | hash("David West")        |
-      | hash("Jonathon Simmons")  |
-      | hash("Dejounte Murray")   |
-      | hash("Tracy McGrady")     |
-      | hash("Paul Gasol")        |
-      | hash("Marco Belinelli")   |
+    Then the result should be, in any order, with relax comparison, and the columns 0 should be hashed:
+      | serve._dst          |
+      | "Tim Duncan"        |
+      | "Tony Parker"       |
+      | "Manu Ginobili"     |
+      | "LaMarcus Aldridge" |
+      | "Rudy Gay"          |
+      | "Marco Belinelli"   |
+      | "Danny Green"       |
+      | "Kyle Anderson"     |
+      | "Aron Baynes"       |
+      | "Boris Diaw"        |
+      | "Tiago Splitter"    |
+      | "Cory Joseph"       |
+      | "David West"        |
+      | "Jonathon Simmons"  |
+      | "Dejounte Murray"   |
+      | "Tracy McGrady"     |
+      | "Paul Gasol"        |
+      | "Marco Belinelli"   |
     When executing query:
       """
       GO 0 TO 3 STEPS FROM hash('Spurs') OVER serve REVERSELY
       """
-    Then the result should be, in any order, with relax comparison:
-      | serve._dst                |
-      | hash("Tim Duncan")        |
-      | hash("Tony Parker")       |
-      | hash("Manu Ginobili")     |
-      | hash("LaMarcus Aldridge") |
-      | hash("Rudy Gay")          |
-      | hash("Marco Belinelli")   |
-      | hash("Danny Green")       |
-      | hash("Kyle Anderson")     |
-      | hash("Aron Baynes")       |
-      | hash("Boris Diaw")        |
-      | hash("Tiago Splitter")    |
-      | hash("Cory Joseph")       |
-      | hash("David West")        |
-      | hash("Jonathon Simmons")  |
-      | hash("Dejounte Murray")   |
-      | hash("Tracy McGrady")     |
-      | hash("Paul Gasol")        |
-      | hash("Marco Belinelli")   |
+    Then the result should be, in any order, with relax comparison, and the columns 0 should be hashed:
+      | serve._dst          |
+      | "Tim Duncan"        |
+      | "Tony Parker"       |
+      | "Manu Ginobili"     |
+      | "LaMarcus Aldridge" |
+      | "Rudy Gay"          |
+      | "Marco Belinelli"   |
+      | "Danny Green"       |
+      | "Kyle Anderson"     |
+      | "Aron Baynes"       |
+      | "Boris Diaw"        |
+      | "Tiago Splitter"    |
+      | "Cory Joseph"       |
+      | "David West"        |
+      | "Jonathon Simmons"  |
+      | "Dejounte Murray"   |
+      | "Tracy McGrady"     |
+      | "Paul Gasol"        |
+      | "Marco Belinelli"   |
     When executing query:
       """
       GO 1 TO 2 STEPS FROM hash('Tony Parker') OVER like BIDIRECT YIELD DISTINCT like._dst
       """
-    Then the result should be, in any order, with relax comparison:
-      | like._dst                 |
-      | hash("Tim Duncan")        |
-      | hash("LaMarcus Aldridge") |
-      | hash("Marco Belinelli")   |
-      | hash("Boris Diaw")        |
-      | hash("Dejounte Murray")   |
-      | hash("Tony Parker")       |
-      | hash("Manu Ginobili")     |
-      | hash("Danny Green")       |
-      | hash("Aron Baynes")       |
-      | hash("Tiago Splitter")    |
-      | hash("Shaquile O'Neal")   |
-      | hash("Rudy Gay")          |
-      | hash("Damian Lillard")    |
-      | hash("LeBron James")      |
-      | hash("Russell Westbrook") |
-      | hash("Chris Paul")        |
-      | hash("Kyle Anderson")     |
-      | hash("Kevin Durant")      |
-      | hash("James Harden")      |
+    Then the result should be, in any order, with relax comparison, and the columns 0 should be hashed:
+      | like._dst           |
+      | "Tim Duncan"        |
+      | "LaMarcus Aldridge" |
+      | "Marco Belinelli"   |
+      | "Boris Diaw"        |
+      | "Dejounte Murray"   |
+      | "Tony Parker"       |
+      | "Manu Ginobili"     |
+      | "Danny Green"       |
+      | "Aron Baynes"       |
+      | "Tiago Splitter"    |
+      | "Shaquile O'Neal"   |
+      | "Rudy Gay"          |
+      | "Damian Lillard"    |
+      | "LeBron James"      |
+      | "Russell Westbrook" |
+      | "Chris Paul"        |
+      | "Kyle Anderson"     |
+      | "Kevin Durant"      |
+      | "James Harden"      |
     When executing query:
       """
       GO 0 TO 2 STEPS FROM hash('Tony Parker') OVER like BIDIRECT YIELD DISTINCT like._dst
       """
-    Then the result should be, in any order, with relax comparison:
-      | like._dst                 |
-      | hash("Tim Duncan")        |
-      | hash("LaMarcus Aldridge") |
-      | hash("Marco Belinelli")   |
-      | hash("Boris Diaw")        |
-      | hash("Dejounte Murray")   |
-      | hash("Tony Parker")       |
-      | hash("Manu Ginobili")     |
-      | hash("Danny Green")       |
-      | hash("Aron Baynes")       |
-      | hash("Tiago Splitter")    |
-      | hash("Shaquile O'Neal")   |
-      | hash("Rudy Gay")          |
-      | hash("Damian Lillard")    |
-      | hash("LeBron James")      |
-      | hash("Russell Westbrook") |
-      | hash("Chris Paul")        |
-      | hash("Kyle Anderson")     |
-      | hash("Kevin Durant")      |
-      | hash("James Harden")      |
+    Then the result should be, in any order, with relax comparison, and the columns 0 should be hashed:
+      | like._dst           |
+      | "Tim Duncan"        |
+      | "LaMarcus Aldridge" |
+      | "Marco Belinelli"   |
+      | "Boris Diaw"        |
+      | "Dejounte Murray"   |
+      | "Tony Parker"       |
+      | "Manu Ginobili"     |
+      | "Danny Green"       |
+      | "Aron Baynes"       |
+      | "Tiago Splitter"    |
+      | "Shaquile O'Neal"   |
+      | "Rudy Gay"          |
+      | "Damian Lillard"    |
+      | "LeBron James"      |
+      | "Russell Westbrook" |
+      | "Chris Paul"        |
+      | "Kyle Anderson"     |
+      | "Kevin Durant"      |
+      | "James Harden"      |
     When executing query:
       """
       GO 1 TO 2 STEPS FROM hash('Russell Westbrook') OVER * YIELD serve._dst, like._dst
       """
-    Then the result should be, in any order, with relax comparison:
-      | serve._dst       | like._dst                 |
-      | hash("Thunders") | EMPTY                     |
-      | EMPTY            | hash("Paul George")       |
-      | EMPTY            | hash("James Harden")      |
-      | hash("Pacers")   | EMPTY                     |
-      | hash("Thunders") | EMPTY                     |
-      | EMPTY            | hash("Russell Westbrook") |
-      | hash("Thunders") | EMPTY                     |
-      | hash("Rockets")  | EMPTY                     |
-      | EMPTY            | hash("Russell Westbrook") |
+    Then the result should be, in any order, with relax comparison, and the columns 0,1 should be hashed:
+      | serve._dst | like._dst           |
+      | "Thunders" | EMPTY               |
+      | EMPTY      | "Paul George"       |
+      | EMPTY      | "James Harden"      |
+      | "Pacers"   | EMPTY               |
+      | "Thunders" | EMPTY               |
+      | EMPTY      | "Russell Westbrook" |
+      | "Thunders" | EMPTY               |
+      | "Rockets"  | EMPTY               |
+      | EMPTY      | "Russell Westbrook" |
     When executing query:
       """
       GO 0 TO 2 STEPS FROM hash('Russell Westbrook') OVER * YIELD serve._dst, like._dst
       """
-    Then the result should be, in any order, with relax comparison:
-      | serve._dst       | like._dst                 |
-      | hash("Thunders") | EMPTY                     |
-      | EMPTY            | hash("Paul George")       |
-      | EMPTY            | hash("James Harden")      |
-      | hash("Pacers")   | EMPTY                     |
-      | hash("Thunders") | EMPTY                     |
-      | EMPTY            | hash("Russell Westbrook") |
-      | hash("Thunders") | EMPTY                     |
-      | hash("Rockets")  | EMPTY                     |
-      | EMPTY            | hash("Russell Westbrook") |
+    Then the result should be, in any order, with relax comparison, and the columns 0,1 should be hashed:
+      | serve._dst | like._dst           |
+      | "Thunders" | EMPTY               |
+      | EMPTY      | "Paul George"       |
+      | EMPTY      | "James Harden"      |
+      | "Pacers"   | EMPTY               |
+      | "Thunders" | EMPTY               |
+      | EMPTY      | "Russell Westbrook" |
+      | "Thunders" | EMPTY               |
+      | "Rockets"  | EMPTY               |
+      | EMPTY      | "Russell Westbrook" |
     When executing query:
       """
       GO 1 TO 2 STEPS FROM hash('Russell Westbrook') OVER *
       YIELD serve._dst, like._dst, serve.start_year, like.likeness, $$.player.name
       """
-    Then the result should be, in any order, with relax comparison:
-      | serve._dst       | like._dst                 | serve.start_year | like.likeness | $$.player.name      |
-      | hash("Thunders") | EMPTY                     | 2008             | EMPTY         | EMPTY               |
-      | EMPTY            | hash("Paul George")       | EMPTY            | 90            | "Paul George"       |
-      | EMPTY            | hash("James Harden")      | EMPTY            | 90            | "James Harden"      |
-      | hash("Pacers")   | EMPTY                     | 2010             | EMPTY         | EMPTY               |
-      | hash("Thunders") | EMPTY                     | 2017             | EMPTY         | EMPTY               |
-      | EMPTY            | hash("Russell Westbrook") | EMPTY            | 95            | "Russell Westbrook" |
-      | hash("Thunders") | EMPTY                     | 2009             | EMPTY         | EMPTY               |
-      | hash("Rockets")  | EMPTY                     | 2012             | EMPTY         | EMPTY               |
-      | EMPTY            | hash("Russell Westbrook") | EMPTY            | 80            | "Russell Westbrook" |
+    Then the result should be, in any order, with relax comparison, and the columns 0,1 should be hashed:
+      | serve._dst | like._dst           | serve.start_year | like.likeness | $$.player.name      |
+      | "Thunders" | EMPTY               | 2008             | EMPTY         | EMPTY               |
+      | EMPTY      | "Paul George"       | EMPTY            | 90            | "Paul George"       |
+      | EMPTY      | "James Harden"      | EMPTY            | 90            | "James Harden"      |
+      | "Pacers"   | EMPTY               | 2010             | EMPTY         | EMPTY               |
+      | "Thunders" | EMPTY               | 2017             | EMPTY         | EMPTY               |
+      | EMPTY      | "Russell Westbrook" | EMPTY            | 95            | "Russell Westbrook" |
+      | "Thunders" | EMPTY               | 2009             | EMPTY         | EMPTY               |
+      | "Rockets"  | EMPTY               | 2012             | EMPTY         | EMPTY               |
+      | EMPTY      | "Russell Westbrook" | EMPTY            | 80            | "Russell Westbrook" |
     When executing query:
       """
       GO 0 TO 2 STEPS FROM hash('Russell Westbrook') OVER *
       YIELD serve._dst, like._dst, serve.start_year, like.likeness, $$.player.name
       """
-    Then the result should be, in any order, with relax comparison:
-      | serve._dst       | like._dst                 | serve.start_year | like.likeness | $$.player.name      |
-      | hash("Thunders") | EMPTY                     | 2008             | EMPTY         | EMPTY               |
-      | EMPTY            | hash("Paul George")       | EMPTY            | 90            | "Paul George"       |
-      | EMPTY            | hash("James Harden")      | EMPTY            | 90            | "James Harden"      |
-      | hash("Pacers")   | EMPTY                     | 2010             | EMPTY         | EMPTY               |
-      | hash("Thunders") | EMPTY                     | 2017             | EMPTY         | EMPTY               |
-      | EMPTY            | hash("Russell Westbrook") | EMPTY            | 95            | "Russell Westbrook" |
-      | hash("Thunders") | EMPTY                     | 2009             | EMPTY         | EMPTY               |
-      | hash("Rockets")  | EMPTY                     | 2012             | EMPTY         | EMPTY               |
-      | EMPTY            | hash("Russell Westbrook") | EMPTY            | 80            | "Russell Westbrook" |
+    Then the result should be, in any order, with relax comparison, and the columns 0,1 should be hashed:
+      | serve._dst | like._dst           | serve.start_year | like.likeness | $$.player.name      |
+      | "Thunders" | EMPTY               | 2008             | EMPTY         | EMPTY               |
+      | EMPTY      | "Paul George"       | EMPTY            | 90            | "Paul George"       |
+      | EMPTY      | "James Harden"      | EMPTY            | 90            | "James Harden"      |
+      | "Pacers"   | EMPTY               | 2010             | EMPTY         | EMPTY               |
+      | "Thunders" | EMPTY               | 2017             | EMPTY         | EMPTY               |
+      | EMPTY      | "Russell Westbrook" | EMPTY            | 95            | "Russell Westbrook" |
+      | "Thunders" | EMPTY               | 2009             | EMPTY         | EMPTY               |
+      | "Rockets"  | EMPTY               | 2012             | EMPTY         | EMPTY               |
+      | EMPTY      | "Russell Westbrook" | EMPTY            | 80            | "Russell Westbrook" |
     When executing query:
       """
       GO 1 TO 2 STEPS FROM hash('Russell Westbrook') OVER * REVERSELY YIELD serve._dst, like._dst
       """
-    Then the result should be, in any order, with relax comparison:
-      | serve._dst | like._dst                 |
-      | EMPTY      | hash("Dejounte Murray")   |
-      | EMPTY      | hash("James Harden")      |
-      | EMPTY      | hash("Paul George")       |
-      | EMPTY      | hash("Dejounte Murray")   |
-      | EMPTY      | hash("Russell Westbrook") |
-      | EMPTY      | hash("Luka Doncic")       |
-      | EMPTY      | hash("Russell Westbrook") |
+    Then the result should be, in any order, with relax comparison, and the columns 0,1 should be hashed:
+      | serve._dst | like._dst           |
+      | EMPTY      | "Dejounte Murray"   |
+      | EMPTY      | "James Harden"      |
+      | EMPTY      | "Paul George"       |
+      | EMPTY      | "Dejounte Murray"   |
+      | EMPTY      | "Russell Westbrook" |
+      | EMPTY      | "Luka Doncic"       |
+      | EMPTY      | "Russell Westbrook" |
     When executing query:
       """
       GO 0 TO 2 STEPS FROM hash('Russell Westbrook') OVER * REVERSELY YIELD serve._dst, like._dst
       """
-    Then the result should be, in any order, with relax comparison:
-      | serve._dst | like._dst                 |
-      | EMPTY      | hash("Dejounte Murray")   |
-      | EMPTY      | hash("James Harden")      |
-      | EMPTY      | hash("Paul George")       |
-      | EMPTY      | hash("Dejounte Murray")   |
-      | EMPTY      | hash("Russell Westbrook") |
-      | EMPTY      | hash("Luka Doncic")       |
-      | EMPTY      | hash("Russell Westbrook") |
+    Then the result should be, in any order, with relax comparison, and the columns 0,1 should be hashed:
+      | serve._dst | like._dst           |
+      | EMPTY      | "Dejounte Murray"   |
+      | EMPTY      | "James Harden"      |
+      | EMPTY      | "Paul George"       |
+      | EMPTY      | "Dejounte Murray"   |
+      | EMPTY      | "Russell Westbrook" |
+      | EMPTY      | "Luka Doncic"       |
+      | EMPTY      | "Russell Westbrook" |
 
   Scenario: Integer Vid error message
     When executing query:
@@ -1459,84 +1459,84 @@ Feature: IntegerVid Go  Sentence
       GO FROM hash('Tim Duncan') OVER like YIELD like._src as src, like._dst as dst | GO FROM $-.src OVER like
       YIELD $-.src as src, like._dst as dst, $^.player.name, $$.player.name
       """
-    Then the result should be, in any order, with relax comparison:
-      | src                | dst                   | $^.player.name | $$.player.name  |
-      | hash("Tim Duncan") | hash("Tony Parker")   | "Tim Duncan"   | "Tony Parker"   |
-      | hash("Tim Duncan") | hash("Manu Ginobili") | "Tim Duncan"   | "Manu Ginobili" |
-      | hash("Tim Duncan") | hash("Tony Parker")   | "Tim Duncan"   | "Tony Parker"   |
-      | hash("Tim Duncan") | hash("Manu Ginobili") | "Tim Duncan"   | "Manu Ginobili" |
+    Then the result should be, in any order, with relax comparison, and the columns 0,1 should be hashed:
+      | src          | dst             | $^.player.name | $$.player.name  |
+      | "Tim Duncan" | "Tony Parker"   | "Tim Duncan"   | "Tony Parker"   |
+      | "Tim Duncan" | "Manu Ginobili" | "Tim Duncan"   | "Manu Ginobili" |
+      | "Tim Duncan" | "Tony Parker"   | "Tim Duncan"   | "Tony Parker"   |
+      | "Tim Duncan" | "Manu Ginobili" | "Tim Duncan"   | "Manu Ginobili" |
     When executing query:
       """
       $a = GO FROM hash('Tim Duncan') OVER like YIELD like._src as src, like._dst as dst;
       GO FROM $a.src OVER like YIELD $a.src as src, like._dst as dst
       """
-    Then the result should be, in any order, with relax comparison:
-      | src                | dst                   |
-      | hash("Tim Duncan") | hash("Tony Parker")   |
-      | hash("Tim Duncan") | hash("Manu Ginobili") |
-      | hash("Tim Duncan") | hash("Tony Parker")   |
-      | hash("Tim Duncan") | hash("Manu Ginobili") |
+    Then the result should be, in any order, with relax comparison, and the columns 0,1 should be hashed:
+      | src          | dst             |
+      | "Tim Duncan" | "Tony Parker"   |
+      | "Tim Duncan" | "Manu Ginobili" |
+      | "Tim Duncan" | "Tony Parker"   |
+      | "Tim Duncan" | "Manu Ginobili" |
     When executing query:
       """
       GO FROM hash('Tim Duncan') OVER like YIELD like._src as src, like._dst as dst
       | GO 1 TO 2 STEPS FROM $-.src OVER like YIELD $-.src as src, like._dst as dst
       """
-    Then the result should be, in any order, with relax comparison:
-      | src                | dst                       |
-      | hash("Tim Duncan") | hash("Tony Parker")       |
-      | hash("Tim Duncan") | hash("Manu Ginobili")     |
-      | hash("Tim Duncan") | hash("Tony Parker")       |
-      | hash("Tim Duncan") | hash("Manu Ginobili")     |
-      | hash("Tim Duncan") | hash("Tim Duncan")        |
-      | hash("Tim Duncan") | hash("Tim Duncan")        |
-      | hash("Tim Duncan") | hash("Manu Ginobili")     |
-      | hash("Tim Duncan") | hash("Manu Ginobili")     |
-      | hash("Tim Duncan") | hash("LaMarcus Aldridge") |
-      | hash("Tim Duncan") | hash("LaMarcus Aldridge") |
-      | hash("Tim Duncan") | hash("Tim Duncan")        |
-      | hash("Tim Duncan") | hash("Tim Duncan")        |
+    Then the result should be, in any order, with relax comparison, and the columns 0,1 should be hashed:
+      | src          | dst                 |
+      | "Tim Duncan" | "Tony Parker"       |
+      | "Tim Duncan" | "Manu Ginobili"     |
+      | "Tim Duncan" | "Tony Parker"       |
+      | "Tim Duncan" | "Manu Ginobili"     |
+      | "Tim Duncan" | "Tim Duncan"        |
+      | "Tim Duncan" | "Tim Duncan"        |
+      | "Tim Duncan" | "Manu Ginobili"     |
+      | "Tim Duncan" | "Manu Ginobili"     |
+      | "Tim Duncan" | "LaMarcus Aldridge" |
+      | "Tim Duncan" | "LaMarcus Aldridge" |
+      | "Tim Duncan" | "Tim Duncan"        |
+      | "Tim Duncan" | "Tim Duncan"        |
     When executing query:
       """
       GO FROM hash('Tim Duncan') OVER like YIELD like._src as src, like._dst as dst
       | GO 1 TO 2 STEPS FROM $-.src OVER like
       YIELD $-.src as src, $-.dst, like._dst as dst, like.likeness
       """
-    Then the result should be, in any order, with relax comparison:
-      | src                | $-.dst                | dst                       | like.likeness |
-      | hash("Tim Duncan") | hash("Tony Parker")   | hash("Tony Parker")       | 95            |
-      | hash("Tim Duncan") | hash("Tony Parker")   | hash("Manu Ginobili")     | 95            |
-      | hash("Tim Duncan") | hash("Manu Ginobili") | hash("Tony Parker")       | 95            |
-      | hash("Tim Duncan") | hash("Manu Ginobili") | hash("Manu Ginobili")     | 95            |
-      | hash("Tim Duncan") | hash("Tony Parker")   | hash("Tim Duncan")        | 95            |
-      | hash("Tim Duncan") | hash("Tony Parker")   | hash("Manu Ginobili")     | 95            |
-      | hash("Tim Duncan") | hash("Tony Parker")   | hash("LaMarcus Aldridge") | 90            |
-      | hash("Tim Duncan") | hash("Tony Parker")   | hash("Tim Duncan")        | 90            |
-      | hash("Tim Duncan") | hash("Manu Ginobili") | hash("Tim Duncan")        | 95            |
-      | hash("Tim Duncan") | hash("Manu Ginobili") | hash("Manu Ginobili")     | 95            |
-      | hash("Tim Duncan") | hash("Manu Ginobili") | hash("LaMarcus Aldridge") | 90            |
-      | hash("Tim Duncan") | hash("Manu Ginobili") | hash("Tim Duncan")        | 90            |
+    Then the result should be, in any order, with relax comparison, and the columns 0,1,2 should be hashed:
+      | src          | $-.dst          | dst                 | like.likeness |
+      | "Tim Duncan" | "Tony Parker"   | "Tony Parker"       | 95            |
+      | "Tim Duncan" | "Tony Parker"   | "Manu Ginobili"     | 95            |
+      | "Tim Duncan" | "Manu Ginobili" | "Tony Parker"       | 95            |
+      | "Tim Duncan" | "Manu Ginobili" | "Manu Ginobili"     | 95            |
+      | "Tim Duncan" | "Tony Parker"   | "Tim Duncan"        | 95            |
+      | "Tim Duncan" | "Tony Parker"   | "Manu Ginobili"     | 95            |
+      | "Tim Duncan" | "Tony Parker"   | "LaMarcus Aldridge" | 90            |
+      | "Tim Duncan" | "Tony Parker"   | "Tim Duncan"        | 90            |
+      | "Tim Duncan" | "Manu Ginobili" | "Tim Duncan"        | 95            |
+      | "Tim Duncan" | "Manu Ginobili" | "Manu Ginobili"     | 95            |
+      | "Tim Duncan" | "Manu Ginobili" | "LaMarcus Aldridge" | 90            |
+      | "Tim Duncan" | "Manu Ginobili" | "Tim Duncan"        | 90            |
     When executing query:
       """
       GO FROM hash('Danny Green') OVER like YIELD like._src AS src, like._dst AS dst
       | GO FROM $-.dst OVER teammate YIELD $-.src AS src, $-.dst, teammate._dst AS dst
       """
-    Then the result should be, in any order, with relax comparison:
-      | src                 | $-.dst             | dst                       |
-      | hash("Danny Green") | hash("Tim Duncan") | hash("Tony Parker")       |
-      | hash("Danny Green") | hash("Tim Duncan") | hash("Manu Ginobili")     |
-      | hash("Danny Green") | hash("Tim Duncan") | hash("LaMarcus Aldridge") |
-      | hash("Danny Green") | hash("Tim Duncan") | hash("Danny Green")       |
+    Then the result should be, in any order, with relax comparison, and the columns 0,1,2 should be hashed:
+      | src           | $-.dst       | dst                 |
+      | "Danny Green" | "Tim Duncan" | "Tony Parker"       |
+      | "Danny Green" | "Tim Duncan" | "Manu Ginobili"     |
+      | "Danny Green" | "Tim Duncan" | "LaMarcus Aldridge" |
+      | "Danny Green" | "Tim Duncan" | "Danny Green"       |
     When executing query:
       """
       $a = GO FROM hash('Danny Green') OVER like YIELD like._src AS src, like._dst AS dst;
       GO FROM $a.dst OVER teammate YIELD $a.src AS src, $a.dst, teammate._dst AS dst
       """
-    Then the result should be, in any order, with relax comparison:
-      | src                 | $a.dst             | dst                       |
-      | hash("Danny Green") | hash("Tim Duncan") | hash("Tony Parker")       |
-      | hash("Danny Green") | hash("Tim Duncan") | hash("Manu Ginobili")     |
-      | hash("Danny Green") | hash("Tim Duncan") | hash("LaMarcus Aldridge") |
-      | hash("Danny Green") | hash("Tim Duncan") | hash("Danny Green")       |
+    Then the result should be, in any order, with relax comparison, and the columns 0,1,2 should be hashed:
+      | src           | $a.dst       | dst                 |
+      | "Danny Green" | "Tim Duncan" | "Tony Parker"       |
+      | "Danny Green" | "Tim Duncan" | "Manu Ginobili"     |
+      | "Danny Green" | "Tim Duncan" | "LaMarcus Aldridge" |
+      | "Danny Green" | "Tim Duncan" | "Danny Green"       |
 
   Scenario: Integer Vid backtrack overlap
     When executing query:
@@ -1544,45 +1544,45 @@ Feature: IntegerVid Go  Sentence
       GO FROM hash('Tony Parker') OVER like YIELD like._src as src, like._dst as dst
       | GO 2 STEPS FROM $-.src OVER like YIELD $-.src, $-.dst, like._src, like._dst
       """
-    Then the result should be, in any order, with relax comparison:
-      | $-.src              | $-.dst                     | like._src                  | like._dst              |
-      | hash("Tony Parker") | hash("Tim Duncan" )        | hash("Tim Duncan" )        | hash("Manu Ginobili")  |
-      | hash("Tony Parker") | hash("Tim Duncan" )        | hash("Tim Duncan" )        | hash("Tony Parker")    |
-      | hash("Tony Parker") | hash("Tim Duncan" )        | hash("LaMarcus Aldridge" ) | hash("Tony Parker")    |
-      | hash("Tony Parker") | hash("Tim Duncan" )        | hash("Manu Ginobili")      | hash("Tim Duncan" )    |
-      | hash("Tony Parker") | hash("Tim Duncan" )        | hash("LaMarcus Aldridge" ) | hash("Tim Duncan" )    |
-      | hash("Tony Parker") | hash("Manu Ginobili" )     | hash("Tim Duncan" )        | hash("Manu Ginobili" ) |
-      | hash("Tony Parker") | hash("Manu Ginobili" )     | hash("Tim Duncan" )        | hash("Tony Parker")    |
-      | hash("Tony Parker") | hash("Manu Ginobili" )     | hash("LaMarcus Aldridge" ) | hash("Tony Parker")    |
-      | hash("Tony Parker") | hash("Manu Ginobili" )     | hash("Manu Ginobili" )     | hash("Tim Duncan" )    |
-      | hash("Tony Parker") | hash("Manu Ginobili" )     | hash("LaMarcus Aldridge" ) | hash("Tim Duncan" )    |
-      | hash("Tony Parker") | hash("LaMarcus Aldridge" ) | hash("Tim Duncan" )        | hash("Manu Ginobili" ) |
-      | hash("Tony Parker") | hash("LaMarcus Aldridge" ) | hash("Tim Duncan" )        | hash("Tony Parker")    |
-      | hash("Tony Parker") | hash("LaMarcus Aldridge" ) | hash("LaMarcus Aldridge" ) | hash("Tony Parker")    |
-      | hash("Tony Parker") | hash("LaMarcus Aldridge" ) | hash("Manu Ginobili" )     | hash("Tim Duncan" )    |
-      | hash("Tony Parker") | hash("LaMarcus Aldridge" ) | hash("LaMarcus Aldridge" ) | hash("Tim Duncan" )    |
+    Then the result should be, in any order, with relax comparison, and the columns 0,1,2,3 should be hashed:
+      | $-.src        | $-.dst              | like._src           | like._dst       |
+      | "Tony Parker" | "Tim Duncan"        | "Tim Duncan"        | "Manu Ginobili" |
+      | "Tony Parker" | "Tim Duncan"        | "Tim Duncan"        | "Tony Parker"   |
+      | "Tony Parker" | "Tim Duncan"        | "LaMarcus Aldridge" | "Tony Parker"   |
+      | "Tony Parker" | "Tim Duncan"        | "Manu Ginobili"     | "Tim Duncan"    |
+      | "Tony Parker" | "Tim Duncan"        | "LaMarcus Aldridge" | "Tim Duncan"    |
+      | "Tony Parker" | "Manu Ginobili"     | "Tim Duncan"        | "Manu Ginobili" |
+      | "Tony Parker" | "Manu Ginobili"     | "Tim Duncan"        | "Tony Parker"   |
+      | "Tony Parker" | "Manu Ginobili"     | "LaMarcus Aldridge" | "Tony Parker"   |
+      | "Tony Parker" | "Manu Ginobili"     | "Manu Ginobili"     | "Tim Duncan"    |
+      | "Tony Parker" | "Manu Ginobili"     | "LaMarcus Aldridge" | "Tim Duncan"    |
+      | "Tony Parker" | "LaMarcus Aldridge" | "Tim Duncan"        | "Manu Ginobili" |
+      | "Tony Parker" | "LaMarcus Aldridge" | "Tim Duncan"        | "Tony Parker"   |
+      | "Tony Parker" | "LaMarcus Aldridge" | "LaMarcus Aldridge" | "Tony Parker"   |
+      | "Tony Parker" | "LaMarcus Aldridge" | "Manu Ginobili"     | "Tim Duncan"    |
+      | "Tony Parker" | "LaMarcus Aldridge" | "LaMarcus Aldridge" | "Tim Duncan"    |
     When executing query:
       """
       $a = GO FROM hash('Tony Parker') OVER like YIELD like._src as src, like._dst as dst;
       GO 2 STEPS FROM $a.src OVER like YIELD $a.src, $a.dst, like._src, like._dst
       """
-    Then the result should be, in any order, with relax comparison:
-      | $a.src              | $a.dst                     | like._src                  | like._dst              |
-      | hash("Tony Parker") | hash("Tim Duncan" )        | hash("Tim Duncan" )        | hash("Manu Ginobili")  |
-      | hash("Tony Parker") | hash("Tim Duncan" )        | hash("Tim Duncan" )        | hash("Tony Parker")    |
-      | hash("Tony Parker") | hash("Tim Duncan" )        | hash("LaMarcus Aldridge" ) | hash("Tony Parker")    |
-      | hash("Tony Parker") | hash("Tim Duncan" )        | hash("Manu Ginobili")      | hash("Tim Duncan" )    |
-      | hash("Tony Parker") | hash("Tim Duncan" )        | hash("LaMarcus Aldridge" ) | hash("Tim Duncan" )    |
-      | hash("Tony Parker") | hash("Manu Ginobili" )     | hash("Tim Duncan" )        | hash("Manu Ginobili" ) |
-      | hash("Tony Parker") | hash("Manu Ginobili" )     | hash("Tim Duncan" )        | hash("Tony Parker")    |
-      | hash("Tony Parker") | hash("Manu Ginobili" )     | hash("LaMarcus Aldridge" ) | hash("Tony Parker")    |
-      | hash("Tony Parker") | hash("Manu Ginobili" )     | hash("Manu Ginobili" )     | hash("Tim Duncan" )    |
-      | hash("Tony Parker") | hash("Manu Ginobili" )     | hash("LaMarcus Aldridge" ) | hash("Tim Duncan" )    |
-      | hash("Tony Parker") | hash("LaMarcus Aldridge" ) | hash("Tim Duncan" )        | hash("Manu Ginobili" ) |
-      | hash("Tony Parker") | hash("LaMarcus Aldridge" ) | hash("Tim Duncan" )        | hash("Tony Parker")    |
-      | hash("Tony Parker") | hash("LaMarcus Aldridge" ) | hash("LaMarcus Aldridge" ) | hash("Tony Parker")    |
-      | hash("Tony Parker") | hash("LaMarcus Aldridge" ) | hash("Manu Ginobili" )     | hash("Tim Duncan" )    |
-      | hash("Tony Parker") | hash("LaMarcus Aldridge" ) | hash("LaMarcus Aldridge" ) | hash("Tim Duncan" )    |
+    Then the result should be, in any order, with relax comparison, and the columns 0,1,2,3 should be hashed:
+      | $a.src        | $a.dst              | like._src           | like._dst       |
+      | "Tony Parker" | "Tim Duncan"        | "Tim Duncan"        | "Manu Ginobili" |
+      | "Tony Parker" | "Tim Duncan"        | "Tim Duncan"        | "Tony Parker"   |
+      | "Tony Parker" | "Tim Duncan"        | "LaMarcus Aldridge" | "Tony Parker"   |
+      | "Tony Parker" | "Tim Duncan"        | "Manu Ginobili"     | "Tim Duncan"    |
+      | "Tony Parker" | "Tim Duncan"        | "LaMarcus Aldridge" | "Tim Duncan"    |
+      | "Tony Parker" | "Manu Ginobili"     | "Tim Duncan"        | "Manu Ginobili" |
+      | "Tony Parker" | "Manu Ginobili"     | "Tim Duncan"        | "Tony Parker"   |
+      | "Tony Parker" | "Manu Ginobili"     | "LaMarcus Aldridge" | "Tony Parker"   |
+      | "Tony Parker" | "Manu Ginobili"     | "Manu Ginobili"     | "Tim Duncan"    |
+      | "Tony Parker" | "Manu Ginobili"     | "LaMarcus Aldridge" | "Tim Duncan"    |
+      | "Tony Parker" | "LaMarcus Aldridge" | "Tim Duncan"        | "Manu Ginobili" |
+      | "Tony Parker" | "LaMarcus Aldridge" | "Tim Duncan"        | "Tony Parker"   |
+      | "Tony Parker" | "LaMarcus Aldridge" | "LaMarcus Aldridge" | "Tony Parker"   |
+      | "Tony Parker" | "LaMarcus Aldridge" | "Manu Ginobili"     | "Tim Duncan"    |
+      | "Tony Parker" | "LaMarcus Aldridge" | "LaMarcus Aldridge" | "Tim Duncan"    |
 
   Scenario: Integer Vid GroupBy and Count
     When executing query:
@@ -1599,6 +1599,6 @@ Feature: IntegerVid Go  Sentence
       """
       GO FROM hash("Tim Duncan") OVER like WHERE like._dst == hash("Tony Parker") | limit 10;
       """
-    Then the result should be, in any order, with relax comparison:
-      | like._dst           |
-      | hash("Tony Parker") |
+    Then the result should be, in any order, with relax comparison, and the columns 0 should be hashed:
+      | like._dst     |
+      | "Tony Parker" |
diff --git a/tests/tck/features/go/GroupbyLimit.IntVid.feature b/tests/tck/features/go/GroupbyLimit.IntVid.feature
index ce2ad2ae14e74faaab0965664de95d5cca7de36a..5bceeed297bcc490be6003d439f861e6224d5dc0 100644
--- a/tests/tck/features/go/GroupbyLimit.IntVid.feature
+++ b/tests/tck/features/go/GroupbyLimit.IntVid.feature
@@ -220,40 +220,40 @@ Feature: Groupby & limit Sentence
       | GO FROM $-.dst over like YIELD $-.dst as dst, like._dst == hash('Tim Duncan') as following
       | GROUP BY $-.dst YIELD $-.dst AS dst, BIT_OR($-.following) AS following
       """
-    Then the result should be, in any order, with relax comparison:
-      | dst                   | following |
-      | hash("Manu Ginobili") | BAD_TYPE  |
-      | hash("Tony Parker")   | BAD_TYPE  |
+    Then the result should be, in any order, with relax comparison, and the columns 0 should be hashed:
+      | dst             | following |
+      | "Manu Ginobili" | BAD_TYPE  |
+      | "Tony Parker"   | BAD_TYPE  |
     When executing query:
       """
       GO FROM hash('Tim Duncan') OVER like YIELD like._dst as dst
       | GO FROM $-.dst over like YIELD $-.dst as dst, like._dst == hash('Tim Duncan') as following
       | GROUP BY $-.dst YIELD $-.dst AS dst, BIT_OR(case when $-.following==true then 1 else 0 end) AS following
       """
-    Then the result should be, in any order, with relax comparison:
-      | dst                   | following |
-      | hash("Tony Parker")   | 1         |
-      | hash("Manu Ginobili") | 1         |
+    Then the result should be, in any order, with relax comparison, and the columns 0 should be hashed:
+      | dst             | following |
+      | "Tony Parker"   | 1         |
+      | "Manu Ginobili" | 1         |
     When executing query:
       """
       GO FROM hash('Tim Duncan') OVER like YIELD like._dst as dst
       |  GO FROM $-.dst over like YIELD $-.dst as dst, like._dst == hash('Tim Duncan') as following
       | GROUP BY $-.dst YIELD $-.dst AS dst, BIT_AND($-.following) AS following
       """
-    Then the result should be, in any order, with relax comparison:
-      | dst                   | following |
-      | hash("Manu Ginobili") | BAD_TYPE  |
-      | hash("Tony Parker")   | BAD_TYPE  |
+    Then the result should be, in any order, with relax comparison, and the columns 0 should be hashed:
+      | dst             | following |
+      | "Manu Ginobili" | BAD_TYPE  |
+      | "Tony Parker"   | BAD_TYPE  |
     When executing query:
       """
       GO FROM hash('Tim Duncan') OVER like YIELD like._dst as dst
       | GO FROM $-.dst over like YIELD $-.dst as dst, like._dst == hash('Tim Duncan') as following
       | GROUP BY $-.dst YIELD $-.dst AS dst, BIT_AND(case when $-.following==true then 1 else 0 end) AS following
       """
-    Then the result should be, in any order, with relax comparison:
-      | dst                   | following |
-      | hash("Manu Ginobili") | 1         |
-      | hash("Tony Parker")   | 0         |
+    Then the result should be, in any order, with relax comparison, and the columns 0 should be hashed:
+      | dst             | following |
+      | "Manu Ginobili" | 1         |
+      | "Tony Parker"   | 0         |
 
   @skip
   Scenario: Groupby with COUNT_DISTINCT
diff --git a/tests/tck/features/insert/Insert.IntVid.feature b/tests/tck/features/insert/Insert.IntVid.feature
index 5cf107efcc1e944977c0d9dc44286a6e91cd133e..60f32a555fd38bb5a2065319c0dab99a45d30882 100644
--- a/tests/tck/features/insert/Insert.IntVid.feature
+++ b/tests/tck/features/insert/Insert.IntVid.feature
@@ -96,9 +96,9 @@ Feature: Insert int vid of vertex and edge
       """
       FETCH PROP ON person hash("Conan")
       """
-    Then the result should be, in any order:
-      | VertexID      | person.name | person.age |
-      | hash('Conan') | "Conan"     | 10         |
+    Then the result should be, in any order, and the columns 0 should be hashed:
+      | VertexID | person.name | person.age |
+      | 'Conan'  | "Conan"     | 10         |
     # # insert vertex with uuid
     # When executing query:
     # """
@@ -129,9 +129,9 @@ Feature: Insert int vid of vertex and edge
       """
       FETCH PROP ON schoolmate hash("Tom")->hash("Bob")
       """
-    Then the result should be, in any order:
+    Then the result should be, in any order, and the columns 0,1 should be hashed:
       | schoolmate._src | schoolmate._dst | schoolmate._rank | schoolmate.likeness | schoolmate.nickname |
-      | hash('Tom')     | hash('Bob')     | 0                | 87                  | "Superman"          |
+      | 'Tom'           | 'Bob'           | 0                | 87                  | "Superman"          |
     # insert edge with timestamp succeed
     When executing query:
       """
@@ -145,17 +145,17 @@ Feature: Insert int vid of vertex and edge
       GO FROM hash("Laura") OVER study
       YIELD $$.school.name, study._dst, $$.school.create_time, (string)study.start_time
       """
-    Then the result should be, in any order:
-      | $$.school.name | study._dst         | $$.school.create_time | (STRING)study.start_time |
-      | "sun_school"   | hash("sun_school") | 1262340000            | "1546336800"             |
+    Then the result should be, in any order, and the columns 1 should be hashed:
+      | $$.school.name | study._dst   | $$.school.create_time | (STRING)study.start_time |
+      | "sun_school"   | "sun_school" | 1262340000            | "1546336800"             |
     # check edge result with fetch
     When executing query:
       """
       FETCH PROP ON school hash("sun_school")
       """
-    Then the result should be, in any order:
-      | VertexID           | school.name  | school.create_time |
-      | hash("sun_school") | "sun_school" | 1262340000         |
+    Then the result should be, in any order, and the columns 0 should be hashed:
+      | VertexID     | school.name  | school.create_time |
+      | "sun_school" | "sun_school" | 1262340000         |
     # insert one vertex multi tags
     When executing query:
       """
@@ -175,17 +175,17 @@ Feature: Insert int vid of vertex and edge
       """
       FETCH PROP ON person hash("Bob")
       """
-    Then the result should be, in any order:
-      | VertexID    | person.name | person.age |
-      | hash('Bob') | 'Bob'       | 9          |
+    Then the result should be, in any order, and the columns 0 should be hashed:
+      | VertexID | person.name | person.age |
+      | 'Bob'    | 'Bob'       | 9          |
     # check student tag result with fetch
     When executing query:
       """
       FETCH PROP ON student hash("Bob")
       """
-    Then the result should be, in any order:
-      | VertexID    | student.grade | student.number |
-      | hash('Bob') | 'four'        | 20191106001    |
+    Then the result should be, in any order, and the columns 0 should be hashed:
+      | VertexID | student.grade | student.number |
+      | 'Bob'    | 'four'        | 20191106001    |
     # insert multi vertex multi tags
     When executing query:
       """
diff --git a/tests/tck/features/lookup/ByIndex.intVid.feature b/tests/tck/features/lookup/ByIndex.intVid.feature
index c5dba792c1ce66673fcd4c733b5743f7a8c1fa24..701b98fcea7626f45c3fb5b64c2bf7d0bdc1711c 100644
--- a/tests/tck/features/lookup/ByIndex.intVid.feature
+++ b/tests/tck/features/lookup/ByIndex.intVid.feature
@@ -8,74 +8,74 @@ Feature: Lookup by index itself in integer vid
       """
       LOOKUP ON team
       """
-    Then the result should be, in any order:
-      | VertexID              |
-      | hash('Nets')          |
-      | hash('Pistons')       |
-      | hash('Bucks')         |
-      | hash('Mavericks')     |
-      | hash('Clippers')      |
-      | hash('Thunders')      |
-      | hash('Lakers')        |
-      | hash('Jazz')          |
-      | hash('Nuggets')       |
-      | hash('Wizards')       |
-      | hash('Pacers')        |
-      | hash('Timberwolves')  |
-      | hash('Hawks')         |
-      | hash('Warriors')      |
-      | hash('Magic')         |
-      | hash('Rockets')       |
-      | hash('Pelicans')      |
-      | hash('Raptors')       |
-      | hash('Spurs')         |
-      | hash('Heat')          |
-      | hash('Grizzlies')     |
-      | hash('Knicks')        |
-      | hash('Suns')          |
-      | hash('Hornets')       |
-      | hash('Cavaliers')     |
-      | hash('Kings')         |
-      | hash('Celtics')       |
-      | hash('76ers')         |
-      | hash('Trail Blazers') |
-      | hash('Bulls')         |
+    Then the result should be, in any order, and the columns 0 should be hashed:
+      | VertexID        |
+      | 'Nets'          |
+      | 'Pistons'       |
+      | 'Bucks'         |
+      | 'Mavericks'     |
+      | 'Clippers'      |
+      | 'Thunders'      |
+      | 'Lakers'        |
+      | 'Jazz'          |
+      | 'Nuggets'       |
+      | 'Wizards'       |
+      | 'Pacers'        |
+      | 'Timberwolves'  |
+      | 'Hawks'         |
+      | 'Warriors'      |
+      | 'Magic'         |
+      | 'Rockets'       |
+      | 'Pelicans'      |
+      | 'Raptors'       |
+      | 'Spurs'         |
+      | 'Heat'          |
+      | 'Grizzlies'     |
+      | 'Knicks'        |
+      | 'Suns'          |
+      | 'Hornets'       |
+      | 'Cavaliers'     |
+      | 'Kings'         |
+      | 'Celtics'       |
+      | '76ers'         |
+      | 'Trail Blazers' |
+      | 'Bulls'         |
     When executing query:
       """
       LOOKUP ON team YIELD team.name AS Name
       """
-    Then the result should be, in any order:
-      | VertexID              | Name            |
-      | hash('Nets')          | 'Nets'          |
-      | hash('Pistons')       | 'Pistons'       |
-      | hash('Bucks')         | 'Bucks'         |
-      | hash('Mavericks')     | 'Mavericks'     |
-      | hash('Clippers')      | 'Clippers'      |
-      | hash('Thunders')      | 'Thunders'      |
-      | hash('Lakers')        | 'Lakers'        |
-      | hash('Jazz')          | 'Jazz'          |
-      | hash('Nuggets')       | 'Nuggets'       |
-      | hash('Wizards')       | 'Wizards'       |
-      | hash('Pacers')        | 'Pacers'        |
-      | hash('Timberwolves')  | 'Timberwolves'  |
-      | hash('Hawks')         | 'Hawks'         |
-      | hash('Warriors')      | 'Warriors'      |
-      | hash('Magic')         | 'Magic'         |
-      | hash('Rockets')       | 'Rockets'       |
-      | hash('Pelicans')      | 'Pelicans'      |
-      | hash('Raptors')       | 'Raptors'       |
-      | hash('Spurs')         | 'Spurs'         |
-      | hash('Heat')          | 'Heat'          |
-      | hash('Grizzlies')     | 'Grizzlies'     |
-      | hash('Knicks')        | 'Knicks'        |
-      | hash('Suns')          | 'Suns'          |
-      | hash('Hornets')       | 'Hornets'       |
-      | hash('Cavaliers')     | 'Cavaliers'     |
-      | hash('Kings')         | 'Kings'         |
-      | hash('Celtics')       | 'Celtics'       |
-      | hash('76ers')         | '76ers'         |
-      | hash('Trail Blazers') | 'Trail Blazers' |
-      | hash('Bulls')         | 'Bulls'         |
+    Then the result should be, in any order, and the columns 0 should be hashed:
+      | VertexID        | Name            |
+      | 'Nets'          | 'Nets'          |
+      | 'Pistons'       | 'Pistons'       |
+      | 'Bucks'         | 'Bucks'         |
+      | 'Mavericks'     | 'Mavericks'     |
+      | 'Clippers'      | 'Clippers'      |
+      | 'Thunders'      | 'Thunders'      |
+      | 'Lakers'        | 'Lakers'        |
+      | 'Jazz'          | 'Jazz'          |
+      | 'Nuggets'       | 'Nuggets'       |
+      | 'Wizards'       | 'Wizards'       |
+      | 'Pacers'        | 'Pacers'        |
+      | 'Timberwolves'  | 'Timberwolves'  |
+      | 'Hawks'         | 'Hawks'         |
+      | 'Warriors'      | 'Warriors'      |
+      | 'Magic'         | 'Magic'         |
+      | 'Rockets'       | 'Rockets'       |
+      | 'Pelicans'      | 'Pelicans'      |
+      | 'Raptors'       | 'Raptors'       |
+      | 'Spurs'         | 'Spurs'         |
+      | 'Heat'          | 'Heat'          |
+      | 'Grizzlies'     | 'Grizzlies'     |
+      | 'Knicks'        | 'Knicks'        |
+      | 'Suns'          | 'Suns'          |
+      | 'Hornets'       | 'Hornets'       |
+      | 'Cavaliers'     | 'Cavaliers'     |
+      | 'Kings'         | 'Kings'         |
+      | 'Celtics'       | 'Celtics'       |
+      | '76ers'         | '76ers'         |
+      | 'Trail Blazers' | 'Trail Blazers' |
+      | 'Bulls'         | 'Bulls'         |
 
   Scenario: [1] Tag TODO
     When executing query:
@@ -104,318 +104,318 @@ Feature: Lookup by index itself in integer vid
       """
       LOOKUP ON serve
       """
-    Then the result should be, in any order:
-      | SrcVID                        | DstVID                | Ranking |
-      | hash("Amar'e Stoudemire")     | hash('Suns')          | 0       |
-      | hash("Amar'e Stoudemire")     | hash('Knicks')        | 0       |
-      | hash("Amar'e Stoudemire")     | hash('Heat')          | 0       |
-      | hash('Russell Westbrook')     | hash('Thunders')      | 0       |
-      | hash('James Harden')          | hash('Thunders')      | 0       |
-      | hash('James Harden')          | hash('Rockets')       | 0       |
-      | hash('Kobe Bryant')           | hash('Lakers')        | 0       |
-      | hash('Tracy McGrady')         | hash('Raptors')       | 0       |
-      | hash('Tracy McGrady')         | hash('Magic')         | 0       |
-      | hash('Tracy McGrady')         | hash('Rockets')       | 0       |
-      | hash('Tracy McGrady')         | hash('Spurs')         | 0       |
-      | hash('Chris Paul')            | hash('Hornets')       | 0       |
-      | hash('Chris Paul')            | hash('Clippers')      | 0       |
-      | hash('Chris Paul')            | hash('Rockets')       | 0       |
-      | hash('Boris Diaw')            | hash('Hawks')         | 0       |
-      | hash('Boris Diaw')            | hash('Suns')          | 0       |
-      | hash('Boris Diaw')            | hash('Hornets')       | 0       |
-      | hash('Boris Diaw')            | hash('Spurs')         | 0       |
-      | hash('Boris Diaw')            | hash('Jazz')          | 0       |
-      | hash('LeBron James')          | hash('Cavaliers')     | 0       |
-      | hash('LeBron James')          | hash('Heat')          | 0       |
-      | hash('LeBron James')          | hash('Cavaliers')     | 1       |
-      | hash('LeBron James')          | hash('Lakers')        | 0       |
-      | hash('Klay Thompson')         | hash('Warriors')      | 0       |
-      | hash('Kristaps Porzingis')    | hash('Knicks')        | 0       |
-      | hash('Kristaps Porzingis')    | hash('Mavericks')     | 0       |
-      | hash('Jonathon Simmons')      | hash('Spurs')         | 0       |
-      | hash('Jonathon Simmons')      | hash('Magic')         | 0       |
-      | hash('Jonathon Simmons')      | hash('76ers')         | 0       |
-      | hash('Marco Belinelli')       | hash('Warriors')      | 0       |
-      | hash('Marco Belinelli')       | hash('Raptors')       | 0       |
-      | hash('Marco Belinelli')       | hash('Hornets')       | 0       |
-      | hash('Marco Belinelli')       | hash('Bulls')         | 0       |
-      | hash('Marco Belinelli')       | hash('Spurs')         | 0       |
-      | hash('Marco Belinelli')       | hash('Kings')         | 0       |
-      | hash('Marco Belinelli')       | hash('Hornets')       | 1       |
-      | hash('Marco Belinelli')       | hash('Hawks')         | 0       |
-      | hash('Marco Belinelli')       | hash('76ers')         | 0       |
-      | hash('Marco Belinelli')       | hash('Spurs')         | 1       |
-      | hash('Luka Doncic')           | hash('Mavericks')     | 0       |
-      | hash('David West')            | hash('Hornets')       | 0       |
-      | hash('David West')            | hash('Pacers')        | 0       |
-      | hash('David West')            | hash('Spurs')         | 0       |
-      | hash('David West')            | hash('Warriors')      | 0       |
-      | hash('Tony Parker')           | hash('Spurs')         | 0       |
-      | hash('Tony Parker')           | hash('Hornets')       | 0       |
-      | hash('Danny Green')           | hash('Cavaliers')     | 0       |
-      | hash('Danny Green')           | hash('Spurs')         | 0       |
-      | hash('Danny Green')           | hash('Raptors')       | 0       |
-      | hash('Rudy Gay')              | hash('Grizzlies')     | 0       |
-      | hash('Rudy Gay')              | hash('Raptors')       | 0       |
-      | hash('Rudy Gay')              | hash('Kings')         | 0       |
-      | hash('Rudy Gay')              | hash('Spurs')         | 0       |
-      | hash('LaMarcus Aldridge')     | hash('Trail Blazers') | 0       |
-      | hash('LaMarcus Aldridge')     | hash('Spurs')         | 0       |
-      | hash('Tim Duncan')            | hash('Spurs')         | 0       |
-      | hash('Kevin Durant')          | hash('Thunders')      | 0       |
-      | hash('Kevin Durant')          | hash('Warriors')      | 0       |
-      | hash('Stephen Curry')         | hash('Warriors')      | 0       |
-      | hash('Ray Allen')             | hash('Bucks')         | 0       |
-      | hash('Ray Allen')             | hash('Thunders')      | 0       |
-      | hash('Ray Allen')             | hash('Celtics')       | 0       |
-      | hash('Ray Allen')             | hash('Heat')          | 0       |
-      | hash('Tiago Splitter')        | hash('Spurs')         | 0       |
-      | hash('Tiago Splitter')        | hash('Hawks')         | 0       |
-      | hash('Tiago Splitter')        | hash('76ers')         | 0       |
-      | hash('DeAndre Jordan')        | hash('Clippers')      | 0       |
-      | hash('DeAndre Jordan')        | hash('Mavericks')     | 0       |
-      | hash('DeAndre Jordan')        | hash('Knicks')        | 0       |
-      | hash('Paul Gasol')            | hash('Grizzlies')     | 0       |
-      | hash('Paul Gasol')            | hash('Lakers')        | 0       |
-      | hash('Paul Gasol')            | hash('Bulls')         | 0       |
-      | hash('Paul Gasol')            | hash('Spurs')         | 0       |
-      | hash('Paul Gasol')            | hash('Bucks')         | 0       |
-      | hash('Aron Baynes')           | hash('Spurs')         | 0       |
-      | hash('Aron Baynes')           | hash('Pistons')       | 0       |
-      | hash('Aron Baynes')           | hash('Celtics')       | 0       |
-      | hash('Cory Joseph')           | hash('Spurs')         | 0       |
-      | hash('Cory Joseph')           | hash('Raptors')       | 0       |
-      | hash('Cory Joseph')           | hash('Pacers')        | 0       |
-      | hash('Vince Carter')          | hash('Raptors')       | 0       |
-      | hash('Vince Carter')          | hash('Nets')          | 0       |
-      | hash('Vince Carter')          | hash('Magic')         | 0       |
-      | hash('Vince Carter')          | hash('Suns')          | 0       |
-      | hash('Vince Carter')          | hash('Mavericks')     | 0       |
-      | hash('Vince Carter')          | hash('Grizzlies')     | 0       |
-      | hash('Vince Carter')          | hash('Kings')         | 0       |
-      | hash('Vince Carter')          | hash('Hawks')         | 0       |
-      | hash('Marc Gasol')            | hash('Grizzlies')     | 0       |
-      | hash('Marc Gasol')            | hash('Raptors')       | 0       |
-      | hash('Ricky Rubio')           | hash('Timberwolves')  | 0       |
-      | hash('Ricky Rubio')           | hash('Jazz')          | 0       |
-      | hash('Ben Simmons')           | hash('76ers')         | 0       |
-      | hash('Giannis Antetokounmpo') | hash('Bucks')         | 0       |
-      | hash('Rajon Rondo')           | hash('Celtics')       | 0       |
-      | hash('Rajon Rondo')           | hash('Mavericks')     | 0       |
-      | hash('Rajon Rondo')           | hash('Kings')         | 0       |
-      | hash('Rajon Rondo')           | hash('Bulls')         | 0       |
-      | hash('Rajon Rondo')           | hash('Pelicans')      | 0       |
-      | hash('Rajon Rondo')           | hash('Lakers')        | 0       |
-      | hash('Manu Ginobili')         | hash('Spurs')         | 0       |
-      | hash('Kyrie Irving')          | hash('Cavaliers')     | 0       |
-      | hash('Kyrie Irving')          | hash('Celtics')       | 0       |
-      | hash('Carmelo Anthony')       | hash('Nuggets')       | 0       |
-      | hash('Carmelo Anthony')       | hash('Knicks')        | 0       |
-      | hash('Carmelo Anthony')       | hash('Thunders')      | 0       |
-      | hash('Carmelo Anthony')       | hash('Rockets')       | 0       |
-      | hash('Dwyane Wade')           | hash('Heat')          | 0       |
-      | hash('Dwyane Wade')           | hash('Bulls')         | 0       |
-      | hash('Dwyane Wade')           | hash('Cavaliers')     | 0       |
-      | hash('Dwyane Wade')           | hash('Heat')          | 1       |
-      | hash('Joel Embiid')           | hash('76ers')         | 0       |
-      | hash('Damian Lillard')        | hash('Trail Blazers') | 0       |
-      | hash('Yao Ming')              | hash('Rockets')       | 0       |
-      | hash('Kyle Anderson')         | hash('Spurs')         | 0       |
-      | hash('Kyle Anderson')         | hash('Grizzlies')     | 0       |
-      | hash('Dejounte Murray')       | hash('Spurs')         | 0       |
-      | hash('Blake Griffin')         | hash('Clippers')      | 0       |
-      | hash('Blake Griffin')         | hash('Pistons')       | 0       |
-      | hash('Steve Nash')            | hash('Suns')          | 0       |
-      | hash('Steve Nash')            | hash('Mavericks')     | 0       |
-      | hash('Steve Nash')            | hash('Suns')          | 1       |
-      | hash('Steve Nash')            | hash('Lakers')        | 0       |
-      | hash('Jason Kidd')            | hash('Mavericks')     | 0       |
-      | hash('Jason Kidd')            | hash('Suns')          | 0       |
-      | hash('Jason Kidd')            | hash('Nets')          | 0       |
-      | hash('Jason Kidd')            | hash('Mavericks')     | 1       |
-      | hash('Jason Kidd')            | hash('Knicks')        | 0       |
-      | hash('Dirk Nowitzki')         | hash('Mavericks')     | 0       |
-      | hash('Paul George')           | hash('Pacers')        | 0       |
-      | hash('Paul George')           | hash('Thunders')      | 0       |
-      | hash('Grant Hill')            | hash('Pistons')       | 0       |
-      | hash('Grant Hill')            | hash('Magic')         | 0       |
-      | hash('Grant Hill')            | hash('Suns')          | 0       |
-      | hash('Grant Hill')            | hash('Clippers')      | 0       |
-      | hash("Shaquile O'Neal")       | hash('Magic')         | 0       |
-      | hash("Shaquile O'Neal")       | hash('Lakers')        | 0       |
-      | hash("Shaquile O'Neal")       | hash('Heat')          | 0       |
-      | hash("Shaquile O'Neal")       | hash('Suns')          | 0       |
-      | hash("Shaquile O'Neal")       | hash('Cavaliers')     | 0       |
-      | hash("Shaquile O'Neal")       | hash('Celtics')       | 0       |
-      | hash('JaVale McGee')          | hash('Wizards')       | 0       |
-      | hash('JaVale McGee')          | hash('Nuggets')       | 0       |
-      | hash('JaVale McGee')          | hash('Mavericks')     | 0       |
-      | hash('JaVale McGee')          | hash('Warriors')      | 0       |
-      | hash('JaVale McGee')          | hash('Lakers')        | 0       |
-      | hash('Dwight Howard')         | hash('Magic')         | 0       |
-      | hash('Dwight Howard')         | hash('Lakers')        | 0       |
-      | hash('Dwight Howard')         | hash('Rockets')       | 0       |
-      | hash('Dwight Howard')         | hash('Hawks')         | 0       |
-      | hash('Dwight Howard')         | hash('Hornets')       | 0       |
-      | hash('Dwight Howard')         | hash('Wizards')       | 0       |
+    Then the result should be, in any order, and the columns 0,1 should be hashed:
+      | SrcVID                  | DstVID          | Ranking |
+      | "Amar'e Stoudemire"     | 'Suns'          | 0       |
+      | "Amar'e Stoudemire"     | 'Knicks'        | 0       |
+      | "Amar'e Stoudemire"     | 'Heat'          | 0       |
+      | 'Russell Westbrook'     | 'Thunders'      | 0       |
+      | 'James Harden'          | 'Thunders'      | 0       |
+      | 'James Harden'          | 'Rockets'       | 0       |
+      | 'Kobe Bryant'           | 'Lakers'        | 0       |
+      | 'Tracy McGrady'         | 'Raptors'       | 0       |
+      | 'Tracy McGrady'         | 'Magic'         | 0       |
+      | 'Tracy McGrady'         | 'Rockets'       | 0       |
+      | 'Tracy McGrady'         | 'Spurs'         | 0       |
+      | 'Chris Paul'            | 'Hornets'       | 0       |
+      | 'Chris Paul'            | 'Clippers'      | 0       |
+      | 'Chris Paul'            | 'Rockets'       | 0       |
+      | 'Boris Diaw'            | 'Hawks'         | 0       |
+      | 'Boris Diaw'            | 'Suns'          | 0       |
+      | 'Boris Diaw'            | 'Hornets'       | 0       |
+      | 'Boris Diaw'            | 'Spurs'         | 0       |
+      | 'Boris Diaw'            | 'Jazz'          | 0       |
+      | 'LeBron James'          | 'Cavaliers'     | 0       |
+      | 'LeBron James'          | 'Heat'          | 0       |
+      | 'LeBron James'          | 'Cavaliers'     | 1       |
+      | 'LeBron James'          | 'Lakers'        | 0       |
+      | 'Klay Thompson'         | 'Warriors'      | 0       |
+      | 'Kristaps Porzingis'    | 'Knicks'        | 0       |
+      | 'Kristaps Porzingis'    | 'Mavericks'     | 0       |
+      | 'Jonathon Simmons'      | 'Spurs'         | 0       |
+      | 'Jonathon Simmons'      | 'Magic'         | 0       |
+      | 'Jonathon Simmons'      | '76ers'         | 0       |
+      | 'Marco Belinelli'       | 'Warriors'      | 0       |
+      | 'Marco Belinelli'       | 'Raptors'       | 0       |
+      | 'Marco Belinelli'       | 'Hornets'       | 0       |
+      | 'Marco Belinelli'       | 'Bulls'         | 0       |
+      | 'Marco Belinelli'       | 'Spurs'         | 0       |
+      | 'Marco Belinelli'       | 'Kings'         | 0       |
+      | 'Marco Belinelli'       | 'Hornets'       | 1       |
+      | 'Marco Belinelli'       | 'Hawks'         | 0       |
+      | 'Marco Belinelli'       | '76ers'         | 0       |
+      | 'Marco Belinelli'       | 'Spurs'         | 1       |
+      | 'Luka Doncic'           | 'Mavericks'     | 0       |
+      | 'David West'            | 'Hornets'       | 0       |
+      | 'David West'            | 'Pacers'        | 0       |
+      | 'David West'            | 'Spurs'         | 0       |
+      | 'David West'            | 'Warriors'      | 0       |
+      | 'Tony Parker'           | 'Spurs'         | 0       |
+      | 'Tony Parker'           | 'Hornets'       | 0       |
+      | 'Danny Green'           | 'Cavaliers'     | 0       |
+      | 'Danny Green'           | 'Spurs'         | 0       |
+      | 'Danny Green'           | 'Raptors'       | 0       |
+      | 'Rudy Gay'              | 'Grizzlies'     | 0       |
+      | 'Rudy Gay'              | 'Raptors'       | 0       |
+      | 'Rudy Gay'              | 'Kings'         | 0       |
+      | 'Rudy Gay'              | 'Spurs'         | 0       |
+      | 'LaMarcus Aldridge'     | 'Trail Blazers' | 0       |
+      | 'LaMarcus Aldridge'     | 'Spurs'         | 0       |
+      | 'Tim Duncan'            | 'Spurs'         | 0       |
+      | 'Kevin Durant'          | 'Thunders'      | 0       |
+      | 'Kevin Durant'          | 'Warriors'      | 0       |
+      | 'Stephen Curry'         | 'Warriors'      | 0       |
+      | 'Ray Allen'             | 'Bucks'         | 0       |
+      | 'Ray Allen'             | 'Thunders'      | 0       |
+      | 'Ray Allen'             | 'Celtics'       | 0       |
+      | 'Ray Allen'             | 'Heat'          | 0       |
+      | 'Tiago Splitter'        | 'Spurs'         | 0       |
+      | 'Tiago Splitter'        | 'Hawks'         | 0       |
+      | 'Tiago Splitter'        | '76ers'         | 0       |
+      | 'DeAndre Jordan'        | 'Clippers'      | 0       |
+      | 'DeAndre Jordan'        | 'Mavericks'     | 0       |
+      | 'DeAndre Jordan'        | 'Knicks'        | 0       |
+      | 'Paul Gasol'            | 'Grizzlies'     | 0       |
+      | 'Paul Gasol'            | 'Lakers'        | 0       |
+      | 'Paul Gasol'            | 'Bulls'         | 0       |
+      | 'Paul Gasol'            | 'Spurs'         | 0       |
+      | 'Paul Gasol'            | 'Bucks'         | 0       |
+      | 'Aron Baynes'           | 'Spurs'         | 0       |
+      | 'Aron Baynes'           | 'Pistons'       | 0       |
+      | 'Aron Baynes'           | 'Celtics'       | 0       |
+      | 'Cory Joseph'           | 'Spurs'         | 0       |
+      | 'Cory Joseph'           | 'Raptors'       | 0       |
+      | 'Cory Joseph'           | 'Pacers'        | 0       |
+      | 'Vince Carter'          | 'Raptors'       | 0       |
+      | 'Vince Carter'          | 'Nets'          | 0       |
+      | 'Vince Carter'          | 'Magic'         | 0       |
+      | 'Vince Carter'          | 'Suns'          | 0       |
+      | 'Vince Carter'          | 'Mavericks'     | 0       |
+      | 'Vince Carter'          | 'Grizzlies'     | 0       |
+      | 'Vince Carter'          | 'Kings'         | 0       |
+      | 'Vince Carter'          | 'Hawks'         | 0       |
+      | 'Marc Gasol'            | 'Grizzlies'     | 0       |
+      | 'Marc Gasol'            | 'Raptors'       | 0       |
+      | 'Ricky Rubio'           | 'Timberwolves'  | 0       |
+      | 'Ricky Rubio'           | 'Jazz'          | 0       |
+      | 'Ben Simmons'           | '76ers'         | 0       |
+      | 'Giannis Antetokounmpo' | 'Bucks'         | 0       |
+      | 'Rajon Rondo'           | 'Celtics'       | 0       |
+      | 'Rajon Rondo'           | 'Mavericks'     | 0       |
+      | 'Rajon Rondo'           | 'Kings'         | 0       |
+      | 'Rajon Rondo'           | 'Bulls'         | 0       |
+      | 'Rajon Rondo'           | 'Pelicans'      | 0       |
+      | 'Rajon Rondo'           | 'Lakers'        | 0       |
+      | 'Manu Ginobili'         | 'Spurs'         | 0       |
+      | 'Kyrie Irving'          | 'Cavaliers'     | 0       |
+      | 'Kyrie Irving'          | 'Celtics'       | 0       |
+      | 'Carmelo Anthony'       | 'Nuggets'       | 0       |
+      | 'Carmelo Anthony'       | 'Knicks'        | 0       |
+      | 'Carmelo Anthony'       | 'Thunders'      | 0       |
+      | 'Carmelo Anthony'       | 'Rockets'       | 0       |
+      | 'Dwyane Wade'           | 'Heat'          | 0       |
+      | 'Dwyane Wade'           | 'Bulls'         | 0       |
+      | 'Dwyane Wade'           | 'Cavaliers'     | 0       |
+      | 'Dwyane Wade'           | 'Heat'          | 1       |
+      | 'Joel Embiid'           | '76ers'         | 0       |
+      | 'Damian Lillard'        | 'Trail Blazers' | 0       |
+      | 'Yao Ming'              | 'Rockets'       | 0       |
+      | 'Kyle Anderson'         | 'Spurs'         | 0       |
+      | 'Kyle Anderson'         | 'Grizzlies'     | 0       |
+      | 'Dejounte Murray'       | 'Spurs'         | 0       |
+      | 'Blake Griffin'         | 'Clippers'      | 0       |
+      | 'Blake Griffin'         | 'Pistons'       | 0       |
+      | 'Steve Nash'            | 'Suns'          | 0       |
+      | 'Steve Nash'            | 'Mavericks'     | 0       |
+      | 'Steve Nash'            | 'Suns'          | 1       |
+      | 'Steve Nash'            | 'Lakers'        | 0       |
+      | 'Jason Kidd'            | 'Mavericks'     | 0       |
+      | 'Jason Kidd'            | 'Suns'          | 0       |
+      | 'Jason Kidd'            | 'Nets'          | 0       |
+      | 'Jason Kidd'            | 'Mavericks'     | 1       |
+      | 'Jason Kidd'            | 'Knicks'        | 0       |
+      | 'Dirk Nowitzki'         | 'Mavericks'     | 0       |
+      | 'Paul George'           | 'Pacers'        | 0       |
+      | 'Paul George'           | 'Thunders'      | 0       |
+      | 'Grant Hill'            | 'Pistons'       | 0       |
+      | 'Grant Hill'            | 'Magic'         | 0       |
+      | 'Grant Hill'            | 'Suns'          | 0       |
+      | 'Grant Hill'            | 'Clippers'      | 0       |
+      | "Shaquile O'Neal"       | 'Magic'         | 0       |
+      | "Shaquile O'Neal"       | 'Lakers'        | 0       |
+      | "Shaquile O'Neal"       | 'Heat'          | 0       |
+      | "Shaquile O'Neal"       | 'Suns'          | 0       |
+      | "Shaquile O'Neal"       | 'Cavaliers'     | 0       |
+      | "Shaquile O'Neal"       | 'Celtics'       | 0       |
+      | 'JaVale McGee'          | 'Wizards'       | 0       |
+      | 'JaVale McGee'          | 'Nuggets'       | 0       |
+      | 'JaVale McGee'          | 'Mavericks'     | 0       |
+      | 'JaVale McGee'          | 'Warriors'      | 0       |
+      | 'JaVale McGee'          | 'Lakers'        | 0       |
+      | 'Dwight Howard'         | 'Magic'         | 0       |
+      | 'Dwight Howard'         | 'Lakers'        | 0       |
+      | 'Dwight Howard'         | 'Rockets'       | 0       |
+      | 'Dwight Howard'         | 'Hawks'         | 0       |
+      | 'Dwight Howard'         | 'Hornets'       | 0       |
+      | 'Dwight Howard'         | 'Wizards'       | 0       |
     When executing query:
       """
       LOOKUP ON serve YIELD serve.start_year AS startYear
       """
-    Then the result should be, in any order:
-      | SrcVID                        | DstVID                | Ranking | startYear |
-      | hash("Amar'e Stoudemire")     | hash('Suns')          | 0       | 2002      |
-      | hash("Amar'e Stoudemire")     | hash('Knicks')        | 0       | 2010      |
-      | hash("Amar'e Stoudemire")     | hash('Heat')          | 0       | 2015      |
-      | hash('Russell Westbrook')     | hash('Thunders')      | 0       | 2008      |
-      | hash('James Harden')          | hash('Thunders')      | 0       | 2009      |
-      | hash('James Harden')          | hash('Rockets')       | 0       | 2012      |
-      | hash('Kobe Bryant')           | hash('Lakers')        | 0       | 1996      |
-      | hash('Tracy McGrady')         | hash('Raptors')       | 0       | 1997      |
-      | hash('Tracy McGrady')         | hash('Magic')         | 0       | 2000      |
-      | hash('Tracy McGrady')         | hash('Rockets')       | 0       | 2004      |
-      | hash('Tracy McGrady')         | hash('Spurs')         | 0       | 2013      |
-      | hash('Chris Paul')            | hash('Hornets')       | 0       | 2005      |
-      | hash('Chris Paul')            | hash('Clippers')      | 0       | 2011      |
-      | hash('Chris Paul')            | hash('Rockets')       | 0       | 2017      |
-      | hash('Boris Diaw')            | hash('Hawks')         | 0       | 2003      |
-      | hash('Boris Diaw')            | hash('Suns')          | 0       | 2005      |
-      | hash('Boris Diaw')            | hash('Hornets')       | 0       | 2008      |
-      | hash('Boris Diaw')            | hash('Spurs')         | 0       | 2012      |
-      | hash('Boris Diaw')            | hash('Jazz')          | 0       | 2016      |
-      | hash('LeBron James')          | hash('Cavaliers')     | 0       | 2003      |
-      | hash('LeBron James')          | hash('Heat')          | 0       | 2010      |
-      | hash('LeBron James')          | hash('Cavaliers')     | 1       | 2014      |
-      | hash('LeBron James')          | hash('Lakers')        | 0       | 2018      |
-      | hash('Klay Thompson')         | hash('Warriors')      | 0       | 2011      |
-      | hash('Kristaps Porzingis')    | hash('Knicks')        | 0       | 2015      |
-      | hash('Kristaps Porzingis')    | hash('Mavericks')     | 0       | 2019      |
-      | hash('Jonathon Simmons')      | hash('Spurs')         | 0       | 2015      |
-      | hash('Jonathon Simmons')      | hash('Magic')         | 0       | 2017      |
-      | hash('Jonathon Simmons')      | hash('76ers')         | 0       | 2019      |
-      | hash('Marco Belinelli')       | hash('Warriors')      | 0       | 2007      |
-      | hash('Marco Belinelli')       | hash('Raptors')       | 0       | 2009      |
-      | hash('Marco Belinelli')       | hash('Hornets')       | 0       | 2010      |
-      | hash('Marco Belinelli')       | hash('Bulls')         | 0       | 2012      |
-      | hash('Marco Belinelli')       | hash('Spurs')         | 0       | 2013      |
-      | hash('Marco Belinelli')       | hash('Kings')         | 0       | 2015      |
-      | hash('Marco Belinelli')       | hash('Hornets')       | 1       | 2016      |
-      | hash('Marco Belinelli')       | hash('Hawks')         | 0       | 2017      |
-      | hash('Marco Belinelli')       | hash('76ers')         | 0       | 2018      |
-      | hash('Marco Belinelli')       | hash('Spurs')         | 1       | 2018      |
-      | hash('Luka Doncic')           | hash('Mavericks')     | 0       | 2018      |
-      | hash('David West')            | hash('Hornets')       | 0       | 2003      |
-      | hash('David West')            | hash('Pacers')        | 0       | 2011      |
-      | hash('David West')            | hash('Spurs')         | 0       | 2015      |
-      | hash('David West')            | hash('Warriors')      | 0       | 2016      |
-      | hash('Tony Parker')           | hash('Spurs')         | 0       | 1999      |
-      | hash('Tony Parker')           | hash('Hornets')       | 0       | 2018      |
-      | hash('Danny Green')           | hash('Cavaliers')     | 0       | 2009      |
-      | hash('Danny Green')           | hash('Spurs')         | 0       | 2010      |
-      | hash('Danny Green')           | hash('Raptors')       | 0       | 2018      |
-      | hash('Rudy Gay')              | hash('Grizzlies')     | 0       | 2006      |
-      | hash('Rudy Gay')              | hash('Raptors')       | 0       | 2013      |
-      | hash('Rudy Gay')              | hash('Kings')         | 0       | 2013      |
-      | hash('Rudy Gay')              | hash('Spurs')         | 0       | 2017      |
-      | hash('LaMarcus Aldridge')     | hash('Trail Blazers') | 0       | 2006      |
-      | hash('LaMarcus Aldridge')     | hash('Spurs')         | 0       | 2015      |
-      | hash('Tim Duncan')            | hash('Spurs')         | 0       | 1997      |
-      | hash('Kevin Durant')          | hash('Thunders')      | 0       | 2007      |
-      | hash('Kevin Durant')          | hash('Warriors')      | 0       | 2016      |
-      | hash('Stephen Curry')         | hash('Warriors')      | 0       | 2009      |
-      | hash('Ray Allen')             | hash('Bucks')         | 0       | 1996      |
-      | hash('Ray Allen')             | hash('Thunders')      | 0       | 2003      |
-      | hash('Ray Allen')             | hash('Celtics')       | 0       | 2007      |
-      | hash('Ray Allen')             | hash('Heat')          | 0       | 2012      |
-      | hash('Tiago Splitter')        | hash('Spurs')         | 0       | 2010      |
-      | hash('Tiago Splitter')        | hash('Hawks')         | 0       | 2015      |
-      | hash('Tiago Splitter')        | hash('76ers')         | 0       | 2017      |
-      | hash('DeAndre Jordan')        | hash('Clippers')      | 0       | 2008      |
-      | hash('DeAndre Jordan')        | hash('Mavericks')     | 0       | 2018      |
-      | hash('DeAndre Jordan')        | hash('Knicks')        | 0       | 2019      |
-      | hash('Paul Gasol')            | hash('Grizzlies')     | 0       | 2001      |
-      | hash('Paul Gasol')            | hash('Lakers')        | 0       | 2008      |
-      | hash('Paul Gasol')            | hash('Bulls')         | 0       | 2014      |
-      | hash('Paul Gasol')            | hash('Spurs')         | 0       | 2016      |
-      | hash('Paul Gasol')            | hash('Bucks')         | 0       | 2019      |
-      | hash('Aron Baynes')           | hash('Spurs')         | 0       | 2013      |
-      | hash('Aron Baynes')           | hash('Pistons')       | 0       | 2015      |
-      | hash('Aron Baynes')           | hash('Celtics')       | 0       | 2017      |
-      | hash('Cory Joseph')           | hash('Spurs')         | 0       | 2011      |
-      | hash('Cory Joseph')           | hash('Raptors')       | 0       | 2015      |
-      | hash('Cory Joseph')           | hash('Pacers')        | 0       | 2017      |
-      | hash('Vince Carter')          | hash('Raptors')       | 0       | 1998      |
-      | hash('Vince Carter')          | hash('Nets')          | 0       | 2004      |
-      | hash('Vince Carter')          | hash('Magic')         | 0       | 2009      |
-      | hash('Vince Carter')          | hash('Suns')          | 0       | 2010      |
-      | hash('Vince Carter')          | hash('Mavericks')     | 0       | 2011      |
-      | hash('Vince Carter')          | hash('Grizzlies')     | 0       | 2014      |
-      | hash('Vince Carter')          | hash('Kings')         | 0       | 2017      |
-      | hash('Vince Carter')          | hash('Hawks')         | 0       | 2018      |
-      | hash('Marc Gasol')            | hash('Grizzlies')     | 0       | 2008      |
-      | hash('Marc Gasol')            | hash('Raptors')       | 0       | 2019      |
-      | hash('Ricky Rubio')           | hash('Timberwolves')  | 0       | 2011      |
-      | hash('Ricky Rubio')           | hash('Jazz')          | 0       | 2017      |
-      | hash('Ben Simmons')           | hash('76ers')         | 0       | 2016      |
-      | hash('Giannis Antetokounmpo') | hash('Bucks')         | 0       | 2013      |
-      | hash('Rajon Rondo')           | hash('Celtics')       | 0       | 2006      |
-      | hash('Rajon Rondo')           | hash('Mavericks')     | 0       | 2014      |
-      | hash('Rajon Rondo')           | hash('Kings')         | 0       | 2015      |
-      | hash('Rajon Rondo')           | hash('Bulls')         | 0       | 2016      |
-      | hash('Rajon Rondo')           | hash('Pelicans')      | 0       | 2017      |
-      | hash('Rajon Rondo')           | hash('Lakers')        | 0       | 2018      |
-      | hash('Manu Ginobili')         | hash('Spurs')         | 0       | 2002      |
-      | hash('Kyrie Irving')          | hash('Cavaliers')     | 0       | 2011      |
-      | hash('Kyrie Irving')          | hash('Celtics')       | 0       | 2017      |
-      | hash('Carmelo Anthony')       | hash('Nuggets')       | 0       | 2003      |
-      | hash('Carmelo Anthony')       | hash('Knicks')        | 0       | 2011      |
-      | hash('Carmelo Anthony')       | hash('Thunders')      | 0       | 2017      |
-      | hash('Carmelo Anthony')       | hash('Rockets')       | 0       | 2018      |
-      | hash('Dwyane Wade')           | hash('Heat')          | 0       | 2003      |
-      | hash('Dwyane Wade')           | hash('Bulls')         | 0       | 2016      |
-      | hash('Dwyane Wade')           | hash('Cavaliers')     | 0       | 2017      |
-      | hash('Dwyane Wade')           | hash('Heat')          | 1       | 2018      |
-      | hash('Joel Embiid')           | hash('76ers')         | 0       | 2014      |
-      | hash('Damian Lillard')        | hash('Trail Blazers') | 0       | 2012      |
-      | hash('Yao Ming')              | hash('Rockets')       | 0       | 2002      |
-      | hash('Kyle Anderson')         | hash('Spurs')         | 0       | 2014      |
-      | hash('Kyle Anderson')         | hash('Grizzlies')     | 0       | 2018      |
-      | hash('Dejounte Murray')       | hash('Spurs')         | 0       | 2016      |
-      | hash('Blake Griffin')         | hash('Clippers')      | 0       | 2009      |
-      | hash('Blake Griffin')         | hash('Pistons')       | 0       | 2018      |
-      | hash('Steve Nash')            | hash('Suns')          | 0       | 1996      |
-      | hash('Steve Nash')            | hash('Mavericks')     | 0       | 1998      |
-      | hash('Steve Nash')            | hash('Suns')          | 1       | 2004      |
-      | hash('Steve Nash')            | hash('Lakers')        | 0       | 2012      |
-      | hash('Jason Kidd')            | hash('Mavericks')     | 0       | 1994      |
-      | hash('Jason Kidd')            | hash('Suns')          | 0       | 1996      |
-      | hash('Jason Kidd')            | hash('Nets')          | 0       | 2001      |
-      | hash('Jason Kidd')            | hash('Mavericks')     | 1       | 2008      |
-      | hash('Jason Kidd')            | hash('Knicks')        | 0       | 2012      |
-      | hash('Dirk Nowitzki')         | hash('Mavericks')     | 0       | 1998      |
-      | hash('Paul George')           | hash('Pacers')        | 0       | 2010      |
-      | hash('Paul George')           | hash('Thunders')      | 0       | 2017      |
-      | hash('Grant Hill')            | hash('Pistons')       | 0       | 1994      |
-      | hash('Grant Hill')            | hash('Magic')         | 0       | 2000      |
-      | hash('Grant Hill')            | hash('Suns')          | 0       | 2007      |
-      | hash('Grant Hill')            | hash('Clippers')      | 0       | 2012      |
-      | hash("Shaquile O'Neal")       | hash('Magic')         | 0       | 1992      |
-      | hash("Shaquile O'Neal")       | hash('Lakers')        | 0       | 1996      |
-      | hash("Shaquile O'Neal")       | hash('Heat')          | 0       | 2004      |
-      | hash("Shaquile O'Neal")       | hash('Suns')          | 0       | 2008      |
-      | hash("Shaquile O'Neal")       | hash('Cavaliers')     | 0       | 2009      |
-      | hash("Shaquile O'Neal")       | hash('Celtics')       | 0       | 2010      |
-      | hash('JaVale McGee')          | hash('Wizards')       | 0       | 2008      |
-      | hash('JaVale McGee')          | hash('Nuggets')       | 0       | 2012      |
-      | hash('JaVale McGee')          | hash('Mavericks')     | 0       | 2015      |
-      | hash('JaVale McGee')          | hash('Warriors')      | 0       | 2016      |
-      | hash('JaVale McGee')          | hash('Lakers')        | 0       | 2018      |
-      | hash('Dwight Howard')         | hash('Magic')         | 0       | 2004      |
-      | hash('Dwight Howard')         | hash('Lakers')        | 0       | 2012      |
-      | hash('Dwight Howard')         | hash('Rockets')       | 0       | 2013      |
-      | hash('Dwight Howard')         | hash('Hawks')         | 0       | 2016      |
-      | hash('Dwight Howard')         | hash('Hornets')       | 0       | 2017      |
-      | hash('Dwight Howard')         | hash('Wizards')       | 0       | 2018      |
+    Then the result should be, in any order, and the columns 0,1 should be hashed:
+      | SrcVID                  | DstVID          | Ranking | startYear |
+      | "Amar'e Stoudemire"     | 'Suns'          | 0       | 2002      |
+      | "Amar'e Stoudemire"     | 'Knicks'        | 0       | 2010      |
+      | "Amar'e Stoudemire"     | 'Heat'          | 0       | 2015      |
+      | 'Russell Westbrook'     | 'Thunders'      | 0       | 2008      |
+      | 'James Harden'          | 'Thunders'      | 0       | 2009      |
+      | 'James Harden'          | 'Rockets'       | 0       | 2012      |
+      | 'Kobe Bryant'           | 'Lakers'        | 0       | 1996      |
+      | 'Tracy McGrady'         | 'Raptors'       | 0       | 1997      |
+      | 'Tracy McGrady'         | 'Magic'         | 0       | 2000      |
+      | 'Tracy McGrady'         | 'Rockets'       | 0       | 2004      |
+      | 'Tracy McGrady'         | 'Spurs'         | 0       | 2013      |
+      | 'Chris Paul'            | 'Hornets'       | 0       | 2005      |
+      | 'Chris Paul'            | 'Clippers'      | 0       | 2011      |
+      | 'Chris Paul'            | 'Rockets'       | 0       | 2017      |
+      | 'Boris Diaw'            | 'Hawks'         | 0       | 2003      |
+      | 'Boris Diaw'            | 'Suns'          | 0       | 2005      |
+      | 'Boris Diaw'            | 'Hornets'       | 0       | 2008      |
+      | 'Boris Diaw'            | 'Spurs'         | 0       | 2012      |
+      | 'Boris Diaw'            | 'Jazz'          | 0       | 2016      |
+      | 'LeBron James'          | 'Cavaliers'     | 0       | 2003      |
+      | 'LeBron James'          | 'Heat'          | 0       | 2010      |
+      | 'LeBron James'          | 'Cavaliers'     | 1       | 2014      |
+      | 'LeBron James'          | 'Lakers'        | 0       | 2018      |
+      | 'Klay Thompson'         | 'Warriors'      | 0       | 2011      |
+      | 'Kristaps Porzingis'    | 'Knicks'        | 0       | 2015      |
+      | 'Kristaps Porzingis'    | 'Mavericks'     | 0       | 2019      |
+      | 'Jonathon Simmons'      | 'Spurs'         | 0       | 2015      |
+      | 'Jonathon Simmons'      | 'Magic'         | 0       | 2017      |
+      | 'Jonathon Simmons'      | '76ers'         | 0       | 2019      |
+      | 'Marco Belinelli'       | 'Warriors'      | 0       | 2007      |
+      | 'Marco Belinelli'       | 'Raptors'       | 0       | 2009      |
+      | 'Marco Belinelli'       | 'Hornets'       | 0       | 2010      |
+      | 'Marco Belinelli'       | 'Bulls'         | 0       | 2012      |
+      | 'Marco Belinelli'       | 'Spurs'         | 0       | 2013      |
+      | 'Marco Belinelli'       | 'Kings'         | 0       | 2015      |
+      | 'Marco Belinelli'       | 'Hornets'       | 1       | 2016      |
+      | 'Marco Belinelli'       | 'Hawks'         | 0       | 2017      |
+      | 'Marco Belinelli'       | '76ers'         | 0       | 2018      |
+      | 'Marco Belinelli'       | 'Spurs'         | 1       | 2018      |
+      | 'Luka Doncic'           | 'Mavericks'     | 0       | 2018      |
+      | 'David West'            | 'Hornets'       | 0       | 2003      |
+      | 'David West'            | 'Pacers'        | 0       | 2011      |
+      | 'David West'            | 'Spurs'         | 0       | 2015      |
+      | 'David West'            | 'Warriors'      | 0       | 2016      |
+      | 'Tony Parker'           | 'Spurs'         | 0       | 1999      |
+      | 'Tony Parker'           | 'Hornets'       | 0       | 2018      |
+      | 'Danny Green'           | 'Cavaliers'     | 0       | 2009      |
+      | 'Danny Green'           | 'Spurs'         | 0       | 2010      |
+      | 'Danny Green'           | 'Raptors'       | 0       | 2018      |
+      | 'Rudy Gay'              | 'Grizzlies'     | 0       | 2006      |
+      | 'Rudy Gay'              | 'Raptors'       | 0       | 2013      |
+      | 'Rudy Gay'              | 'Kings'         | 0       | 2013      |
+      | 'Rudy Gay'              | 'Spurs'         | 0       | 2017      |
+      | 'LaMarcus Aldridge'     | 'Trail Blazers' | 0       | 2006      |
+      | 'LaMarcus Aldridge'     | 'Spurs'         | 0       | 2015      |
+      | 'Tim Duncan'            | 'Spurs'         | 0       | 1997      |
+      | 'Kevin Durant'          | 'Thunders'      | 0       | 2007      |
+      | 'Kevin Durant'          | 'Warriors'      | 0       | 2016      |
+      | 'Stephen Curry'         | 'Warriors'      | 0       | 2009      |
+      | 'Ray Allen'             | 'Bucks'         | 0       | 1996      |
+      | 'Ray Allen'             | 'Thunders'      | 0       | 2003      |
+      | 'Ray Allen'             | 'Celtics'       | 0       | 2007      |
+      | 'Ray Allen'             | 'Heat'          | 0       | 2012      |
+      | 'Tiago Splitter'        | 'Spurs'         | 0       | 2010      |
+      | 'Tiago Splitter'        | 'Hawks'         | 0       | 2015      |
+      | 'Tiago Splitter'        | '76ers'         | 0       | 2017      |
+      | 'DeAndre Jordan'        | 'Clippers'      | 0       | 2008      |
+      | 'DeAndre Jordan'        | 'Mavericks'     | 0       | 2018      |
+      | 'DeAndre Jordan'        | 'Knicks'        | 0       | 2019      |
+      | 'Paul Gasol'            | 'Grizzlies'     | 0       | 2001      |
+      | 'Paul Gasol'            | 'Lakers'        | 0       | 2008      |
+      | 'Paul Gasol'            | 'Bulls'         | 0       | 2014      |
+      | 'Paul Gasol'            | 'Spurs'         | 0       | 2016      |
+      | 'Paul Gasol'            | 'Bucks'         | 0       | 2019      |
+      | 'Aron Baynes'           | 'Spurs'         | 0       | 2013      |
+      | 'Aron Baynes'           | 'Pistons'       | 0       | 2015      |
+      | 'Aron Baynes'           | 'Celtics'       | 0       | 2017      |
+      | 'Cory Joseph'           | 'Spurs'         | 0       | 2011      |
+      | 'Cory Joseph'           | 'Raptors'       | 0       | 2015      |
+      | 'Cory Joseph'           | 'Pacers'        | 0       | 2017      |
+      | 'Vince Carter'          | 'Raptors'       | 0       | 1998      |
+      | 'Vince Carter'          | 'Nets'          | 0       | 2004      |
+      | 'Vince Carter'          | 'Magic'         | 0       | 2009      |
+      | 'Vince Carter'          | 'Suns'          | 0       | 2010      |
+      | 'Vince Carter'          | 'Mavericks'     | 0       | 2011      |
+      | 'Vince Carter'          | 'Grizzlies'     | 0       | 2014      |
+      | 'Vince Carter'          | 'Kings'         | 0       | 2017      |
+      | 'Vince Carter'          | 'Hawks'         | 0       | 2018      |
+      | 'Marc Gasol'            | 'Grizzlies'     | 0       | 2008      |
+      | 'Marc Gasol'            | 'Raptors'       | 0       | 2019      |
+      | 'Ricky Rubio'           | 'Timberwolves'  | 0       | 2011      |
+      | 'Ricky Rubio'           | 'Jazz'          | 0       | 2017      |
+      | 'Ben Simmons'           | '76ers'         | 0       | 2016      |
+      | 'Giannis Antetokounmpo' | 'Bucks'         | 0       | 2013      |
+      | 'Rajon Rondo'           | 'Celtics'       | 0       | 2006      |
+      | 'Rajon Rondo'           | 'Mavericks'     | 0       | 2014      |
+      | 'Rajon Rondo'           | 'Kings'         | 0       | 2015      |
+      | 'Rajon Rondo'           | 'Bulls'         | 0       | 2016      |
+      | 'Rajon Rondo'           | 'Pelicans'      | 0       | 2017      |
+      | 'Rajon Rondo'           | 'Lakers'        | 0       | 2018      |
+      | 'Manu Ginobili'         | 'Spurs'         | 0       | 2002      |
+      | 'Kyrie Irving'          | 'Cavaliers'     | 0       | 2011      |
+      | 'Kyrie Irving'          | 'Celtics'       | 0       | 2017      |
+      | 'Carmelo Anthony'       | 'Nuggets'       | 0       | 2003      |
+      | 'Carmelo Anthony'       | 'Knicks'        | 0       | 2011      |
+      | 'Carmelo Anthony'       | 'Thunders'      | 0       | 2017      |
+      | 'Carmelo Anthony'       | 'Rockets'       | 0       | 2018      |
+      | 'Dwyane Wade'           | 'Heat'          | 0       | 2003      |
+      | 'Dwyane Wade'           | 'Bulls'         | 0       | 2016      |
+      | 'Dwyane Wade'           | 'Cavaliers'     | 0       | 2017      |
+      | 'Dwyane Wade'           | 'Heat'          | 1       | 2018      |
+      | 'Joel Embiid'           | '76ers'         | 0       | 2014      |
+      | 'Damian Lillard'        | 'Trail Blazers' | 0       | 2012      |
+      | 'Yao Ming'              | 'Rockets'       | 0       | 2002      |
+      | 'Kyle Anderson'         | 'Spurs'         | 0       | 2014      |
+      | 'Kyle Anderson'         | 'Grizzlies'     | 0       | 2018      |
+      | 'Dejounte Murray'       | 'Spurs'         | 0       | 2016      |
+      | 'Blake Griffin'         | 'Clippers'      | 0       | 2009      |
+      | 'Blake Griffin'         | 'Pistons'       | 0       | 2018      |
+      | 'Steve Nash'            | 'Suns'          | 0       | 1996      |
+      | 'Steve Nash'            | 'Mavericks'     | 0       | 1998      |
+      | 'Steve Nash'            | 'Suns'          | 1       | 2004      |
+      | 'Steve Nash'            | 'Lakers'        | 0       | 2012      |
+      | 'Jason Kidd'            | 'Mavericks'     | 0       | 1994      |
+      | 'Jason Kidd'            | 'Suns'          | 0       | 1996      |
+      | 'Jason Kidd'            | 'Nets'          | 0       | 2001      |
+      | 'Jason Kidd'            | 'Mavericks'     | 1       | 2008      |
+      | 'Jason Kidd'            | 'Knicks'        | 0       | 2012      |
+      | 'Dirk Nowitzki'         | 'Mavericks'     | 0       | 1998      |
+      | 'Paul George'           | 'Pacers'        | 0       | 2010      |
+      | 'Paul George'           | 'Thunders'      | 0       | 2017      |
+      | 'Grant Hill'            | 'Pistons'       | 0       | 1994      |
+      | 'Grant Hill'            | 'Magic'         | 0       | 2000      |
+      | 'Grant Hill'            | 'Suns'          | 0       | 2007      |
+      | 'Grant Hill'            | 'Clippers'      | 0       | 2012      |
+      | "Shaquile O'Neal"       | 'Magic'         | 0       | 1992      |
+      | "Shaquile O'Neal"       | 'Lakers'        | 0       | 1996      |
+      | "Shaquile O'Neal"       | 'Heat'          | 0       | 2004      |
+      | "Shaquile O'Neal"       | 'Suns'          | 0       | 2008      |
+      | "Shaquile O'Neal"       | 'Cavaliers'     | 0       | 2009      |
+      | "Shaquile O'Neal"       | 'Celtics'       | 0       | 2010      |
+      | 'JaVale McGee'          | 'Wizards'       | 0       | 2008      |
+      | 'JaVale McGee'          | 'Nuggets'       | 0       | 2012      |
+      | 'JaVale McGee'          | 'Mavericks'     | 0       | 2015      |
+      | 'JaVale McGee'          | 'Warriors'      | 0       | 2016      |
+      | 'JaVale McGee'          | 'Lakers'        | 0       | 2018      |
+      | 'Dwight Howard'         | 'Magic'         | 0       | 2004      |
+      | 'Dwight Howard'         | 'Lakers'        | 0       | 2012      |
+      | 'Dwight Howard'         | 'Rockets'       | 0       | 2013      |
+      | 'Dwight Howard'         | 'Hawks'         | 0       | 2016      |
+      | 'Dwight Howard'         | 'Hornets'       | 0       | 2017      |
+      | 'Dwight Howard'         | 'Wizards'       | 0       | 2018      |
 
   Scenario: [2] Edge TODO
     When executing query:
diff --git a/tests/tck/features/lookup/Output.intVid.feature b/tests/tck/features/lookup/Output.intVid.feature
index d8638b3451c2ecf8b19735ecb494154e8a04f38a..a611f033520d8aa67cf75f75ee360d09f09d3f5e 100644
--- a/tests/tck/features/lookup/Output.intVid.feature
+++ b/tests/tck/features/lookup/Output.intVid.feature
@@ -9,10 +9,10 @@ Feature: Lookup with output in integer vid
       LOOKUP ON player WHERE player.age == 40 |
       FETCH PROP ON player $-.VertexID YIELD player.name
       """
-    Then the result should be, in any order:
-      | VertexID              | player.name     |
-      | hash('Kobe Bryant')   | 'Kobe Bryant'   |
-      | hash('Dirk Nowitzki') | 'Dirk Nowitzki' |
+    Then the result should be, in any order, and the columns 0 should be hashed:
+      | VertexID        | player.name     |
+      | 'Kobe Bryant'   | 'Kobe Bryant'   |
+      | 'Dirk Nowitzki' | 'Dirk Nowitzki' |
 
   Scenario: [1] tag ouput with yield rename
     When executing query:
@@ -20,10 +20,10 @@ Feature: Lookup with output in integer vid
       LOOKUP ON player WHERE player.age == 40 YIELD player.name AS name |
       FETCH PROP ON player $-.VertexID YIELD player.name AS name
       """
-    Then the result should be, in any order:
-      | VertexID              | name            |
-      | hash('Kobe Bryant')   | 'Kobe Bryant'   |
-      | hash('Dirk Nowitzki') | 'Dirk Nowitzki' |
+    Then the result should be, in any order, and the columns 0 should be hashed:
+      | VertexID        | name            |
+      | 'Kobe Bryant'   | 'Kobe Bryant'   |
+      | 'Dirk Nowitzki' | 'Dirk Nowitzki' |
 
   Scenario: [1] tag output by var
     When executing query:
@@ -31,10 +31,10 @@ Feature: Lookup with output in integer vid
       $a = LOOKUP ON player WHERE player.age == 40;
       FETCH PROP ON player $a.VertexID YIELD player.name
       """
-    Then the result should be, in any order:
-      | VertexID              | player.name     |
-      | hash('Kobe Bryant')   | 'Kobe Bryant'   |
-      | hash('Dirk Nowitzki') | 'Dirk Nowitzki' |
+    Then the result should be, in any order, and the columns 0 should be hashed:
+      | VertexID        | player.name     |
+      | 'Kobe Bryant'   | 'Kobe Bryant'   |
+      | 'Dirk Nowitzki' | 'Dirk Nowitzki' |
 
   Scenario: [1] tag ouput with yield rename by var
     When executing query:
@@ -42,10 +42,10 @@ Feature: Lookup with output in integer vid
       $a = LOOKUP ON player WHERE player.age == 40 YIELD player.name AS name;
       FETCH PROP ON player $a.VertexID YIELD player.name AS name
       """
-    Then the result should be, in any order:
-      | VertexID              | name            |
-      | hash('Kobe Bryant')   | 'Kobe Bryant'   |
-      | hash('Dirk Nowitzki') | 'Dirk Nowitzki' |
+    Then the result should be, in any order, and the columns 0 should be hashed:
+      | VertexID        | name            |
+      | 'Kobe Bryant'   | 'Kobe Bryant'   |
+      | 'Dirk Nowitzki' | 'Dirk Nowitzki' |
 
   Scenario: [2] edge output
     When executing query:
@@ -54,10 +54,10 @@ Feature: Lookup with output in integer vid
       YIELD serve.start_year |
       FETCH PROP ON serve $-.SrcVID->$-.DstVID YIELD serve.start_year
       """
-    Then the result should be, in any order:
-      | serve._src                | serve._dst        | serve._rank | serve.start_year |
-      | hash('Russell Westbrook') | hash('Thunders')  | 0           | 2008             |
-      | hash('Marc Gasol')        | hash('Grizzlies') | 0           | 2008             |
+    Then the result should be, in any order, and the columns 0,1 should be hashed:
+      | serve._src          | serve._dst  | serve._rank | serve.start_year |
+      | 'Russell Westbrook' | 'Thunders'  | 0           | 2008             |
+      | 'Marc Gasol'        | 'Grizzlies' | 0           | 2008             |
 
   Scenario: [2] edge output with yield rename
     When executing query:
@@ -66,10 +66,10 @@ Feature: Lookup with output in integer vid
       YIELD serve.start_year AS startYear |
       FETCH PROP ON serve $-.SrcVID->$-.DstVID YIELD serve.start_year AS startYear
       """
-    Then the result should be, in any order:
-      | serve._src                | serve._dst        | serve._rank | startYear |
-      | hash('Russell Westbrook') | hash('Thunders')  | 0           | 2008      |
-      | hash('Marc Gasol')        | hash('Grizzlies') | 0           | 2008      |
+    Then the result should be, in any order, and the columns 0,1 should be hashed:
+      | serve._src          | serve._dst  | serve._rank | startYear |
+      | 'Russell Westbrook' | 'Thunders'  | 0           | 2008      |
+      | 'Marc Gasol'        | 'Grizzlies' | 0           | 2008      |
 
   Scenario: [2] edge output by var
     When executing query:
@@ -78,10 +78,10 @@ Feature: Lookup with output in integer vid
       YIELD serve.start_year;
       FETCH PROP ON serve $a.SrcVID->$a.DstVID YIELD serve.start_year
       """
-    Then the result should be, in any order:
-      | serve._src                | serve._dst        | serve._rank | serve.start_year |
-      | hash('Russell Westbrook') | hash('Thunders')  | 0           | 2008             |
-      | hash('Marc Gasol')        | hash('Grizzlies') | 0           | 2008             |
+    Then the result should be, in any order, and the columns 0,1 should be hashed:
+      | serve._src          | serve._dst  | serve._rank | serve.start_year |
+      | 'Russell Westbrook' | 'Thunders'  | 0           | 2008             |
+      | 'Marc Gasol'        | 'Grizzlies' | 0           | 2008             |
 
   Scenario: [2] edge output with yield rename by var
     When executing query:
@@ -90,7 +90,7 @@ Feature: Lookup with output in integer vid
       YIELD serve.start_year AS startYear;
       FETCH PROP ON serve $a.SrcVID->$a.DstVID YIELD serve.start_year AS startYear
       """
-    Then the result should be, in any order:
-      | serve._src                | serve._dst        | serve._rank | startYear |
-      | hash('Russell Westbrook') | hash('Thunders')  | 0           | 2008      |
-      | hash('Marc Gasol')        | hash('Grizzlies') | 0           | 2008      |
+    Then the result should be, in any order, and the columns 0,1 should be hashed:
+      | serve._src          | serve._dst  | serve._rank | startYear |
+      | 'Russell Westbrook' | 'Thunders'  | 0           | 2008      |
+      | 'Marc Gasol'        | 'Grizzlies' | 0           | 2008      |
diff --git a/tests/tck/features/lookup/WithYield.intVid.feature b/tests/tck/features/lookup/WithYield.intVid.feature
index 148efae59325112ee1ab19d62a8ccc339210df0c..78a175a39cae03d6493be2ce6b1098259d087c90 100644
--- a/tests/tck/features/lookup/WithYield.intVid.feature
+++ b/tests/tck/features/lookup/WithYield.intVid.feature
@@ -8,20 +8,20 @@ Feature: Lookup with yield in integer vid
       """
       LOOKUP ON player WHERE player.age == 40 YIELD player.name
       """
-    Then the result should be, in any order:
-      | VertexID              | player.name     |
-      | hash('Kobe Bryant')   | 'Kobe Bryant'   |
-      | hash('Dirk Nowitzki') | 'Dirk Nowitzki' |
+    Then the result should be, in any order, and the columns 0 should be hashed:
+      | VertexID        | player.name     |
+      | 'Kobe Bryant'   | 'Kobe Bryant'   |
+      | 'Dirk Nowitzki' | 'Dirk Nowitzki' |
 
   Scenario: [1] tag with yield rename
     When executing query:
       """
       LOOKUP ON player WHERE player.age == 40 YIELD player.name AS name
       """
-    Then the result should be, in any order:
-      | VertexID              | name            |
-      | hash('Kobe Bryant')   | 'Kobe Bryant'   |
-      | hash('Dirk Nowitzki') | 'Dirk Nowitzki' |
+    Then the result should be, in any order, and the columns 0 should be hashed:
+      | VertexID        | name            |
+      | 'Kobe Bryant'   | 'Kobe Bryant'   |
+      | 'Dirk Nowitzki' | 'Dirk Nowitzki' |
 
   Scenario: [2] edge with yield
     When executing query:
@@ -29,10 +29,10 @@ Feature: Lookup with yield in integer vid
       LOOKUP ON serve WHERE serve.start_year == 2008 and serve.end_year == 2019
       YIELD serve.start_year
       """
-    Then the result should be, in any order:
-      | SrcVID                    | DstVID            | Ranking | serve.start_year |
-      | hash('Russell Westbrook') | hash('Thunders')  | 0       | 2008             |
-      | hash('Marc Gasol')        | hash('Grizzlies') | 0       | 2008             |
+    Then the result should be, in any order, and the columns 0,1 should be hashed:
+      | SrcVID              | DstVID      | Ranking | serve.start_year |
+      | 'Russell Westbrook' | 'Thunders'  | 0       | 2008             |
+      | 'Marc Gasol'        | 'Grizzlies' | 0       | 2008             |
 
   Scenario: [2] edge with yield rename
     When executing query:
@@ -40,7 +40,7 @@ Feature: Lookup with yield in integer vid
       LOOKUP ON serve WHERE serve.start_year == 2008 and serve.end_year == 2019
       YIELD serve.start_year AS startYear
       """
-    Then the result should be, in any order:
-      | SrcVID                    | DstVID            | Ranking | startYear |
-      | hash('Russell Westbrook') | hash('Thunders')  | 0       | 2008      |
-      | hash('Marc Gasol')        | hash('Grizzlies') | 0       | 2008      |
+    Then the result should be, in any order, and the columns 0,1 should be hashed:
+      | SrcVID              | DstVID      | Ranking | startYear |
+      | 'Russell Westbrook' | 'Thunders'  | 0       | 2008      |
+      | 'Marc Gasol'        | 'Grizzlies' | 0       | 2008      |
diff --git a/tests/tck/features/match/MatchById.IntVid.feature b/tests/tck/features/match/MatchById.IntVid.feature
index b709098589bf9c5e0cce15eca4cc5ddd43001a4e..4e388388c274f7791f94e289ca64001520b8de89 100644
--- a/tests/tck/features/match/MatchById.IntVid.feature
+++ b/tests/tck/features/match/MatchById.IntVid.feature
@@ -31,9 +31,9 @@ Feature: Integer Vid Match By Id
       """
       MATCH (n) WHERE id(n) == hash('Tony Parker') RETURN id(n), labels(n)
       """
-    Then the result should be, in any order, with relax comparison:
-      | id(n)               | labels(n)  |
-      | hash('Tony Parker') | ['player'] |
+    Then the result should be, in any order, with relax comparison, and the columns 0 should be hashed:
+      | id(n)         | labels(n)  |
+      | 'Tony Parker' | ['player'] |
     When executing query:
       """
       MATCH (n) WHERE id(n) == hash('not_exist_vertex') RETURN labels(n)
@@ -68,19 +68,19 @@ Feature: Integer Vid Match By Id
       """
       MATCH (n) WHERE id(n) IN [hash('LaMarcus Aldridge'), hash('Tony Parker'), hash('not_exist_vertex')] return id(n)
       """
-    Then the result should be, in any order, with relax comparison:
-      | id(n)                     |
-      | hash("LaMarcus Aldridge") |
-      | hash("Tony Parker")       |
+    Then the result should be, in any order, with relax comparison, and the columns 0 should be hashed:
+      | id(n)               |
+      | "LaMarcus Aldridge" |
+      | "Tony Parker"       |
     When executing query:
       """
       MATCH (n) WHERE id(n) IN [hash('LaMarcus Aldridge'), hash('Tony Parker'), hash('not_exist_vertex')]
       return id(n), `tags`(n)
       """
-    Then the result should be, in any order, with relax comparison:
-      | id(n)                     | tags(n)    |
-      | hash("LaMarcus Aldridge") | ['player'] |
-      | hash("Tony Parker")       | ['player'] |
+    Then the result should be, in any order, with relax comparison, and the columns 0 should be hashed:
+      | id(n)               | tags(n)    |
+      | "LaMarcus Aldridge" | ['player'] |
+      | "Tony Parker"       | ['player'] |
     When executing query:
       """
       MATCH (start)-[e]-(end) WHERE id(start) IN [hash("Paul George"), hash("not_exist_vertex")]
diff --git a/tests/tck/features/match/SeekByTag.intVid.feature b/tests/tck/features/match/SeekByTag.intVid.feature
index f1124631a968e85509aad7b93eb96429d8cd4484..6cb984dbf0d498e9b73f50a1517c4366d8e99fe2 100644
--- a/tests/tck/features/match/SeekByTag.intVid.feature
+++ b/tests/tck/features/match/SeekByTag.intVid.feature
@@ -9,18 +9,18 @@ Feature: Match seek by tag
       MATCH (v:bachelor)
       RETURN id(v) AS vid
       """
-    Then the result should be, in any order:
-      | vid                |
-      | hash('Tim Duncan') |
+    Then the result should be, in any order, and the columns 0 should be hashed:
+      | vid          |
+      | 'Tim Duncan' |
     And no side effects
     When executing query:
       """
       MATCH (v:bachelor)
       RETURN id(v) AS vid, v.age AS age
       """
-    Then the result should be, in any order:
-      | vid                | age |
-      | hash('Tim Duncan') | 42  |
+    Then the result should be, in any order, and the columns 0 should be hashed:
+      | vid          | age |
+      | 'Tim Duncan' | 42  |
     And no side effects
 
   Scenario: seek by tag index
@@ -29,76 +29,76 @@ Feature: Match seek by tag
       MATCH (v:team)
       RETURN id(v)
       """
-    Then the result should be, in any order:
-      | id(v)                 |
-      | hash('Nets')          |
-      | hash('Pistons')       |
-      | hash('Bucks')         |
-      | hash('Mavericks')     |
-      | hash('Clippers')      |
-      | hash('Thunders')      |
-      | hash('Lakers')        |
-      | hash('Jazz')          |
-      | hash('Nuggets')       |
-      | hash('Wizards')       |
-      | hash('Pacers')        |
-      | hash('Timberwolves')  |
-      | hash('Hawks')         |
-      | hash('Warriors')      |
-      | hash('Magic')         |
-      | hash('Rockets')       |
-      | hash('Pelicans')      |
-      | hash('Raptors')       |
-      | hash('Spurs')         |
-      | hash('Heat')          |
-      | hash('Grizzlies')     |
-      | hash('Knicks')        |
-      | hash('Suns')          |
-      | hash('Hornets')       |
-      | hash('Cavaliers')     |
-      | hash('Kings')         |
-      | hash('Celtics')       |
-      | hash('76ers')         |
-      | hash('Trail Blazers') |
-      | hash('Bulls')         |
+    Then the result should be, in any order, and the columns 0 should be hashed:
+      | id(v)           |
+      | 'Nets'          |
+      | 'Pistons'       |
+      | 'Bucks'         |
+      | 'Mavericks'     |
+      | 'Clippers'      |
+      | 'Thunders'      |
+      | 'Lakers'        |
+      | 'Jazz'          |
+      | 'Nuggets'       |
+      | 'Wizards'       |
+      | 'Pacers'        |
+      | 'Timberwolves'  |
+      | 'Hawks'         |
+      | 'Warriors'      |
+      | 'Magic'         |
+      | 'Rockets'       |
+      | 'Pelicans'      |
+      | 'Raptors'       |
+      | 'Spurs'         |
+      | 'Heat'          |
+      | 'Grizzlies'     |
+      | 'Knicks'        |
+      | 'Suns'          |
+      | 'Hornets'       |
+      | 'Cavaliers'     |
+      | 'Kings'         |
+      | 'Celtics'       |
+      | '76ers'         |
+      | 'Trail Blazers' |
+      | 'Bulls'         |
     And no side effects
     When executing query:
       """
       MATCH (v:team)
       RETURN id(v) AS vid, v.name AS name
       """
-    Then the result should be, in any order:
-      | vid                   | name            |
-      | hash('Nets')          | 'Nets'          |
-      | hash('Pistons')       | 'Pistons'       |
-      | hash('Bucks')         | 'Bucks'         |
-      | hash('Mavericks')     | 'Mavericks'     |
-      | hash('Clippers')      | 'Clippers'      |
-      | hash('Thunders')      | 'Thunders'      |
-      | hash('Lakers')        | 'Lakers'        |
-      | hash('Jazz')          | 'Jazz'          |
-      | hash('Nuggets')       | 'Nuggets'       |
-      | hash('Wizards')       | 'Wizards'       |
-      | hash('Pacers')        | 'Pacers'        |
-      | hash('Timberwolves')  | 'Timberwolves'  |
-      | hash('Hawks')         | 'Hawks'         |
-      | hash('Warriors')      | 'Warriors'      |
-      | hash('Magic')         | 'Magic'         |
-      | hash('Rockets')       | 'Rockets'       |
-      | hash('Pelicans')      | 'Pelicans'      |
-      | hash('Raptors')       | 'Raptors'       |
-      | hash('Spurs')         | 'Spurs'         |
-      | hash('Heat')          | 'Heat'          |
-      | hash('Grizzlies')     | 'Grizzlies'     |
-      | hash('Knicks')        | 'Knicks'        |
-      | hash('Suns')          | 'Suns'          |
-      | hash('Hornets')       | 'Hornets'       |
-      | hash('Cavaliers')     | 'Cavaliers'     |
-      | hash('Kings')         | 'Kings'         |
-      | hash('Celtics')       | 'Celtics'       |
-      | hash('76ers')         | '76ers'         |
-      | hash('Trail Blazers') | 'Trail Blazers' |
-      | hash('Bulls')         | 'Bulls'         |
+    Then the result should be, in any order, and the columns 0 should be hashed:
+      | vid             | name            |
+      | 'Nets'          | 'Nets'          |
+      | 'Pistons'       | 'Pistons'       |
+      | 'Bucks'         | 'Bucks'         |
+      | 'Mavericks'     | 'Mavericks'     |
+      | 'Clippers'      | 'Clippers'      |
+      | 'Thunders'      | 'Thunders'      |
+      | 'Lakers'        | 'Lakers'        |
+      | 'Jazz'          | 'Jazz'          |
+      | 'Nuggets'       | 'Nuggets'       |
+      | 'Wizards'       | 'Wizards'       |
+      | 'Pacers'        | 'Pacers'        |
+      | 'Timberwolves'  | 'Timberwolves'  |
+      | 'Hawks'         | 'Hawks'         |
+      | 'Warriors'      | 'Warriors'      |
+      | 'Magic'         | 'Magic'         |
+      | 'Rockets'       | 'Rockets'       |
+      | 'Pelicans'      | 'Pelicans'      |
+      | 'Raptors'       | 'Raptors'       |
+      | 'Spurs'         | 'Spurs'         |
+      | 'Heat'          | 'Heat'          |
+      | 'Grizzlies'     | 'Grizzlies'     |
+      | 'Knicks'        | 'Knicks'        |
+      | 'Suns'          | 'Suns'          |
+      | 'Hornets'       | 'Hornets'       |
+      | 'Cavaliers'     | 'Cavaliers'     |
+      | 'Kings'         | 'Kings'         |
+      | 'Celtics'       | 'Celtics'       |
+      | '76ers'         | '76ers'         |
+      | 'Trail Blazers' | 'Trail Blazers' |
+      | 'Bulls'         | 'Bulls'         |
     And no side effects
 
   Scenario: seek by tag index with extend
diff --git a/tests/tck/features/yield/yield.IntVid.feature b/tests/tck/features/yield/yield.IntVid.feature
index 63bd2263fb25c34aa63a9c10fdc6bbfb01aa984d..1141b842e05dbc9ab551da2cc79a8e83c604851c 100644
--- a/tests/tck/features/yield/yield.IntVid.feature
+++ b/tests/tck/features/yield/yield.IntVid.feature
@@ -163,29 +163,29 @@ Feature: Yield Sentence
       """
       GO 2 STEPS FROM hash("Tim Duncan") OVER like YIELD like._dst AS dst | YIELD DISTINCT $-.dst AS dst
       """
-    Then the result should be, in any order:
-      | dst                       |
-      | hash("Tim Duncan")        |
-      | hash("LaMarcus Aldridge") |
-      | hash("Manu Ginobili" )    |
+    Then the result should be, in any order, and the columns 0 should be hashed:
+      | dst                 |
+      | "Tim Duncan"        |
+      | "LaMarcus Aldridge" |
+      | "Manu Ginobili"     |
     When executing query:
       """
       GO 2 STEPS FROM hash("Tim Duncan") OVER like YIELD like._dst AS dst | YIELD $-.dst AS dst
       """
-    Then the result should be, in any order:
-      | dst                       |
-      | hash("Tim Duncan")        |
-      | hash("Tim Duncan")        |
-      | hash("LaMarcus Aldridge") |
-      | hash("Manu Ginobili")     |
+    Then the result should be, in any order, and the columns 0 should be hashed:
+      | dst                 |
+      | "Tim Duncan"        |
+      | "Tim Duncan"        |
+      | "LaMarcus Aldridge" |
+      | "Manu Ginobili"     |
     When executing query:
       """
       GO FROM hash("Tim Duncan") OVER like YIELD like._dst AS dst | YIELD DISTINCT $-.dst AS dst
       """
-    Then the result should be, in any order:
-      | dst                   |
-      | hash("Tony Parker")   |
-      | hash("Manu Ginobili") |
+    Then the result should be, in any order, and the columns 0 should be hashed:
+      | dst             |
+      | "Tony Parker"   |
+      | "Manu Ginobili" |
 
   Scenario: YieldVar
     When executing query:
@@ -254,29 +254,29 @@ Feature: Yield Sentence
       """
       $a = GO 2 STEPS FROM hash("Tim Duncan") OVER like YIELD like._dst AS dst;YIELD DISTINCT $a.dst AS dst
       """
-    Then the result should be, in any order:
-      | dst                       |
-      | hash("Tim Duncan")        |
-      | hash("LaMarcus Aldridge") |
-      | hash("Manu Ginobili")     |
+    Then the result should be, in any order, and the columns 0 should be hashed:
+      | dst                 |
+      | "Tim Duncan"        |
+      | "LaMarcus Aldridge" |
+      | "Manu Ginobili"     |
     When executing query:
       """
       $a = GO 2 STEPS FROM hash("Tim Duncan") OVER like YIELD like._dst AS dst;YIELD $a.dst AS dst
       """
-    Then the result should be, in any order:
-      | dst                       |
-      | hash("Tim Duncan")        |
-      | hash("LaMarcus Aldridge") |
-      | hash("Manu Ginobili")     |
-      | hash("Tim Duncan")        |
+    Then the result should be, in any order, and the columns 0 should be hashed:
+      | dst                 |
+      | "Tim Duncan"        |
+      | "LaMarcus Aldridge" |
+      | "Manu Ginobili"     |
+      | "Tim Duncan"        |
     When executing query:
       """
       $a = GO FROM hash("Tim Duncan") OVER like YIELD like._dst AS dst;YIELD DISTINCT $a.dst AS dst
       """
-    Then the result should be, in any order:
-      | dst                   |
-      | hash("Manu Ginobili") |
-      | hash("Tony Parker")   |
+    Then the result should be, in any order, and the columns 0 should be hashed:
+      | dst             |
+      | "Manu Ginobili" |
+      | "Tony Parker"   |
 
   Scenario: Error
     When executing query: