Make hash by the value allocated, not by pointer

arangod/Aql/AqlValue.cpp

@@ -1371,59 +1371,60 @@ namespace std {
 using arangodb::aql::AqlValue;
 
 size_t hash<AqlValue>::operator()(AqlValue const& x) const noexcept {
-  auto t = x.type();
-  switch (t) {
-    case AqlValue::VPACK_INLINE:
-      return static_cast<size_t>(
-          VPackSlice(x._data.inlineSliceMeta.slice).volatileHash());
-    case AqlValue::VPACK_INLINE_INT64:
-    case AqlValue::VPACK_INLINE_UINT64:
-    case AqlValue::VPACK_INLINE_DOUBLE:
-      return static_cast<size_t>(
-          VPackSlice(x._data.longNumberMeta.data.slice.slice).volatileHash());
-      // TODO(MBkkt) these hashes have bad distribution
-    case AqlValue::VPACK_SLICE_POINTER:
-      return std::hash<void const*>()(x._data.slicePointerMeta.pointer);
-    case AqlValue::VPACK_MANAGED_SLICE:
-      return std::hash<void const*>()(x._data.managedSliceMeta.pointer);
-    case AqlValue::VPACK_MANAGED_STRING:
-      return std::hash<void const*>()(x._data.managedStringMeta.pointer);
-    case AqlValue::RANGE:
-      return std::hash<void const*>()(x._data.rangeMeta.range);
+  using T = AqlValue::AqlValueType;
+  auto aqlValueType = x.type();
+  // as this is non owning, we hash by the pointer
+  if (aqlValueType == T::VPACK_SLICE_POINTER) {
+    return std::hash<void const*>()(x._data.slicePointerMeta.pointer);
   }
-  return 0;
+  auto hash64 = x.hash(0);  // make a normalized hash, for the semantics of the
+                            // value regardless of the storae stype
+  size_t h = static_cast<size_t>(hash64);
+  if (h == 0) {  // fallback to avoid collision with the marker that uses h ==
+                 // 0, very unlikely to happen
+    h = 1;
+  }
+  return h;
 }
 
 bool equal_to<AqlValue>::operator()(AqlValue const& a,
                                     AqlValue const& b) const noexcept {
-  // TODO(MBkkt) can be just compare two uint64_t?
-  auto t = a.type();
-  if (t != b.type()) {
+  using T = AqlValue::AqlValueType;
+  auto ta = a.type();
+  auto tb = b.type();
+
+  if (ta == tb) {
+    switch (ta) {
+      case T::VPACK_INLINE:
+        return VPackSlice(a._data.inlineSliceMeta.slice)
+            .binaryEquals(VPackSlice(b._data.inlineSliceMeta.slice));
+      case T::VPACK_INLINE_INT64:
+      case T::VPACK_INLINE_UINT64:
+      case T::VPACK_INLINE_DOUBLE:
+        return a._data.longNumberMeta.data.intLittleEndian.val ==
+               b._data.longNumberMeta.data.intLittleEndian.val;
+      case T::VPACK_SLICE_POINTER:
+        return a._data.slicePointerMeta.pointer ==
+               b._data.slicePointerMeta.pointer;
+      case T::RANGE: {
+        auto const* ra = a._data.rangeMeta.range;
+        auto const* rb = b._data.rangeMeta.range;
+        return ra->_low == rb->_low && ra->_high == rb->_high;
+      }
+      default:
+        return a.slice(ta).binaryEquals(b.slice(tb));
+    }
+  }
+
+  if (ta == T::RANGE || tb == T::RANGE) {
     return false;
   }
-  switch (t) {
-    case AqlValue::VPACK_INLINE:
-      return VPackSlice(a._data.inlineSliceMeta.slice)
-          .binaryEquals(VPackSlice(b._data.inlineSliceMeta.slice));
-    case AqlValue::VPACK_INLINE_INT64:
-    case AqlValue::VPACK_INLINE_UINT64:
-    case AqlValue::VPACK_INLINE_DOUBLE:
-      // equal is equal. sign/endianess does not matter
-      return a._data.longNumberMeta.data.intLittleEndian.val ==
-             b._data.longNumberMeta.data.intLittleEndian.val;
-    case AqlValue::VPACK_SLICE_POINTER:
-      return a._data.slicePointerMeta.pointer ==
-             b._data.slicePointerMeta.pointer;
-    case AqlValue::VPACK_MANAGED_SLICE:
-      return a._data.managedSliceMeta.pointer ==
-             b._data.managedSliceMeta.pointer;
-    case AqlValue::VPACK_MANAGED_STRING:
-      return a._data.managedStringMeta.pointer ==
-             b._data.managedStringMeta.pointer;
-    case AqlValue::RANGE:
-      return a._data.rangeMeta.range == b._data.rangeMeta.range;
+
+  if (ta == T::VPACK_SLICE_POINTER || tb == T::VPACK_SLICE_POINTER) {
+    return false;
   }
-  return false;
+
+  return a.slice(ta).binaryEquals(b.slice(tb));
 }
 
 }  // namespace std