In-Memory Key-Value Store with Nested Transactions

Problem Statement

Design an in-memory key-value store that supports nested transactions. The store should handle basic set, get, and delete operations, along with begin, commit, and rollback commands to manage transaction scopes.

Requirements

• set(key, value): Sets the value for a key in the current active transaction scope.
• get(key): Returns the value for the key. If the key exists in the current scope, return that value. Otherwise, traverse up to parent scopes to find the value. Return None if the key is not found in any scope.
• delete(key): Effectively hides the key in the current scope. Any get request for this key should return None.
• begin(): Starts a new nested transaction scope.
• commit(): Merges the current transaction scope into the parent scope. If there is no parent scope, the changes persist at the global level.
• rollback(): Discards all changes made in the current transaction scope.

Signature

class TransactionalStore:
    def __init__(self):
        pass
    def set(self, key, value):
        pass
    def get(self, key):
        pass
    def delete(self, key):
        pass
    def begin(self):
        pass
    def commit(self):
        pass
    def rollback(self):
        pass

Examples

Example 1:

store = TransactionalStore()
store.set("a", 1)
print(store.get("a")) # Output: 1
store.begin()
store.set("a", 2)
print(store.get("a")) # Output: 2
store.rollback()
print(store.get("a")) # Output: 1

Constraints

• Use a stack-based approach to represent the hierarchy of transaction states.
• Ensure get operations run efficiently relative to the number of active transactions.