Rust中如何实现支持多键类型查询的HashMap？

问题背景 #

我尝试实现一个支持多键查询的Map类型（比如HashMap），可以通过session_id或screen_name两种方式查找值，但卡在了代码实现上，核心问题是不知道如何让Key类型适配多查询场景的Borrow trait：

use std::borrow::Borrow;
use std::collections::HashMap;

/// 用作Map键的值，例如`HashMap<Key, _>`。
#[derive(Clone, Debug, Eq, Hash, PartialEq)]
struct Key {
    session_id: usize,
    screen_name: String,
}

/// 针对以`Key`为键的Map的不同查询方式。
///
/// 每个变体必须构成唯一索引。
#[derive(Clone, Debug, Eq, Hash, PartialEq)]
enum KeyQuery<'s> {
    SessionId(usize),
    ScreenName(&'s str),
}

impl<'s> Borrow<KeyQuery<'s>> for Key {
    fn borrow(&self) -> &KeyQuery<'s> {
        // 这里无法实现：一个Key对应两个Query变体，方法返回类型固定
    }
}

fn main() {
    let mut map: HashMap<Key, ()> = HashMap::new();
    map.insert(
        Key {
            session_id: 1248,
            screen_name: "nombe_hombre".to_string(),
        },
        (),
    );

    // 期望通过任意字段查找值
    map.get(&KeyQuery::SessionId(1248));
    map.get(&KeyQuery::ScreenName("nombe_hombre"));
}

核心矛盾分析 #

这个思路从根上走不通，有两个关键原因：

1. 类型系统限制：Borrow<KeyQuery<'s>>要求Key的borrow方法返回固定类型的引用，但一个Key实例同时对应KeyQuery的两个变体，无法动态返回其中任意一个。
2. 哈希逻辑不匹配：HashMap<Key, _>的哈希和相等判断基于Key的两个字段组合，而单个查询字段的哈希值与组合哈希完全不同，就算Borrow实现了也找不到对应数据。

可行实现方案 #

方案1：多索引HashMap（推荐） #

最直接高效的方式是维护多个HashMap索引，分别对应不同的查询字段，所有索引指向同一个值（用Arc共享避免复制）：

use std::collections::HashMap;
use std::sync::Arc;

#[derive(Clone, Debug, Eq, Hash, PartialEq)]
struct Key {
    session_id: usize,
    screen_name: String,
}

struct MultiKeyMap<V> {
    // 按session_id索引
    by_session: HashMap<usize, Arc<V>>,
    // 按screen_name索引
    by_screen_name: HashMap<String, Arc<V>>,
    // 存储完整键值对
    full_entries: HashMap<Key, Arc<V>>,
}

impl<V> MultiKeyMap<V> {
    fn new() -> Self {
        Self {
            by_session: HashMap::new(),
            by_screen_name: HashMap::new(),
            full_entries: HashMap::new(),
        }
    }

    fn insert(&mut self, key: Key, value: V) {
        let shared_value = Arc::new(value);
        // 同步更新所有索引
        self.by_session.insert(key.session_id, shared_value.clone());
        self.by_screen_name.insert(key.screen_name.clone(), shared_value.clone());
        self.full_entries.insert(key, shared_value);
    }

    fn get_by_session(&self, session_id: usize) -> Option<&V> {
        self.by_session.get(session_id).map(|arc| &**arc)
    }

    fn get_by_screen_name(&self, screen_name: &str) -> Option<&V> {
        self.by_screen_name.get(screen_name).map(|arc| &**arc)
    }
}

fn main() {
    let mut map = MultiKeyMap::new();
    map.insert(
        Key {
            session_id: 1248,
            screen_name: "nombe_hombre".to_string(),
        },
        (),
    );

    assert!(map.get_by_session(1248).is_some());
    assert!(map.get_by_screen_name("nombe_hombre").is_some());
}

优点：查询效率O(1)，逻辑清晰；缺点：插入/删除时需要同步更新所有索引，有额外的内存和性能开销。

方案2：Trait抽象的线性查询（仅适合小数据量） #

如果数据量不大，可以定义查询Trait，通过线性遍历匹配查询条件：

use std::collections::HashMap;

#[derive(Clone, Debug, Eq, Hash, PartialEq)]
struct Key {
    session_id: usize,
    screen_name: String,
}

// 定义查询行为的Trait
trait KeyMatcher {
    fn matches(&self, key: &Key) -> bool;
}

// 让usize可以匹配session_id
impl KeyMatcher for usize {
    fn matches(&self, key: &Key) -> bool {
        *self == key.session_id
    }
}

// 让&str可以匹配screen_name
impl<'a> KeyMatcher for &'a str {
    fn matches(&self, key: &Key) -> bool {
        *self == key.screen_name
    }
}

struct MultiKeyMap<V> {
    inner: HashMap<Key, V>,
}

impl<V> MultiKeyMap<V> {
    fn new() -> Self {
        Self { inner: HashMap::new() }
    }

    fn insert(&mut self, key: Key, value: V) {
        self.inner.insert(key, value);
    }

    fn get<Q: KeyMatcher>(&self, query: Q) -> Option<&V> {
        // 线性遍历查找匹配项
        self.inner.iter().find(|(k, _)| query.matches(k)).map(|(_, v)| v)
    }
}

fn main() {
    let mut map = MultiKeyMap::new();
    map.insert(
        Key {
            session_id: 1248,
            screen_name: "nombe_hombre".to_string(),
        },
        (),
    );

    assert!(map.get(1248).is_some());
    assert!(map.get("nombe_hombre").is_some());
}

优点：实现简单，无需维护多索引；缺点：查询效率O(n)，数据量大时性能极差。

总结 #

• 追求性能优先选方案1，这是工业界常用的多键查询实现方式；
• 小数据量场景可以用方案2快速实现；
• 最初尝试的枚举+Borrow思路无法实现，受限于Rust类型系统和HashMap的哈希匹配逻辑。

内容的提问来源于stack exchange，提问作者Dylan L