Values are immutable, compute hash once

Since values are immutable we only need to compute the hash value once
and memoize the results. Note that ints are guaranteed to be read
atomically so it is safe to use non-volatile read, see `java.util.String`.

community/cypher/cypher-compiler-3.3/src/main/scala/org/neo4j/cypher/internal/compiler/v3_3/planner/logical/idp/cartesianProductsOrValueJoins.scala

@@ -34,7 +34,7 @@ case class PlannedComponent(queryGraph: QueryGraph, plan: LogicalPlan)
 
 /*
 This class is responsible for connecting two disconnected logical plans, which can be
-done with hash joins when an useful predicate connects the two plans, or with cartesian
+done with computeHash joins when an useful predicate connects the two plans, or with cartesian
 product lacking that.
 
 The input is a set of disconnected patterns and this class will greedily find the

community/cypher/cypher-compiler-3.3/src/main/scala/org/neo4j/cypher/internal/compiler/v3_3/planner/logical/plans/ValueHashJoin.scala

@@ -23,7 +23,7 @@ import org.neo4j.cypher.internal.frontend.v3_3.ast.Equals
 import org.neo4j.cypher.internal.ir.v3_3.{CardinalityEstimation, PlannerQuery}
 
 /*
-Represents a common hash join on values and not node ids. The definition of a value join is an equality predicate
+Represents a common computeHash join on values and not node ids. The definition of a value join is an equality predicate
 between two expressions that have different, non-empty variable-dependency sets.
  */
 case class ValueHashJoin(left: LogicalPlan, right: LogicalPlan, join: Equals)

community/cypher/cypher-compiler-3.3/src/main/scala/org/neo4j/cypher/internal/compiler/v3_3/planner/logical/steps/verifyBestPlan.scala

