Design In-Memory Database — Multi-Field Filtering

Problem

Design a simplified in-memory key-value store supporting:

set(key, field, value) — set field in key's record
get(key, field) — get field value or "" if missing
delete(key, field) — delete field; return true if existed
scan(key) — return all fields and values for a key, sorted by field name
scanByRank(key, field, rank) — return top rank entries by field value (desc)

Solutions

Python

from collections import defaultdict
from sortedcontainers import SortedDict

class InMemoryDatabase:
    def __init__(self):
        self.db = defaultdict(dict)

    def set(self, key, field, value):
        self.db[key][field] = value

    def get(self, key, field):
        return self.db[key].get(field, "")

    def delete(self, key, field):
        if key in self.db and field in self.db[key]:
            del self.db[key][field]
            return True
        return False

    def scan(self, key):
        if key not in self.db:
            return []
        return sorted(f"{k}({v})" for k, v in self.db[key].items())

    def scanByRank(self, key, field, rank):
        if key not in self.db:
            return []
        items = sorted(self.db[key].items(), key=lambda x: (-int(x[1]), x[0]))
        return [f"{k}({v})" for k, v in items[:rank]]

JavaScript

class InMemoryDatabase {
    constructor() { this.db = new Map(); }
    set(key, field, value) {
        if (!this.db.has(key)) this.db.set(key, new Map());
        this.db.get(key).set(field, value);
    }
    get(key, field) { return this.db.get(key)?.get(field) ?? ""; }
    delete(key, field) {
        if (this.db.has(key) && this.db.get(key).has(field)) {
            this.db.get(key).delete(field); return true;
        }
        return false;
    }
    scan(key) {
        const r = this.db.get(key); if (!r) return [];
        return [...r.entries()].sort((a,b)=>a[0].localeCompare(b[0])).map(([k,v])=>`${k}(${v})`);
    }
}

Java

import java.util.*;
class InMemoryDatabase {
    Map<String, TreeMap<String,String>> db = new HashMap<>();
    public void set(String key, String field, String value) {
        db.computeIfAbsent(key, k -> new TreeMap<>()).put(field, value);
    }
    public String get(String key, String field) {
        return db.getOrDefault(key, new TreeMap<>()).getOrDefault(field, "");
    }
    public boolean delete(String key, String field) {
        if (!db.containsKey(key) || !db.get(key).containsKey(field)) return false;
        db.get(key).remove(field); return true;
    }
    public List<String> scan(String key) {
        List<String> res = new ArrayList<>();
        db.getOrDefault(key, new TreeMap<>()).forEach((k,v) -> res.add(k+"("+v+")"));
        return res;
    }
}

C++

#include <unordered_map>
#include <map>
#include <string>
#include <vector>
using namespace std;
class InMemoryDatabase {
    unordered_map<string, map<string,string>> db;
public:
    void set(string key, string field, string value) { db[key][field] = value; }
    string get(string key, string field) {
        if (!db.count(key) || !db[key].count(field)) return "";
        return db[key][field];
    }
    bool del(string key, string field) {
        if (!db.count(key) || !db[key].count(field)) return false;
        db[key].erase(field); return true;
    }
    vector<string> scan(string key) {
        vector<string> res;
        for (auto& [k,v] : db[key]) res.push_back(k+"("+v+")");
        return res;
    }
};

C

/* C: 2D array of key-field-value triples, linear scan for get/delete/scan */