Congratulations, you made it! We've been on a journey to expand our simple key-value store and have added integral features such as expiration times and LRU caching, learning from the popular data store, Redis.
Our key-value store has been revved up. It can now hold values for a specified time and uses LRU caching for handling keys when memory capacity becomes a potential concern while also preserving performance. We mimic Redis in two main aspects: fast access to stored data and optimized memory use.
The expanded key-value store can now be seen as a rudimentary version of Redis, the ultra-fast, in-memory data store with rich data structure support. Does it mean our key-value store is as powerful as Redis? Not entirely, because Redis has much more complex features (such as data replication, persistence options, various types of data structures, built-in Lua scripting, etc.). However, we've gained a glimpse into the inner workings of Redis and built something similar. This can be a great confidence booster, ever boosting your understanding of computer science and software development.
Here's the final snapshot of our key-value store implemented in Python:
xxxxxxxxxx
if __name__ == '__main__':
from collections import OrderedDict
import time
class LRU_Cache:
def __init__(self, capacity):
self.capacity = capacity
self.cache = OrderedDict()
def get(self, key):
try:
value = self.cache.pop(key)
self.cache[key] = value
return value
except KeyError:
return -1
def put(self, key, value):
try:
self.cache.pop(key)
except KeyError:
if len(self.cache) >= self.capacity:
self.cache.popitem(last=False)
self.cache[key] = value
key_value_store = LRU_Cache(3)
key_value_store.put(1, 'value1')
key_value_store.put(2, 'value2')
print(key_value_store.get(1)) # Output: 'value1'