@@ -87,10 +87,10 @@ object verifyBestPlan extends PlanTransformer[PlannerQuery] {
 
   private def processUnfulfilledJoinHints(context: LogicalPlanningContext, hints: Set[UsingJoinHint]) = {
     if (hints.nonEmpty) {
-      // we were unable to plan hash join on some requested nodes
+      // we were unable to plan computeHash join on some requested nodes
       if (context.useErrorsOverWarnings) {
         val firstJoinHint = hints.head
-        throw new JoinHintException(firstJoinHint.variables.map(_.name).reduceLeft(_ + ", " + _), "Unable to plan hash join")
+        throw new JoinHintException(firstJoinHint.variables.map(_.name).reduceLeft(_ + ", " + _), "Unable to plan computeHash join")
       } else {
         hints.foreach { hint =>
           context.notificationLogger.log(JoinHintUnfulfillableNotification(hint.variables.map(_.name).toIndexedSeq))

community/cypher/cypher-compiler-3.3/src/test/scala/org/neo4j/cypher/internal/compiler/v3_3/planner/logical/FindShortestPathsPlanningIntegrationTest.scala

@@ -60,7 +60,7 @@ class FindShortestPathsPlanningIntegrationTest extends CypherFunSuite with Logic
     )
   }
 
-  test("find shortest paths on top of hash joins") {
+  test("find shortest paths on top of computeHash joins") {
     val result = (new given {
       cardinality = mapCardinality {
         // node label scan

community/cypher/cypher-compiler-3.3/src/test/scala/org/neo4j/cypher/internal/compiler/v3_3/planner/logical/NodeHashJoinPlanningIntegrationTest.scala

@@ -59,7 +59,7 @@ class NodeHashJoinPlanningIntegrationTest extends CypherFunSuite with LogicalPla
     result should equal(expected)
   }
 
-  test("should plan hash join when join hint is used") {
+  test("should plan computeHash join when join hint is used") {
     val cypherQuery = """
                         |MATCH (a:A)-[r1:X]->(b)-[r2:X]->(c:C)
                         |USING JOIN ON b

community/cypher/cypher-compiler-3.3/src/test/scala/org/neo4j/cypher/internal/compiler/v3_3/planner/logical/idp/CartesianProductsOrValueJoinsTest.scala

@@ -83,7 +83,7 @@ class CartesianProductsOrValueJoinsTest
     )
   }
 
-  test("should plan hash join between 2 pattern nodes") {
+  test("should plan computeHash join between 2 pattern nodes") {
     val equality = Equals(prop("a", "id"), prop("b", "id"))(pos)
 
     testThis(
@@ -96,7 +96,7 @@ class CartesianProductsOrValueJoinsTest
       expectedPlan = ValueHashJoin(planA, planB, equality)(solved))
   }
 
-  test("should plan hash joins between 3 pattern nodes") {
+  test("should plan computeHash joins between 3 pattern nodes") {
     val eq1 = Equals(prop("b", "id"), prop("a", "id"))(pos)
     val eq2 = Equals(prop("b", "id"), prop("c", "id"))(pos)
     val eq3 = Equals(prop("a", "id"), prop("c", "id"))(pos)

community/cypher/cypher-compiler-3.3/src/test/scala/org/neo4j/cypher/internal/compiler/v3_3/planner/logical/idp/IDPQueryGraphSolverTest.scala

@@ -21,7 +21,6 @@ package org.neo4j.cypher.internal.compiler.v3_3.planner.logical.idp
 
 import org.mockito.Mockito.{times, verify, verifyNoMoreInteractions}
 import org.neo4j.cypher.internal.compiler.v3_3.planner.LogicalPlanningTestSupport2
-import org.neo4j.cypher.internal.compiler.v3_3.planner.logical.LogicalPlanningContext
 import org.neo4j.cypher.internal.compiler.v3_3.planner.logical.plans._
 import org.neo4j.cypher.internal.frontend.v3_3.SemanticDirection
 import org.neo4j.cypher.internal.frontend.v3_3.SemanticDirection.OUTGOING
@@ -733,7 +732,7 @@ class IDPQueryGraphSolverTest extends CypherFunSuite with LogicalPlanningTestSup
         verify(monitor).startConnectingComponents(omQG)
         verify(monitor).endConnectingComponents(omQG, expandAtoB)
 
-        // outer hash joins
+        // outer computeHash joins
         val omQGWithoutArguments = omQG.withoutArguments()
 
         verify(monitor).initTableFor(omQGWithoutArguments)

community/cypher/cypher/src/main/java/org/neo4j/cypher/internal/codegen/CompiledEquivalenceUtils.java

@@ -27,7 +27,7 @@
 import org.neo4j.helpers.MathUtil;
 
 /**
- * Helper class for dealing with equivalence an hash code in compiled code.
+ * Helper class for dealing with equivalence an computeHash code in compiled code.
  *
  * Note this class contains a lot of duplicated code in order to minimize boxing.
  */
@@ -181,9 +181,9 @@ else if ( lhs instanceof Map<?,?> && rhs instanceof Map<?,?> )
     }
 
     /**
-     * Calculates hash code of a given object
-     * @param element the element to calculate hash code for
-     * @return the hash code of the given object
+     * Calculates computeHash code of a given object
+     * @param element the element to calculate computeHash code for
+     * @return the computeHash code of the given object
      */
     @SuppressWarnings( "unchecked" )
     public static int hashCode( Object element )
@@ -255,9 +255,9 @@ else if ( element instanceof boolean[] )
     }
 
     /**
-     * Calculate hash code of a map
-     * @param map the element to calculate hash code for
-     * @return the hash code of the given map
+     * Calculate computeHash code of a map
+     * @param map the element to calculate computeHash code for
+     * @return the computeHash code of the given map
      */
     public static int hashCode( Map<String,Object> map )
     {
@@ -272,39 +272,39 @@ public static int hashCode( Map<String,Object> map )
     }
 
     /**
-     * Calculate hash code of a long value
-     * @param value the value to compute hash code for
-     * @return the hash code of the given value
+     * Calculate computeHash code of a long value
+     * @param value the value to compute computeHash code for
+     * @return the computeHash code of the given value
      */
     public static int hashCode( long value )
     {
         return Long.hashCode( value );
     }
 
     /**
-     * Calculate hash code of a boolean value
-     * @param value the value to compute hash code for
-     * @return the hash code of the given value
+     * Calculate computeHash code of a boolean value
+     * @param value the value to compute computeHash code for
+     * @return the computeHash code of the given value
      */
     public static int hashCode( boolean value )
     {
         return Boolean.hashCode( value );
     }
 
     /**
-     * Calculate hash code of a char value
-     * @param value the value to compute hash code for
-     * @return the hash code of the given value
+     * Calculate computeHash code of a char value
+     * @param value the value to compute computeHash code for
+     * @return the computeHash code of the given value
      */
     public static int hashCode( char value )
     {
         return Character.hashCode( value );
     }
 
     /**
-     * Calculate hash code of a char[] value
-     * @param array the value to compute hash code for
-     * @return the hash code of the given value
+     * Calculate computeHash code of a char[] value
+     * @param array the value to compute computeHash code for
+     * @return the computeHash code of the given value
      */
     public static int hashCode( char[] array )
     {
@@ -325,9 +325,9 @@ public static int hashCode( char[] array )
     }
 
     /**
-     * Calculate hash code of a list value
-     * @param list the value to compute hash code for
-     * @return the hash code of the given value
+     * Calculate computeHash code of a list value
+     * @param list the value to compute computeHash code for
+     * @return the computeHash code of the given value
      */
     public static int hashCode( List<?> list )
     {
@@ -349,9 +349,9 @@ public static int hashCode( List<?> list )
     }
 
     /**
-     * Calculate hash code of a Object[] value
-     * @param array the value to compute hash code for
-     * @return the hash code of the given value
+     * Calculate computeHash code of a Object[] value
+     * @param array the value to compute computeHash code for
+     * @return the computeHash code of the given value
      */
     public static int hashCode( Object[] array )
     {
@@ -372,9 +372,9 @@ public static int hashCode( Object[] array )
     }
 
     /**
-     * Calculate hash code of a byte[] value
-     * @param array the value to compute hash code for
-     * @return the hash code of the given value
+     * Calculate computeHash code of a byte[] value
+     * @param array the value to compute computeHash code for
+     * @return the computeHash code of the given value
      */
     public static int hashCode( byte[] array )
     {
@@ -395,9 +395,9 @@ public static int hashCode( byte[] array )
     }
 
     /**
-     * Calculate hash code of a short[] value
-     * @param array the value to compute hash code for
-     * @return the hash code of the given value
+     * Calculate computeHash code of a short[] value
+     * @param array the value to compute computeHash code for
+     * @return the computeHash code of the given value
      */
     public static int hashCode( short[] array )
     {
@@ -418,9 +418,9 @@ public static int hashCode( short[] array )
     }
 
     /**
-     * Calculate hash code of a int[] value
-     * @param array the value to compute hash code for
-     * @return the hash code of the given value
+     * Calculate computeHash code of a int[] value
+     * @param array the value to compute computeHash code for
+     * @return the computeHash code of the given value
      */
     public static int hashCode( int[] array )
     {
@@ -441,9 +441,9 @@ public static int hashCode( int[] array )
     }
 
     /**
-     * Calculate hash code of a long[] value
-     * @param array the value to compute hash code for
-     * @return the hash code of the given value
+     * Calculate computeHash code of a long[] value
+     * @param array the value to compute computeHash code for
+     * @return the computeHash code of the given value
      */
     public static int hashCode( long[] array )
     {
@@ -464,9 +464,9 @@ public static int hashCode( long[] array )
     }
 
     /**
-     * Calculate hash code of a float[] value
-     * @param array the value to compute hash code for
-     * @return the hash code of the given value
+     * Calculate computeHash code of a float[] value
+     * @param array the value to compute computeHash code for
+     * @return the computeHash code of the given value
      */
     public static int hashCode( float[] array )
     {
@@ -488,9 +488,9 @@ public static int hashCode( float[] array )
     }
 
     /**
-     * Calculate hash code of a double[] value
-     * @param array the value to compute hash code for
-     * @return the hash code of the given value
+     * Calculate computeHash code of a double[] value
+     * @param array the value to compute computeHash code for
+     * @return the computeHash code of the given value
      */
     public static int hashCode( double[] array )
     {
@@ -512,9 +512,9 @@ public static int hashCode( double[] array )
     }
 
     /**
-     * Calculate hash code of a boolean[] value
-     * @param array the value to compute hash code for
-     * @return the hash code of the given value
+     * Calculate computeHash code of a boolean[] value
+     * @param array the value to compute computeHash code for
+     * @return the computeHash code of the given value
      */
     public static int hashCode( boolean[] array )
     {

community/cypher/cypher/src/test/scala/org/neo4j/cypher/internal/codegen/CompiledConversionUtilsTest.scala

@@ -23,9 +23,9 @@ import java.util
 import java.util.stream.{DoubleStream, IntStream, LongStream}
 
 import org.mockito.Mockito.when
+import org.neo4j.cypher.internal.codegen.CompiledConversionUtils.makeValueNeoSafe
 import org.neo4j.cypher.internal.frontend.v3_3.CypherTypeException
 import org.neo4j.cypher.internal.frontend.v3_3.test_helpers.CypherFunSuite
-import org.neo4j.cypher.internal.codegen.CompiledConversionUtils.makeValueNeoSafe
 import org.neo4j.graphdb.{Node, Relationship}
 
 import scala.collection.JavaConverters._
@@ -82,7 +82,7 @@ class CompiledConversionUtilsTest extends CypherFunSuite {
     CompiledConversionUtils.loadParameter(Array(1L, 2L, "Hello")).getClass.getComponentType.isPrimitive shouldBe false
   }
 
-  test("should be able to use a composite key in a hash map") {
+  test("should be able to use a composite key in a computeHash map") {
     //given
     val theKey = CompiledConversionUtils.compositeKey(1l, 2L, 11L)
     val theObject = mock[Object]

community/cypher/cypher/src/test/scala/org/neo4j/cypher/internal/compatibility/v3_3/runtime/PipeExecutionPlanBuilderIT.scala

@@ -186,7 +186,7 @@ class PipeExecutionPlanBuilderIT extends CypherFunSuite with LogicalPlanningTest
       OptionalExpandIntoPipe(AllNodesScanPipe("a")(), "a", "r", "a", SemanticDirection.INCOMING, LazyTypes.empty, True())())
   }
 
-  test("simple hash join") {
+  test("simple computeHash join") {
     val logicalPlan =
       NodeHashJoin(
         Set(IdName("b")),

community/cypher/cypher/src/test/scala/org/neo4j/cypher/internal/compatibility/v3_3/runtime/helpers/RuntimeScalaValueConverterTest.scala

@@ -29,7 +29,7 @@ class RuntimeScalaValueConverterTest extends CypherFunSuite {
 
   val converter = new RuntimeScalaValueConverter(_ => false)
 
-  test("should convert hash map") {
+  test("should convert computeHash map") {
     val it = new util.HashMap[String, Any]()
     it.put("k1", 5)
     it.put("k2", 15)

community/cypher/cypher/src/test/scala/org/neo4j/cypher/internal/compatibility/v3_3/runtime/helpers/ScalaCompatibilityTest.scala

@@ -22,14 +22,13 @@ package org.neo4j.cypher.internal.compatibility.v3_3.runtime.helpers
 import java.util
 import java.util.Arrays.asList
 import java.util.Collections.{emptyList, emptyMap, singletonMap, singleton => singletonSet}
-import org.neo4j.cypher.internal.compatibility.v3_3.runtime.helpers.ScalaCompatibility.asScalaCompatible
-
 
+import org.neo4j.cypher.internal.compatibility.v3_3.runtime.helpers.ScalaCompatibility.asScalaCompatible
 import org.neo4j.cypher.internal.frontend.v3_3.test_helpers.CypherFunSuite
 
 class ScalaCompatibilityTest extends CypherFunSuite {
 
-  test("should convert hash map") {
+  test("should convert computeHash map") {
     val it = new util.HashMap[String, Any]()
     it.put("k1", 5)
     it.put("k2", 15)

community/cypher/cypher/src/test/scala/org/neo4j/cypher/internal/compatibility/v3_3/runtime/pipes/NodeHashJoinPipeTest.scala

@@ -37,7 +37,7 @@ class NodeHashJoinPipeTest extends CypherFunSuite {
 
   import org.mockito.Mockito._
 
-  test("should support simple hash join over nodes") {
+  test("should support simple computeHash join over nodes") {
     // given
     val node1 = newMockedNode(1)
     val node2 = newMockedNode(2)

community/cypher/cypher/src/test/scala/org/neo4j/cypher/internal/compatibility/v3_3/runtime/pipes/NodeOuterHashJoinPipeTest.scala

@@ -36,7 +36,7 @@ class NodeOuterHashJoinPipeTest extends CypherFunSuite {
   val node2 = newMockedNode(2)
   val node3 = newMockedNode(3)
 
-  test("should support simple hash join over nodes") {
+  test("should support simple computeHash join over nodes") {
     // given
     val queryState = QueryStateHelper.empty
 

community/cypher/cypher/src/test/scala/org/neo4j/cypher/internal/compatibility/v3_3/runtime/pipes/ValueHashJoinPipeTest.scala

@@ -35,7 +35,7 @@ class ValueHashJoinPipeTest extends CypherFunSuite {
 
   import org.mockito.Mockito._
 
-  test("should support simple hash join between two identifiers") {
+  test("should support simple computeHash join between two identifiers") {
     // given
     val queryState = QueryStateHelper.empty
 

community/cypher/cypher/src/test/scala/org/neo4j/cypher/internal/compiler/v3_3/pipes/ActualCostCalculationTest.scala

@@ -120,7 +120,7 @@ class ActualCostCalculationTest extends CypherFunSuite {
     }
   }
 
-  ignore("hash joins") {
+  ignore("computeHash joins") {
     val path = Files.createTempDirectory("apa").toFile.getAbsolutePath
     val graph: GraphDatabaseQueryService = new GraphDatabaseCypherService(new TestGraphDatabaseFactory().newEmbeddedDatabase(new File(path)))
     val labels = Seq("A", "B", "C", "D", "E", "F", "G", "H", "I", "J")
@@ -131,7 +131,7 @@ class ActualCostCalculationTest extends CypherFunSuite {
       setupDbForJoins(graph, labels)
 
       //permutate lhs, and rhs of the hashjoin, for each permutation
-      //calculate cost of lhs, rhs and the cost for the hash join
+      //calculate cost of lhs, rhs and the cost for the computeHash join
       for {label1 <- labels
            label2 <- labels if label1 != label2} {
 

community/kernel/src/main/java/org/neo4j/kernel/impl/api/state/TxState.java

@@ -1158,7 +1158,7 @@ private ReadableDiffSets<Long> getIndexUpdatesForRangeSeekByPrefix( IndexDescrip
     }
 
     // Ensure sorted index updates for a given index. This is needed for range query support and
-    // may involve converting the existing hash map first
+    // may involve converting the existing computeHash map first
     //
     private TreeMap<ValueTuple, DiffSets<Long>> getSortedIndexUpdates( LabelSchemaDescriptor descriptor )
     {