143 lines
5.2 KiB
Markdown
143 lines
5.2 KiB
Markdown
```python
|
|
import sqlite3
|
|
import time
|
|
|
|
class SQLiteRedis:
|
|
def __init__(self, db_name='redis.sqlite'):
|
|
self.conn = sqlite3.connect(db_name, isolation_level=None)
|
|
self.conn.execute('PRAGMA journal_mode=WAL')
|
|
self.cur = self.conn.cursor()
|
|
self._create_tables()
|
|
|
|
def _create_tables(self):
|
|
self.cur.execute('''CREATE TABLE IF NOT EXISTS kv_store
|
|
(key TEXT PRIMARY KEY, value TEXT)''')
|
|
self.cur.execute('''CREATE TABLE IF NOT EXISTS expiry
|
|
(key TEXT PRIMARY KEY, expire_at INTEGER)''')
|
|
self.cur.execute('''CREATE TABLE IF NOT EXISTS list_store
|
|
(key TEXT, idx INTEGER, value TEXT,
|
|
PRIMARY KEY (key, idx))''')
|
|
self.cur.execute('''CREATE TABLE IF NOT EXISTS hash_store
|
|
(key TEXT, field TEXT, value TEXT,
|
|
PRIMARY KEY (key, field))''')
|
|
|
|
|
|
def set(self, key, value):
|
|
self.cur.execute("REPLACE INTO kv_store (key, value) VALUES (?, ?)",
|
|
(key, value))
|
|
|
|
def get(self, key):
|
|
self.cur.execute("SELECT value FROM kv_store WHERE key = ?", (key,))
|
|
result = self.cur.fetchone()
|
|
if result:
|
|
return result[0]
|
|
return None
|
|
|
|
def delete(self, key):
|
|
self.cur.execute("DELETE FROM kv_store WHERE key = ?", (key,))
|
|
self.cur.execute("DELETE FROM expiry WHERE key = ?", (key,))
|
|
|
|
def expire(self, key, seconds):
|
|
expire_at = int(time.time()) + seconds
|
|
self.cur.execute("REPLACE INTO expiry (key, expire_at) VALUES (?, ?)",
|
|
(key, expire_at))
|
|
|
|
def ttl(self, key):
|
|
self.cur.execute("SELECT expire_at FROM expiry WHERE key = ?", (key,))
|
|
result = self.cur.fetchone()
|
|
if result:
|
|
ttl = result[0] - int(time.time())
|
|
return max(ttl, 0)
|
|
return -1
|
|
|
|
def _cleanup_expired(self):
|
|
now = int(time.time())
|
|
self.cur.execute("DELETE FROM kv_store WHERE key IN "
|
|
"(SELECT key FROM expiry WHERE expire_at <= ?)", (now,))
|
|
self.cur.execute("DELETE FROM expiry WHERE expire_at <= ?", (now,))
|
|
|
|
def close(self):
|
|
self.conn.close()
|
|
|
|
def lpush(self, key, *values):
|
|
for value in values:
|
|
self.cur.execute("INSERT INTO list_store (key, idx, value) "
|
|
"SELECT ?, COALESCE(MIN(idx), 0) - 1, ? "
|
|
"FROM list_store WHERE key = ?", (key, value, key))
|
|
return self.llen(key)
|
|
|
|
def rpush(self, key, *values):
|
|
for value in values:
|
|
self.cur.execute("INSERT INTO list_store (key, idx, value) "
|
|
"SELECT ?, COALESCE(MAX(idx), -1) + 1, ? "
|
|
"FROM list_store WHERE key = ?", (key, value, key))
|
|
return self.llen(key)
|
|
|
|
def lpop(self, key):
|
|
self.cur.execute("SELECT value FROM list_store WHERE key = ? "
|
|
"ORDER BY idx ASC LIMIT 1", (key,))
|
|
result = self.cur.fetchone()
|
|
if result:
|
|
self.cur.execute("DELETE FROM list_store WHERE key = ? "
|
|
"AND idx = (SELECT MIN(idx) FROM list_store WHERE key = ?)",
|
|
(key, key))
|
|
return result[0]
|
|
return None
|
|
|
|
def llen(self, key):
|
|
self.cur.execute("SELECT COUNT(*) FROM list_store WHERE key = ?", (key,))
|
|
return self.cur.fetchone()[0]
|
|
|
|
def lrange(self, key, start, stop):
|
|
self.cur.execute("SELECT value FROM list_store WHERE key = ? "
|
|
"ORDER BY idx ASC LIMIT ? OFFSET ?",
|
|
(key, stop - start, start))
|
|
return [row[0] for row in self.cur.fetchall()]
|
|
|
|
def hset(self, key, field, value):
|
|
self.cur.execute("REPLACE INTO hash_store (key, field, value) VALUES (?, ?, ?)",
|
|
(key, field, value))
|
|
return 1
|
|
|
|
def hget(self, key, field):
|
|
self.cur.execute("SELECT value FROM hash_store WHERE key = ? AND field = ?",
|
|
(key, field))
|
|
result = self.cur.fetchone()
|
|
return result[0] if result else None
|
|
|
|
def hdel(self, key, *fields):
|
|
deleted = 0
|
|
for field in fields:
|
|
self.cur.execute("DELETE FROM hash_store WHERE key = ? AND field = ?",
|
|
(key, field))
|
|
deleted += self.cur.rowcount
|
|
return deleted
|
|
|
|
def hlen(self, key):
|
|
self.cur.execute("SELECT COUNT(*) FROM hash_store WHERE key = ?", (key,))
|
|
return self.cur.fetchone()[0]
|
|
|
|
def hgetall(self, key):
|
|
self.cur.execute("SELECT field, value FROM hash_store WHERE key = ?", (key,))
|
|
return dict(self.cur.fetchall())
|
|
|
|
|
|
# 사용 예시
|
|
r = SQLiteRedis()
|
|
r.set('mykey', 'Hello, World!')
|
|
print(r.get('mykey'))
|
|
r.expire('mykey', 10)
|
|
print(r.ttl('mykey'))
|
|
|
|
# LIST 사용
|
|
r.lpush("mylist", "world", "hello")
|
|
r.rpush("mylist", "!")
|
|
print(r.lrange("mylist", 0, -1)) # ['hello', 'world', '!']
|
|
print(r.lpop("mylist")) # 'hello'
|
|
|
|
# HASH 사용
|
|
r.hset("myhash", "name", "John")
|
|
r.hset("myhash", "age", "30")
|
|
print(r.hget("myhash", "name")) # 'John'
|
|
print(r.hgetall("myhash")) # {'name': 'John', 'age': '30'}
|
|
``` |