[yugabyte#25403] docdb: Add helpers for defining hash functions

Summary:
Defining hash functions for structs requires a lot of boilerplate. For example, to make
`boost::hash` work with `YsqlFullTableName`, we have:

```
inline size_t hash_value(const YsqlFullTableName& table) {
  size_t value = 0;
  boost::hash_combine(value, table.namespace_name);
  boost::hash_combine(value, table.schema_name);
  boost::hash_combine(value, table.table_name);
  return value;
}
```

This diff adds helper macros to eliminate much of the boilerplate needed to make std::hash
and boost::hash work with structs, e.g.

```
YB_STRUCT_DEFINE_HASH(yb, YsqlFullTableName, namespace_name, schema_name, table_name);
```
will allow both `std::hash<YsqlFullTableName>` and `boost::hash<YsqlFullTableName>` to work and hash over `namespace_name`, `schema_name`, and `table_name`.
Jira: DB-14634

Test Plan: Jenkins

Reviewers: hsunder, sergei, xCluster

Reviewed By: hsunder

Subscribers: svc_phabricator, ycdcxcluster, bkolagani, ybase

Differential Revision: https://phorge.dev.yugabyte.com/D40837

Author: es1024

src/yb/cdc/cdc_service.cc

@@ -2088,7 +2088,7 @@ void CDCServiceImpl::ProcessMetricsForEmptyChildrenTablets(
 
       // Need to work our way up the hierarchy until we find a tablet with a valid value.
       auto parent_tablet = child_tablet_meta.parent_tablet_info;
-      std::unordered_set<TabletStreamInfo, TabletStreamInfo::Hash> tablet_hierarchy;
+      std::unordered_set<TabletStreamInfo> tablet_hierarchy;
       tablet_hierarchy.insert(child_tablet);
 
       while (!parent_tablet.tablet_id.empty()) {
@@ -2137,7 +2137,7 @@ void CDCServiceImpl::ProcessMetricsForEmptyChildrenTablets(
 void CDCServiceImpl::UpdateMetrics() {
   auto tablet_checkpoints = impl_->TabletCheckpointsCopy();
   TabletInfoToLastReplicationTimeMap cdc_state_tablets_to_last_replication_time;
-  std::unordered_set<TabletStreamInfo, TabletStreamInfo::Hash> expired_entries;
+  std::unordered_set<TabletStreamInfo> expired_entries;
   EmptyChildrenTabletMap empty_children_tablets;
 
   Status iteration_status;

src/yb/cdc/cdc_service.h

@@ -413,9 +413,9 @@ class CDCServiceImpl : public CDCServiceIf {
     std::shared_ptr<yb::xrepl::XClusterTabletMetrics> tablet_metric;
   };
   using EmptyChildrenTabletMap =
-      std::unordered_map<TabletStreamInfo, ChildrenTabletMeta, TabletStreamInfo::Hash>;
+      std::unordered_map<TabletStreamInfo, ChildrenTabletMeta>;
   using TabletInfoToLastReplicationTimeMap =
-      std::unordered_map<TabletStreamInfo, std::optional<uint64_t>, TabletStreamInfo::Hash>;
+      std::unordered_map<TabletStreamInfo, std::optional<uint64_t>>;
   // Helper function for processing metrics of children tablets. We need to find an ancestor tablet
   // that has a last replicated time and use that with our latest op's time to find the full lag.
   void ProcessMetricsForEmptyChildrenTablets(

src/yb/cdc/cdc_util.cc

@@ -13,8 +13,6 @@
 
 #include "yb/cdc/cdc_util.h"
 
-#include <boost/functional/hash.hpp>
-
 #include "yb/gutil/strings/stringpiece.h"
 #include "yb/util/format.h"
 
@@ -24,12 +22,4 @@ std::string TabletStreamInfo::ToString() const {
   return Format("{ stream_id: $1 tablet_id: $2 }", stream_id, tablet_id);
 }
 
-std::size_t TabletStreamInfo::Hash::operator()(const TabletStreamInfo& p) const noexcept {
-  std::size_t hash = 0;
-  boost::hash_combine(hash, p.stream_id);
-  boost::hash_combine(hash, p.tablet_id);
-
-  return hash;
-}
-
 }  // namespace yb::cdc

src/yb/cdc/cdc_util.h

@@ -14,8 +14,10 @@
 #pragma once
 
 #include <string>
+
 #include "yb/cdc/xrepl_types.h"
 #include "yb/common/entity_ids_types.h"
+#include "yb/util/hash_util.h"
 
 namespace yb::cdc {
 
@@ -24,15 +26,11 @@ struct TabletStreamInfo {
   xrepl::StreamId stream_id;
   TabletId tablet_id;
 
-  bool operator==(const TabletStreamInfo& other) const {
-    return stream_id == other.stream_id && tablet_id == other.tablet_id;
-  }
+  bool operator==(const TabletStreamInfo& other) const = default;
 
-  std::string ToString() const;
+  YB_STRUCT_DEFINE_HASH(TabletStreamInfo, stream_id, tablet_id);
 
-  struct Hash {
-    std::size_t operator()(const TabletStreamInfo& p) const noexcept;
-  };
+  std::string ToString() const;
 };
 
 
@@ -46,6 +44,4 @@ struct CDCCreationState {
   }
 };
 
-inline size_t hash_value(const TabletStreamInfo& p) noexcept { return TabletStreamInfo::Hash()(p); }
-
 }  // namespace yb::cdc

src/yb/cdc/xcluster_types.cc

@@ -13,8 +13,6 @@
 
 #include "yb/cdc/xcluster_types.h"
 
-#include <boost/container_hash/hash_fwd.hpp>
-
 #include "yb/util/format.h"
 
 namespace yb::xcluster {
@@ -23,16 +21,6 @@ std::string ProducerTabletInfo::ToString() const {
   return YB_STRUCT_TO_STRING(replication_group_id, stream_id, tablet_id, table_id);
 }
 
-std::size_t ProducerTabletInfo::Hash::operator()(const ProducerTabletInfo& p) const noexcept {
-  std::size_t hash = 0;
-  boost::hash_combine(hash, p.replication_group_id);
-  boost::hash_combine(hash, p.stream_id);
-  boost::hash_combine(hash, p.tablet_id);
-  boost::hash_combine(hash, p.table_id);
-
-  return hash;
-}
-
 std::string ConsumerTabletInfo::ToString() const {
   return Format("{ consumer tablet ID: $0 table ID: $1 }", tablet_id, table_id);
 }

src/yb/cdc/xcluster_types.h

@@ -16,6 +16,7 @@
 #include "yb/cdc/xrepl_types.h"
 #include "yb/common/common_types.pb.h"
 #include "yb/common/entity_ids_types.h"
+#include "yb/util/hash_util.h"
 
 namespace yb::xcluster {
 
@@ -44,22 +45,13 @@ struct ProducerTabletInfo {
   TabletId tablet_id;
   TableId table_id;
 
-  bool operator==(const ProducerTabletInfo& other) const {
-    return replication_group_id == other.replication_group_id && stream_id == other.stream_id &&
-           tablet_id == other.tablet_id && table_id == other.table_id;
-  }
+  bool operator==(const ProducerTabletInfo& other) const = default;
 
-  std::string ToString() const;
+  YB_STRUCT_DEFINE_HASH(ProducerTabletInfo, replication_group_id, stream_id, tablet_id, table_id);
 
-  struct Hash {
-    std::size_t operator()(const ProducerTabletInfo& p) const noexcept;
-  };
+  std::string ToString() const;
 };
 
-inline size_t hash_value(const ProducerTabletInfo& p) noexcept {
-  return ProducerTabletInfo::Hash()(p);
-}
-
 struct ConsumerTabletInfo {
   std::string tablet_id;
   TableId table_id;

src/yb/common/opid.cc

@@ -17,8 +17,7 @@
 
 #include <algorithm>
 
-#include <boost/functional/hash.hpp>
-
+#include "yb/util/hash_util.h"
 #include "yb/util/stol_utils.h"
 
 namespace yb {
@@ -70,12 +69,7 @@ std::ostream& operator<<(std::ostream& out, const OpId& op_id) {
 }
 
 size_t hash_value(const OpId& op_id) noexcept {
-  size_t result = 0;
-
-  boost::hash_combine(result, op_id.term);
-  boost::hash_combine(result, op_id.index);
-
-  return result;
+  return YB_STRUCT_HASH_VALUE(op_id, term, index);
 }
 
 } // namespace yb

src/yb/common/pg_types.h

@@ -13,11 +13,11 @@
 
 #pragma once
 
-#include <boost/functional/hash/hash.hpp>
-
 #include "yb/common/entity_ids.h"
 #include "yb/common/schema.h"
 
+#include "yb/util/hash_util.h"
+
 namespace yb {
 
 class Slice;
@@ -83,6 +83,10 @@ struct PgObjectId {
   static NamespaceId GetYbNamespaceIdFromPB(const PB& pb) {
     return FromPB(pb).GetYbNamespaceId();
   }
+
+  constexpr std::strong_ordering operator<=>(const PgObjectId&) const = default;
+
+  YB_STRUCT_DEFINE_HASH(PgObjectId, database_oid, object_oid);
 };
 
 using PgObjectIdHash = boost::hash<PgObjectId>;
@@ -91,49 +95,19 @@ inline std::ostream& operator<<(std::ostream& out, const PgObjectId& id) {
   return out << id.ToString();
 }
 
-inline bool operator==(const PgObjectId& lhs, const PgObjectId& rhs) {
-  return lhs.database_oid == rhs.database_oid && lhs.object_oid == rhs.object_oid;
-}
-
-inline bool operator<(const PgObjectId& lhs, const PgObjectId& rhs) {
-  return lhs.database_oid == rhs.database_oid
-      ? (lhs.object_oid < rhs.object_oid)
-      : (lhs.database_oid < rhs.database_oid);
-}
-
-inline size_t hash_value(const PgObjectId& id) {
-  size_t value = 0;
-  boost::hash_combine(value, id.database_oid);
-  boost::hash_combine(value, id.object_oid);
-  return value;
-}
-
 // A struct for complete PG table names.
 struct YsqlFullTableName {
   NamespaceName namespace_name;
   PgSchemaName schema_name;
   TableName table_name;
 
-  bool operator==(const YsqlFullTableName& other) const {
-    return namespace_name == other.namespace_name && schema_name == other.schema_name &&
-           table_name == other.table_name;
-  }
+  bool operator==(const YsqlFullTableName& other) const = default;
 
-  std::string ToString() const;
+  YB_STRUCT_DEFINE_HASH(YsqlFullTableName, namespace_name, schema_name, table_name);
 
-  struct Hash {
-    std::size_t operator()(const YsqlFullTableName& p) const noexcept;
-  };
+  std::string ToString() const;
 };
 
 using YsqlFullTableNameHash = boost::hash<YsqlFullTableName>;
 
-inline size_t hash_value(const YsqlFullTableName& table) {
-  size_t value = 0;
-  boost::hash_combine(value, table.namespace_name);
-  boost::hash_combine(value, table.schema_name);
-  boost::hash_combine(value, table.table_name);
-  return value;
-}
-
 }  // namespace yb

src/yb/docdb/object_lock_data.h

@@ -13,12 +13,11 @@
 
 #pragma once
 
-#include <boost/functional/hash.hpp>
-
 #include "yb/common/transaction.h"
 #include "yb/dockv/dockv_fwd.h"
 #include "yb/tserver/tserver.pb.h"
 #include "yb/util/compare_util.h"
+#include "yb/util/hash_util.h"
 
 namespace yb::docdb {
 
@@ -30,6 +29,8 @@ struct VersionedTransaction {
       const TransactionId& txn_id_, TxnReuseVersion txn_version_) : txn_id(txn_id_),
       txn_version(txn_version_) {}
 
+  YB_STRUCT_DEFINE_HASH(VersionedTransaction, txn_id, txn_version);
+
   std::string ToString() const {
     return YB_STRUCT_TO_STRING(txn_id, txn_version);
   }
@@ -46,13 +47,6 @@ inline bool operator<(const VersionedTransaction& lhs, const VersionedTransactio
   return lhs.txn_version < rhs.txn_version;
 }
 
-inline size_t hash_value(const VersionedTransaction object) noexcept {
-  size_t seed = 0;
-  boost::hash_combine(seed, object.txn_id);
-  boost::hash_combine(seed, object.txn_version);
-  return seed;
-}
-
 struct ObjectLockOwner {
   VersionedTransaction versioned_txn;
   SubTransactionId subtxn_id;
@@ -70,6 +64,8 @@ struct ObjectLockOwner {
     req->set_subtxn_id(subtxn_id);
   }
 
+  YB_STRUCT_DEFINE_HASH(ObjectLockOwner, versioned_txn, subtxn_id);
+
   std::string ToString() const {
     return YB_STRUCT_TO_STRING(versioned_txn, subtxn_id);
   }
@@ -86,13 +82,6 @@ inline bool operator<(const ObjectLockOwner& lhs, const ObjectLockOwner& rhs) {
   return lhs.subtxn_id < rhs.subtxn_id;
 }
 
-inline size_t hash_value(const ObjectLockOwner object) noexcept {
-  size_t seed = 0;
-  boost::hash_combine(seed, object.versioned_txn);
-  boost::hash_combine(seed, object.subtxn_id);
-  return seed;
-}
-
 // ObjectLockPrefix is the entity for which the ts_local_lock_manager acquires locks. In context of
 // object/table locks, when a session requests lock(s) on an object oid corresponding to a database
 // oid, an 'ObjectLockPrefix' in formed which is then passed to the ObjectLockManager.
@@ -105,6 +94,8 @@ struct ObjectLockPrefix {
     return YB_STRUCT_TO_STRING(database_oid, object_oid, lock_type);
   }
 
+  YB_STRUCT_DEFINE_HASH(ObjectLockPrefix, database_oid, object_oid, lock_type);
+
   uint64_t database_oid;
   uint64_t object_oid;
   dockv::KeyEntryType lock_type;
@@ -124,12 +115,4 @@ inline bool operator<(const ObjectLockPrefix& lhs, const ObjectLockPrefix& rhs)
   return lhs.lock_type < rhs.lock_type;
 }
 
-inline size_t hash_value(const ObjectLockPrefix object) noexcept {
-  size_t seed = 0;
-  boost::hash_combine(seed, object.database_oid);
-  boost::hash_combine(seed, object.object_oid);
-  boost::hash_combine(seed, object.lock_type);
-  return seed;
-}
-
 } // namespace yb::docdb

src/yb/master/xcluster/xcluster_outbound_replication_group.cc

@@ -18,6 +18,7 @@
 #include "yb/common/xcluster_util.h"
 #include "yb/master/catalog_entity_info.h"
 #include "yb/master/xcluster/xcluster_outbound_replication_group_tasks.h"
+#include "yb/util/hash_util.h"
 #include "yb/util/is_operation_done_result.h"
 #include "yb/util/status_log.h"
 #include "yb/util/sync_point.h"
@@ -35,10 +36,7 @@ namespace {
 
 struct TableSchemaNamePairHash {
   std::size_t operator()(const XClusterOutboundReplicationGroup::TableSchemaNamePair& elem) const {
-    std::size_t hash = 0;
-    boost::hash_combine(hash, elem.first);
-    boost::hash_combine(hash, elem.second);
-    return hash;
+    return YB_STRUCT_HASH_VALUE(elem, first, second);
   }
 };