strepsiades
412 lines
16 KiB
Python
412 lines
16 KiB
Python
import aiosqlite
|
|
import json
|
|
import os
|
|
import sqlite3
|
|
from typing import Optional, Dict, List, Any, TYPE_CHECKING
|
|
|
|
if TYPE_CHECKING:
|
|
from .sync_node import SyncNode
|
|
|
|
class PersistenceBackend:
|
|
"""
|
|
Persistence 负责同步系统运行时数据的持久化存储（aiosqlite 实现）。
|
|
主要作为 DataCollection 和 BindingManager 的后端存储。
|
|
"""
|
|
def __init__(self, db_path: str = ":memory:", backend: str = "sqlite"):
|
|
self.db_path = db_path
|
|
self.backend = backend
|
|
self.conn: Optional[aiosqlite.Connection] = None
|
|
|
|
@staticmethod
|
|
def _is_read_only_sql(sql: str) -> bool:
|
|
stmt = (sql or "").strip().lower()
|
|
return stmt.startswith("select") or stmt.startswith("pragma") or stmt.startswith("with")
|
|
|
|
@classmethod
|
|
def query_records(
|
|
cls,
|
|
*,
|
|
backend: str,
|
|
db_path: str,
|
|
sql: str,
|
|
limit: int = 200,
|
|
) -> tuple[List[str], List[Dict[str, Any]]]:
|
|
if backend != "sqlite":
|
|
raise NotImplementedError(f"records query backend not supported yet: {backend}")
|
|
if not cls._is_read_only_sql(sql):
|
|
raise ValueError("Only read-only SQL is allowed")
|
|
|
|
path = db_path
|
|
if not os.path.exists(path):
|
|
raise FileNotFoundError(f"DB not found: {path}")
|
|
|
|
with sqlite3.connect(path) as conn:
|
|
conn.row_factory = sqlite3.Row
|
|
cursor = conn.execute(sql)
|
|
rows = cursor.fetchmany(max(1, min(limit, 2000)))
|
|
columns = [item[0] for item in (cursor.description or [])]
|
|
data = [{k: row[k] for k in columns} for row in rows]
|
|
return columns, data
|
|
|
|
@classmethod
|
|
def records_summary(
|
|
cls,
|
|
*,
|
|
backend: str,
|
|
db_path: str,
|
|
) -> Dict[str, Any]:
|
|
summary: Dict[str, Any] = {
|
|
"backend": backend,
|
|
"db_path": db_path,
|
|
"db_exists": os.path.exists(db_path),
|
|
"tables": [],
|
|
"sample_bindings": [],
|
|
}
|
|
if not os.path.exists(db_path):
|
|
return summary
|
|
if backend != "sqlite":
|
|
summary["error"] = f"records summary backend not supported yet: {backend}"
|
|
return summary
|
|
|
|
with sqlite3.connect(db_path) as conn:
|
|
conn.row_factory = sqlite3.Row
|
|
tables = conn.execute(
|
|
"SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%' ORDER BY name"
|
|
).fetchall()
|
|
table_names = [str(r["name"]) for r in tables]
|
|
|
|
for name in table_names:
|
|
count = conn.execute(f"SELECT COUNT(1) AS c FROM {name}").fetchone()["c"]
|
|
summary["tables"].append({"name": name, "count": int(count)})
|
|
|
|
if "bindings" in table_names:
|
|
sample = conn.execute(
|
|
"SELECT node_type, local_id, remote_id FROM bindings ORDER BY last_updated DESC LIMIT 50"
|
|
).fetchall()
|
|
summary["sample_bindings"] = [
|
|
{
|
|
"node_type": row["node_type"],
|
|
"local_id": row["local_id"],
|
|
"remote_id": row["remote_id"],
|
|
}
|
|
for row in sample
|
|
]
|
|
return summary
|
|
|
|
async def initialize(self):
|
|
"""异步初始化数据库连接和表结构"""
|
|
if self.backend != "sqlite":
|
|
raise NotImplementedError(f"Persistence backend not supported yet: {self.backend}")
|
|
|
|
# 确保目录存在
|
|
if self.db_path != ":memory:":
|
|
dir_path = os.path.dirname(self.db_path)
|
|
if dir_path:
|
|
os.makedirs(dir_path, exist_ok=True)
|
|
|
|
self.conn = await aiosqlite.connect(self.db_path)
|
|
self.conn.row_factory = aiosqlite.Row
|
|
await self._init_db()
|
|
|
|
async def _init_db(self):
|
|
# 1. 节点表: 仅用于持久化存储 DataCollection 中的 SyncNode
|
|
# 注意: depend_ids不持久化，每次从data实时计算
|
|
await self.conn.execute("""
|
|
CREATE TABLE IF NOT EXISTS nodes (
|
|
collection_id TEXT NOT NULL,
|
|
node_id TEXT NOT NULL,
|
|
node_type TEXT NOT NULL,
|
|
data_id TEXT,
|
|
bind_data_id TEXT,
|
|
data TEXT,
|
|
origin_data TEXT,
|
|
action TEXT,
|
|
status TEXT,
|
|
binding_status TEXT,
|
|
error TEXT,
|
|
sync_log TEXT,
|
|
context TEXT,
|
|
PRIMARY KEY (collection_id, node_id)
|
|
)
|
|
""")
|
|
await self._ensure_nodes_schema()
|
|
|
|
# 2. 绑定表: 存储本地到远程的映射关系
|
|
# 只保留 local_id / remote_id 两字段（remote_id 可空）
|
|
await self._ensure_bindings_schema()
|
|
await self.conn.commit()
|
|
|
|
async def _ensure_nodes_schema(self) -> None:
|
|
cursor = await self.conn.execute("PRAGMA table_info(nodes)")
|
|
rows = await cursor.fetchall()
|
|
columns = [r[1] for r in rows] if rows else []
|
|
if "bind_data_id" not in columns:
|
|
await self.conn.execute("ALTER TABLE nodes ADD COLUMN bind_data_id TEXT")
|
|
|
|
async def _ensure_bindings_schema(self) -> None:
|
|
"""确保 bindings 表为 (node_type, local_id, remote_id) 结构。
|
|
|
|
若检测到旧表含 payload 列，则进行迁移。
|
|
"""
|
|
cursor = await self.conn.execute("PRAGMA table_info(bindings)")
|
|
rows = await cursor.fetchall()
|
|
columns = [r[1] for r in rows] if rows else []
|
|
|
|
if not columns:
|
|
await self.conn.execute("""
|
|
CREATE TABLE IF NOT EXISTS bindings (
|
|
node_type TEXT NOT NULL,
|
|
local_id TEXT NOT NULL,
|
|
remote_id TEXT,
|
|
last_updated TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
|
|
PRIMARY KEY (node_type, local_id)
|
|
)
|
|
""")
|
|
return
|
|
|
|
if "payload" in columns and "remote_id" not in columns:
|
|
# 迁移旧结构 payload -> remote_id
|
|
await self.conn.execute("""
|
|
CREATE TABLE IF NOT EXISTS bindings_new (
|
|
node_type TEXT NOT NULL,
|
|
local_id TEXT NOT NULL,
|
|
remote_id TEXT,
|
|
last_updated TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
|
|
PRIMARY KEY (node_type, local_id)
|
|
)
|
|
""")
|
|
|
|
async with self.conn.execute("SELECT node_type, local_id, payload FROM bindings") as cur:
|
|
old_rows = await cur.fetchall()
|
|
for row in old_rows:
|
|
try:
|
|
payload_dict = json.loads(row[2]) if row[2] else {}
|
|
except json.JSONDecodeError:
|
|
payload_dict = {}
|
|
remote_id = payload_dict.get("remote_id")
|
|
await self.conn.execute(
|
|
"INSERT OR REPLACE INTO bindings_new (node_type, local_id, remote_id) VALUES (?, ?, ?)",
|
|
(row[0], row[1], remote_id),
|
|
)
|
|
|
|
await self.conn.execute("DROP TABLE bindings")
|
|
await self.conn.execute("ALTER TABLE bindings_new RENAME TO bindings")
|
|
|
|
# --- DataCollection 支持 ---
|
|
|
|
async def save_node(self, collection_id: str, node: "SyncNode"):
|
|
"""保存或更新单个节点（depend_ids不持久化，运行时从data实时计算）"""
|
|
bind_data_id = None
|
|
if isinstance(node.context, dict):
|
|
value = node.context.get("bind_data_id")
|
|
if value is not None and value != "":
|
|
bind_data_id = str(value)
|
|
await self.conn.execute("""
|
|
INSERT OR REPLACE INTO nodes (
|
|
collection_id, node_id, node_type, data_id, bind_data_id,
|
|
data, origin_data, action, status, binding_status, error, sync_log, context
|
|
)
|
|
VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
|
|
""", (
|
|
collection_id,
|
|
node.node_id,
|
|
node.node_type,
|
|
node.data_id,
|
|
bind_data_id,
|
|
json.dumps(node.data) if node.data else None,
|
|
json.dumps(node.origin_data) if node.origin_data else None,
|
|
node.action.value,
|
|
node.status.value,
|
|
node.binding_status.value,
|
|
node.error,
|
|
node.sync_log,
|
|
json.dumps(node.context) if node.context else None
|
|
))
|
|
await self.conn.commit()
|
|
|
|
async def save_nodes_bulk(self, collection_id: str, nodes: List["SyncNode"]):
|
|
"""批量保存或更新节点 (单次提交，depend_ids不持久化)"""
|
|
if not nodes:
|
|
return
|
|
rows = []
|
|
for node in nodes:
|
|
bind_data_id = None
|
|
if isinstance(node.context, dict):
|
|
value = node.context.get("bind_data_id")
|
|
if value is not None and value != "":
|
|
bind_data_id = str(value)
|
|
rows.append((
|
|
collection_id,
|
|
node.node_id,
|
|
node.node_type,
|
|
node.data_id,
|
|
bind_data_id,
|
|
json.dumps(node.data) if node.data else None,
|
|
json.dumps(node.origin_data) if node.origin_data else None,
|
|
node.action.value,
|
|
node.status.value,
|
|
node.binding_status.value,
|
|
node.error,
|
|
node.sync_log,
|
|
json.dumps(node.context) if node.context else None
|
|
))
|
|
|
|
await self.conn.executemany("""
|
|
INSERT OR REPLACE INTO nodes (
|
|
collection_id, node_id, node_type, data_id, bind_data_id,
|
|
data, origin_data, action, status, binding_status, error, sync_log, context
|
|
)
|
|
VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
|
|
""", rows)
|
|
await self.conn.commit()
|
|
|
|
async def delete_node(self, collection_id: str, node_id: str):
|
|
"""删除单个节点"""
|
|
await self.conn.execute("DELETE FROM nodes WHERE collection_id = ? AND node_id = ?", (collection_id, node_id))
|
|
await self.conn.commit()
|
|
|
|
async def delete_nodes_bulk(self, collection_id: str, node_ids: List[str]):
|
|
"""批量删除节点 (单次提交)"""
|
|
if not node_ids:
|
|
return
|
|
rows = [(collection_id, node_id) for node_id in node_ids]
|
|
await self.conn.executemany(
|
|
"DELETE FROM nodes WHERE collection_id = ? AND node_id = ?",
|
|
rows,
|
|
)
|
|
await self.conn.commit()
|
|
|
|
async def load_nodes(self, collection_id: str) -> List[Dict[str, Any]]:
|
|
"""从特定 collection 中加载所有节点（depend_ids初始化为空，稍后从data实时计算）"""
|
|
async with self.conn.execute("SELECT * FROM nodes WHERE collection_id = ?", (collection_id,)) as cursor:
|
|
rows = await cursor.fetchall()
|
|
results = []
|
|
for row in rows:
|
|
results.append({
|
|
"node_id": row["node_id"],
|
|
"node_type": row["node_type"],
|
|
"data_id": row["data_id"],
|
|
"bind_data_id": row["bind_data_id"],
|
|
"depend_ids": [], # 不从数据库加载，运行时从data实时计算
|
|
"data": json.loads(row["data"]) if row["data"] else None,
|
|
"origin_data": json.loads(row["origin_data"]) if row["origin_data"] else None,
|
|
"action": row["action"],
|
|
"status": row["status"],
|
|
"binding_status": row["binding_status"],
|
|
"error": row["error"],
|
|
"sync_log": row["sync_log"],
|
|
"context": json.loads(row["context"]) if row["context"] else {}
|
|
})
|
|
if results[-1]["bind_data_id"] and isinstance(results[-1]["context"], dict):
|
|
results[-1]["context"]["bind_data_id"] = results[-1]["bind_data_id"]
|
|
return results
|
|
|
|
# --- BindingManager 支持 ---
|
|
|
|
async def save_binding(self, node_type: str, local_id: str, payload_dict: Dict[str, Any]):
|
|
"""保存或更新绑定关系及其元数据"""
|
|
remote_id = payload_dict.get("remote_id") if payload_dict else None
|
|
await self.conn.execute("""
|
|
INSERT OR REPLACE INTO bindings (node_type, local_id, remote_id)
|
|
VALUES (?, ?, ?)
|
|
""", (node_type, local_id, remote_id))
|
|
await self.conn.commit()
|
|
|
|
async def save_bindings_bulk(self, node_type: str, bindings: Dict[str, Optional[str]]):
|
|
"""批量保存或更新绑定关系 (单次提交)"""
|
|
if not bindings:
|
|
return
|
|
rows = []
|
|
for local_id, remote_id in bindings.items():
|
|
rows.append((node_type, local_id, remote_id))
|
|
await self.conn.executemany(
|
|
"INSERT OR REPLACE INTO bindings (node_type, local_id, remote_id) VALUES (?, ?, ?)",
|
|
rows,
|
|
)
|
|
await self.conn.commit()
|
|
|
|
async def delete_binding(self, node_type: str, local_id: str):
|
|
"""删除绑定关系"""
|
|
await self.conn.execute(
|
|
"DELETE FROM bindings WHERE node_type = ? AND local_id = ?",
|
|
(node_type, local_id)
|
|
)
|
|
await self.conn.commit()
|
|
|
|
async def delete_bindings_bulk(self, node_type: str, local_ids: List[str]):
|
|
"""批量删除绑定关系 (单次提交)"""
|
|
if not local_ids:
|
|
return
|
|
rows = [(node_type, local_id) for local_id in local_ids]
|
|
await self.conn.executemany(
|
|
"DELETE FROM bindings WHERE node_type = ? AND local_id = ?",
|
|
rows,
|
|
)
|
|
await self.conn.commit()
|
|
|
|
async def load_bindings(self, node_type: str) -> List[Dict[str, Any]]:
|
|
"""回写该类型下的所有绑定关系到内存"""
|
|
async with self.conn.execute(
|
|
"SELECT local_id, remote_id FROM bindings WHERE node_type = ?",
|
|
(node_type,)
|
|
) as cursor:
|
|
rows = await cursor.fetchall()
|
|
return [
|
|
{"local_id": r["local_id"], "payload": {"remote_id": r["remote_id"]}}
|
|
for r in rows
|
|
]
|
|
|
|
async def load_bind_data_id_overrides(self, node_type: str) -> Dict[str, Optional[str]]:
|
|
"""基于 bindings 表计算 node_id -> bind_data_id 覆盖映射。
|
|
|
|
规则：
|
|
- local 节点的 bind_data_id 取其绑定 remote 节点的 data_id
|
|
- remote 节点的 bind_data_id 取其绑定 local 节点的 data_id
|
|
"""
|
|
sql = """
|
|
SELECT b.local_id AS src_node_id, rn.data_id AS bind_data_id
|
|
FROM bindings b
|
|
LEFT JOIN nodes rn
|
|
ON rn.node_id = b.remote_id
|
|
AND rn.node_type = b.node_type
|
|
WHERE b.node_type = ?
|
|
|
|
UNION ALL
|
|
|
|
SELECT b.remote_id AS src_node_id, ln.data_id AS bind_data_id
|
|
FROM bindings b
|
|
LEFT JOIN nodes ln
|
|
ON ln.node_id = b.local_id
|
|
AND ln.node_type = b.node_type
|
|
WHERE b.node_type = ?
|
|
AND b.remote_id IS NOT NULL
|
|
"""
|
|
async with self.conn.execute(sql, (node_type, node_type)) as cursor:
|
|
rows = await cursor.fetchall()
|
|
result: Dict[str, Optional[str]] = {}
|
|
for row in rows:
|
|
src_node_id = row["src_node_id"]
|
|
if not src_node_id:
|
|
continue
|
|
result[str(src_node_id)] = row["bind_data_id"]
|
|
return result
|
|
|
|
async def dump_to_runtime(self, filename: str):
|
|
"""将当前状态转储到 _runtime 文件夹 (使用 VACUUM INTO)"""
|
|
runtime_path = os.path.join("_runtime", filename)
|
|
if os.path.exists(runtime_path):
|
|
os.remove(runtime_path)
|
|
|
|
# VACUUM INTO 是备份 SQLite 的推荐方式 (SQLite 3.27+)
|
|
await self.conn.execute("VACUUM INTO ?", (runtime_path,))
|
|
|
|
async def close(self):
|
|
"""关闭数据库连接（包含异常处理）"""
|
|
if self.conn:
|
|
try:
|
|
await self.conn.close()
|
|
except Exception as e:
|
|
print(f"⚠️ Error closing persistence: {e}")
|
|
finally:
|
|
self.conn = None
|