uint64_t variant::hash()

in velox/type/Variant.cpp [473:546]
71 lines of code
19 McCabe index (conditional complexity)

uint64_t variant::hash() const {
  uint64_t hash = 0;
  if (isNull()) {
    return folly::Hash{}(static_cast<int32_t>(kind_));
  }

  switch (kind_) {
    case TypeKind::BIGINT:
      return folly::Hash{}(value<TypeKind::BIGINT>());
    case TypeKind::INTEGER:
      return folly::Hash{}(value<TypeKind::INTEGER>());
    case TypeKind::SMALLINT:
      return folly::Hash{}(value<TypeKind::SMALLINT>());
    case TypeKind::TINYINT:
      return folly::Hash{}(value<TypeKind::TINYINT>());
    case TypeKind::BOOLEAN:
      return folly::Hash{}(value<TypeKind::BOOLEAN>());
    case TypeKind::REAL:
      return folly::Hash{}(value<TypeKind::REAL>());
    case TypeKind::DOUBLE:
      return folly::Hash{}(value<TypeKind::DOUBLE>());
    case TypeKind::VARBINARY:
      return folly::Hash{}(value<TypeKind::VARBINARY>());
    case TypeKind::VARCHAR:
      return folly::Hash{}(value<TypeKind::VARCHAR>());
    case TypeKind::ARRAY: {
      auto& arrayVariant = value<TypeKind::ARRAY>();
      auto hasher = folly::Hash{};
      for (int32_t i = 0; i < arrayVariant.size(); i++) {
        hash = folly::hash::hash_combine_generic(
            hasher, hash, arrayVariant[i].hash());
      }
      return hash;
    }
    case TypeKind::ROW: {
      auto hasher = folly::Hash{};
      auto& rowVariant = value<TypeKind::ROW>();
      for (int32_t i = 0; i < rowVariant.size(); i++) {
        hash = folly::hash::hash_combine_generic(
            hasher, hash, rowVariant[i].hash());
      }
      return hash;
    }
    case TypeKind::DATE: {
      auto dateValue = value<TypeKind::DATE>();
      return folly::Hash{}(dateValue.days());
    }
    case TypeKind::TIMESTAMP: {
      auto timestampValue = value<TypeKind::TIMESTAMP>();
      return folly::Hash{}(
          timestampValue.getSeconds(), timestampValue.getNanos());
    }

    case TypeKind::MAP: {
      auto hasher = folly::Hash{};
      auto& mapVariant = value<TypeKind::MAP>();
      uint64_t combinedKeyHash = 0, combinedValueHash = 0;
      uint64_t singleKeyHash = 0, singleValueHash = 0;
      for (auto it = mapVariant.begin(); it != mapVariant.end(); ++it) {
        singleKeyHash = it->first.hash();
        singleValueHash = it->second.hash();
        combinedKeyHash = folly::hash::commutative_hash_combine_value_generic(
            combinedKeyHash, hasher, singleKeyHash);
        combinedValueHash = folly::hash::commutative_hash_combine_value_generic(
            combinedValueHash, hasher, singleValueHash);
      }

      return folly::hash::hash_combine_generic(
          folly::Hash{}, combinedKeyHash, combinedValueHash);
    }
    default:
      VELOX_NYI();
  }
}