数据库重构

src/chat/emoji_system/emoji_manager.py

@@ -14,7 +14,7 @@ from PIL import Image
 from rich.traceback import install
 from sqlalchemy import select
 from src.common.database.database import db
-from src.common.database.sqlalchemy_database_api import get_session
+from src.common.database.sqlalchemy_database_api import get_db_session
 from src.common.database.sqlalchemy_models import Emoji, Images
 from src.common.logger import get_logger
 from src.config.config import global_config, model_config
@@ -30,8 +30,6 @@ EMOJI_DIR = os.path.join(BASE_DIR, "emoji")  # 表情包存储目录
 EMOJI_REGISTERED_DIR = os.path.join(BASE_DIR, "emoji_registed")  # 已注册的表情包注册目录
 MAX_EMOJI_FOR_PROMPT = 20  # 最大允许的表情包描述数量于图片替换的 prompt 中
 
-session = get_session()
-
 """
 还没经过测试，有些地方数据库和内存数据同步可能不完全
 
@@ -152,6 +150,7 @@ class MaiEmoji:
             # --- 数据库操作 ---
             try:
                 # 准备数据库记录 for emoji collection
+                with get_db_session() as session:
                     emotion_str = ",".join(self.emotion) if self.emotion else ""
 
                     emoji = Emoji(
@@ -205,14 +204,15 @@ class MaiEmoji:
 
             # 2. 删除数据库记录
             try:
+                with get_db_session() as session:
                     will_delete_emoji = session.execute(select(Emoji).where(Emoji.emoji_hash == self.hash)).scalar_one_or_none()
                     if will_delete_emoji is None:
                         logger.warning(f"[删除] 数据库中未找到哈希值为 {self.hash} 的表情包记录。")
                         result = 0  # Indicate no DB record was deleted
                     else:
                         session.delete(will_delete_emoji)
-                    session.commit()
                         result = 1  # Successfully deleted one record
+                        session.commit()
             except Exception as e:
                 logger.error(f"[错误] 删除数据库记录时出错: {str(e)}")
                 result = 0
@@ -403,35 +403,36 @@ class EmojiManager:
 
     def initialize(self) -> None:
         """初始化数据库连接和表情目录"""
-        try:
-            db.connect(reuse_if_open=True)
-            if db.is_closed():
-                raise RuntimeError("数据库连接失败")
-            _ensure_emoji_dir()
-            self._initialized = True  # 标记为已初始化
-            logger.info("EmojiManager初始化成功")
-        except Exception as e:
-            logger.error(f"EmojiManager初始化失败: {e}")
-            self._initialized = False
-            raise
+    #     try:
+    #         db.connect(reuse_if_open=True)
+    #         if db.is_closed():
+    #             raise RuntimeError("数据库连接失败")
+    #         _ensure_emoji_dir()
+    #         self._initialized = True  # 标记为已初始化
+    #         logger.info("EmojiManager初始化成功")
+    #     except Exception as e:
+    #         logger.error(f"EmojiManager初始化失败: {e}")
+    #         self._initialized = False
+    #         raise
 
-    def _ensure_db(self) -> None:
-        """确保数据库已初始化"""
-        if not self._initialized:
-            self.initialize()
-        if not self._initialized:
-            raise RuntimeError("EmojiManager not initialized")
+    # def _ensure_db(self) -> None:
+    #     """确保数据库已初始化"""
+    #     if not self._initialized:
+    #         self.initialize()
+    #     if not self._initialized:
+    #         raise RuntimeError("EmojiManager not initialized")
 
     def record_usage(self, emoji_hash: str) -> None:
         """记录表情使用次数"""
         try:
+            with get_db_session() as session:
                 emoji_update = session.execute(select(Emoji).where(Emoji.emoji_hash == emoji_hash)).scalar_one_or_none()
                 if emoji_update is None:
                     logger.error(f"记录表情使用失败: 未找到 hash 为 {emoji_hash} 的表情包")
                 else:
                     emoji_update.usage_count += 1
                 emoji_update.last_used_time = time.time()  # Update last used time
-                session.commit()  # Persist changes to DB
+                session.commit()
         except Exception as e:
             logger.error(f"记录表情使用失败: {str(e)}")
 
@@ -659,6 +660,7 @@ class EmojiManager:
     async def get_all_emoji_from_db(self) -> None:
         """获取所有表情包并初始化为MaiEmoji类对象，更新 self.emoji_objects"""
         try:
+            with get_db_session() as session:
                 self._ensure_db()
                 logger.debug("[数据库] 开始加载所有表情包记录 ...")
 
@@ -673,6 +675,7 @@ class EmojiManager:
             if load_errors > 0:
                 logger.warning(f"[数据库] 加载过程中出现 {load_errors} 个错误。")
             
+
         except Exception as e:
             logger.error(f"[错误] 从数据库加载所有表情包对象失败: {str(e)}")
             self.emoji_objects = []  # 加载失败则清空列表
@@ -688,6 +691,7 @@ class EmojiManager:
             list[MaiEmoji]: 表情包对象列表
         """
         try:
+            with get_db_session() as session:
                 self._ensure_db()
 
             if emoji_hash:
@@ -703,7 +707,6 @@ class EmojiManager:
 
             if load_errors > 0:
                 logger.warning(f"[查询] 加载过程中出现 {load_errors} 个错误。")
-
             return emoji_objects
 
         except Exception as e:
@@ -744,6 +747,7 @@ class EmojiManager:
             # 如果内存中没有，从数据库查找
             self._ensure_db()
             try:
+                with get_db_session() as session:
                     emoji_record = session.execute(select(Emoji).where(Emoji.emoji_hash == emoji_hash)).scalar_one_or_none()
                 if emoji_record and emoji_record.description:
                     logger.info(f"[缓存命中] 从数据库获取表情包描述: {emoji_record.description[:50]}...")
@@ -751,6 +755,7 @@ class EmojiManager:
             except Exception as e:
                 logger.error(f"从数据库查询表情包描述时出错: {e}")
 
+
             return None
 
         except Exception as e:
@@ -905,6 +910,7 @@ class EmojiManager:
             # 尝试从Images表获取已有的详细描述（可能在收到表情包时已生成）
             existing_description = None
             try:
+                with get_db_session() as session:
                 # from src.common.database.database_model_compat import Images
 
                     stmt = select(Images).where((Images.emoji_hash == image_hash) & (Images.type == "emoji"))

src/chat/express/expression_learner.py

@@ -7,7 +7,7 @@ from datetime import datetime
 from typing import List, Dict, Optional, Any, Tuple
 
 from src.common.logger import get_logger
-from src.common.database.sqlalchemy_database_api import get_session
+from src.common.database.sqlalchemy_database_api import get_db_session
 from sqlalchemy import select
 from src.common.database.sqlalchemy_models import Expression
 from src.llm_models.utils_model import LLMRequest
@@ -22,7 +22,6 @@ DECAY_DAYS = 30  # 30天衰减到0.01
 DECAY_MIN = 0.01  # 最小衰减值
 
 logger = get_logger("expressor")
-session = get_session()
 
 def format_create_date(timestamp: float) -> str:
     """
@@ -204,6 +203,7 @@ class ExpressionLearner:
         learnt_grammar_expressions = []
 
         # 直接从数据库查询
+        with get_db_session() as session:
             style_query = session.execute(select(Expression).where((Expression.chat_id == self.chat_id) & (Expression.type == "style")))
         for expr in style_query.scalars():
             # 确保create_date存在，如果不存在则使用last_active_time
@@ -247,6 +247,7 @@ class ExpressionLearner:
         对数据库中的所有表达方式应用全局衰减
         """
         try:
+            with get_db_session() as session:
                 # 获取所有表达方式
                 all_expressions = session.execute(select(Expression)).scalars()
 
@@ -265,19 +266,19 @@ class ExpressionLearner:
                 if new_count <= 0.01:
                     # 如果count太小，删除这个表达方式
                     session.delete(expr)
+                    session.commit()
                     deleted_count += 1
                 else:
                     # 更新count
                     expr.count = new_count
                     updated_count += 1
 
-            session.commit()
+            
 
             if updated_count > 0 or deleted_count > 0:
                 logger.info(f"全局衰减完成：更新了 {updated_count} 个表达方式，删除了 {deleted_count} 个表达方式")
 
         except Exception as e:
-            session.rollback()
             logger.error(f"数据库全局衰减失败: {e}")
 
     def calculate_decay_factor(self, time_diff_days: float) -> float:
@@ -355,6 +356,7 @@ class ExpressionLearner:
         for chat_id, expr_list in chat_dict.items():
             for new_expr in expr_list:
                 # 查找是否已存在相似表达方式
+                with get_db_session() as session:
                     query = session.execute(select(Expression).where(
                     (Expression.chat_id == chat_id)
                     & (Expression.type == type)
@@ -380,6 +382,7 @@ class ExpressionLearner:
                             create_date=current_time,  # 手动设置创建日期
                         )
                         session.add(new_expression)
+                        session.commit()
                 # 限制最大数量
                 exprs = list(
                     session.execute(select(Expression)
@@ -391,6 +394,7 @@ class ExpressionLearner:
                     for expr in exprs[: len(exprs) - MAX_EXPRESSION_COUNT]:
                         session.delete(expr)
                         session.commit()
+                
             return learnt_expressions
 
     async def learn_expression(self, type: str, num: int = 10) -> Optional[Tuple[List[Tuple[str, str, str]], str]]:
@@ -574,7 +578,7 @@ class ExpressionLearnerManager:
                             continue
 
                         # 查重：同chat_id+type+situation+style
-
+                        with get_db_session() as session:
                             query = session.execute(select(Expression).where(
                             (Expression.chat_id == chat_id)
                             & (Expression.type == type_str)
@@ -596,6 +600,8 @@ class ExpressionLearnerManager:
                                 create_date=last_active_time,  # 迁移时使用last_active_time作为创建时间
                             )
                             session.add(new_expression)
+                            session.commit()
+                            
                             migrated_count += 1
                     logger.info(f"已迁移 {expr_file} 到数据库，包含 {len(expressions)} 个表达方式")
                 except json.JSONDecodeError as e:
@@ -627,6 +633,7 @@ class ExpressionLearnerManager:
         使用last_active_time作为create_date的默认值
         """
         try:
+            with get_db_session() as session:
                 # 查找所有create_date为空的表达方式
                 old_expressions = session.execute(select(Expression).where(Expression.create_date.is_(None))).scalars()
                 updated_count = 0
@@ -636,12 +643,12 @@ class ExpressionLearnerManager:
                     expr.create_date = expr.last_active_time
                     updated_count += 1
 
-            session.commit()
+                
 
                 if updated_count > 0:
                     logger.info(f"已为 {updated_count} 个老的表达方式设置创建日期")
+                session.commit()
         except Exception as e:
-            session.rollback()
             logger.error(f"迁移老数据创建日期失败: {e}")
 
 

src/chat/express/expression_selector.py

@@ -12,8 +12,7 @@ from src.common.logger import get_logger
 from sqlalchemy import select
 from src.common.database.sqlalchemy_models import Expression
 from src.chat.utils.prompt_builder import Prompt, global_prompt_manager
-from src.common.database.sqlalchemy_database_api import get_session
-session = get_session()
+from src.common.database.sqlalchemy_database_api import get_db_session
 
 logger = get_logger("expression_selector")
 
@@ -132,7 +131,7 @@ class ExpressionSelector:
         # sourcery skip: extract-duplicate-method, move-assign
         # 支持多chat_id合并抽选
         related_chat_ids = self.get_related_chat_ids(chat_id)
-
+        with get_db_session() as session:
         # 优化：一次性查询所有相关chat_id的表达方式
             style_query = session.execute(select(Expression).where(
                 (Expression.chat_id.in_(related_chat_ids)) & (Expression.type == "style")
@@ -180,6 +179,7 @@ class ExpressionSelector:
             selected_grammar = weighted_sample(grammar_exprs, grammar_weights, grammar_num)
         else:
             selected_grammar = []
+        
         return selected_style, selected_grammar
 
     def update_expressions_count_batch(self, expressions_to_update: List[Dict[str, Any]], increment: float = 0.1):
@@ -199,6 +199,7 @@ class ExpressionSelector:
             if key not in updates_by_key:
                 updates_by_key[key] = expr
         for chat_id, expr_type, situation, style in updates_by_key:
+            with get_db_session() as session:
                 query = session.execute(select(Expression).where(
                 (Expression.chat_id == chat_id)
                 & (Expression.type == expr_type)
@@ -211,10 +212,11 @@ class ExpressionSelector:
                 new_count = min(current_count + increment, 5.0)
                 expr_obj.count = new_count
                 expr_obj.last_active_time = time.time()
-                session.commit()
+                
                 logger.debug(
                     f"表达方式激活: 原count={current_count:.3f}, 增量={increment}, 新count={new_count:.3f} in db"
                 )
+            session.commit()
 
     async def select_suitable_expressions_llm(
         self,

src/chat/memory_system/Hippocampus.py

@@ -19,7 +19,7 @@ from src.config.config import global_config, model_config
 from sqlalchemy import select,insert,update,delete
 from src.common.database.sqlalchemy_models import Messages, GraphNodes, GraphEdges  # SQLAlchemy Models导入
 from src.common.logger import get_logger
-from src.common.database.sqlalchemy_database_api import get_session
+from src.common.database.sqlalchemy_database_api import get_db_session
 from src.chat.memory_system.sample_distribution import MemoryBuildScheduler  # 分布生成器
 from src.chat.utils.chat_message_builder import (
     get_raw_msg_by_timestamp,
@@ -30,7 +30,6 @@ from src.chat.utils.utils import translate_timestamp_to_human_readable
 
 
 install(extra_lines=3)
-session = get_session()
 
 def calculate_information_content(text):
     """计算文本的信息量（熵）"""
@@ -862,7 +861,7 @@ class EntorhinalCortex:
                         for message in messages:
                             # 确保在更新前获取最新的 memorized_times
                             current_memorized_times = message.get("memorized_times", 0)
-                            # 使用 SQLAlchemy 2.0 更新记录
+                            with get_db_session() as session:
                                 session.execute(
                                 update(Messages)
                                 .where(Messages.message_id == message["message_id"])
@@ -882,6 +881,7 @@ class EntorhinalCortex:
         current_time = datetime.datetime.now().timestamp()
 
         # 获取数据库中所有节点和内存中所有节点
+        with get_db_session() as session:
             db_nodes = {node.concept: node for node in session.execute(select(GraphNodes)).scalars()}
             memory_nodes = list(self.memory_graph.G.nodes(data=True))
 
@@ -951,7 +951,7 @@ class EntorhinalCortex:
                 for i in range(0, len(nodes_to_create), batch_size):
                     batch = nodes_to_create[i : i + batch_size]
                     session.execute(insert(GraphNodes), batch)
-                session.commit()
+                    
 
             if nodes_to_update:
                 batch_size = 100
@@ -963,11 +963,11 @@ class EntorhinalCortex:
                             .where(GraphNodes.concept == node_data["concept"])
                             .values(**{k: v for k, v in node_data.items() if k != "concept"})
                         )
-                session.commit()
+                    
 
             if nodes_to_delete:
                 session.execute(delete(GraphNodes).where(GraphNodes.concept.in_(nodes_to_delete)))
-            session.commit()
+                
 
             # 处理边的信息
             db_edges = list(session.execute(select(GraphEdges)).scalars())
@@ -1023,7 +1023,7 @@ class EntorhinalCortex:
                 for i in range(0, len(edges_to_create), batch_size):
                     batch = edges_to_create[i : i + batch_size]
                     session.execute(insert(GraphEdges), batch)
-                session.commit()
+                    
 
             if edges_to_update:
                 batch_size = 100
@@ -1037,15 +1037,19 @@ class EntorhinalCortex:
                             )
                             .values(**{k: v for k, v in edge_data.items() if k not in ["source", "target"]})
                         )
-                session.commit()
+                    
 
             if edges_to_delete:
                 for source, target in edges_to_delete:
                     session.execute(
                         delete(GraphEdges).where((GraphEdges.source == source) & (GraphEdges.target == target))
                     )
+
+            # 提交事务
             session.commit()
 
+                
+
         end_time = time.time()
         logger.info(f"[同步] 总耗时: {end_time - start_time:.2f}秒")
         logger.info(f"[同步] 同步了 {len(memory_nodes)} 个节点和 {len(memory_edges)} 条边")
@@ -1056,10 +1060,11 @@ class EntorhinalCortex:
         logger.info("[数据库] 开始重新同步所有记忆数据...")
 
         # 清空数据库
+        with get_db_session() as session:
             clear_start = time.time()
             session.execute(delete(GraphNodes))
             session.execute(delete(GraphEdges))
-        session.commit()
+            
             clear_end = time.time()
             logger.info(f"[数据库] 清空数据库耗时: {clear_end - clear_start:.2f}秒")
 
@@ -1117,7 +1122,7 @@ class EntorhinalCortex:
                 for i in range(0, len(nodes_data), batch_size):
                     batch = nodes_data[i : i + batch_size]
                     session.execute(insert(GraphNodes), batch)
-                session.commit()
+                    
             node_end = time.time()
             logger.info(f"[数据库] 写入 {len(nodes_data)} 个节点耗时: {node_end - node_start:.2f}秒")
 
@@ -1129,6 +1134,7 @@ class EntorhinalCortex:
                     batch = edges_data[i : i + batch_size]
                     session.execute(insert(GraphEdges), batch)
             session.commit()
+            
         edge_end = time.time()
         logger.info(f"[数据库] 写入 {len(edges_data)} 条边耗时: {edge_end - edge_start:.2f}秒")
 
@@ -1145,6 +1151,7 @@ class EntorhinalCortex:
         self.memory_graph.G.clear()
 
         # 从数据库加载所有节点
+        with get_db_session() as session:
             nodes = list(session.execute(select(GraphNodes)).scalars())
             for node in nodes:
                 concept = node.concept
@@ -1166,7 +1173,7 @@ class EntorhinalCortex:
                         session.execute(
                             update(GraphNodes).where(GraphNodes.concept == concept).values(**update_data)
                         )
-                    session.commit()
+                        
 
                     # 获取时间信息(如果不存在则使用当前时间)
                     created_time = node.created_time or current_time
@@ -1202,7 +1209,7 @@ class EntorhinalCortex:
                         .where((GraphEdges.source == source) & (GraphEdges.target == target))
                         .values(**update_data)
                     )
-                session.commit()
+                    
 
                 # 获取时间信息(如果不存在则使用当前时间)
                 created_time = edge.created_time or current_time
@@ -1213,6 +1220,7 @@ class EntorhinalCortex:
                     self.memory_graph.G.add_edge(
                         source, target, strength=strength, created_time=created_time, last_modified=last_modified
                     )
+            session.commit()
 
             if need_update:
                 logger.info("[数据库] 已为缺失的时间字段进行补充")

src/chat/memory_system/instant_memory.py

@@ -11,12 +11,11 @@ from datetime import datetime, timedelta
 from src.llm_models.utils_model import LLMRequest
 from src.common.logger import get_logger
 from src.common.database.sqlalchemy_models import Memory  # SQLAlchemy Models导入
-from src.common.database.sqlalchemy_database_api import get_session
+from src.common.database.sqlalchemy_database_api import get_db_session
 from src.config.config import model_config
 
 from sqlalchemy import select
 logger = get_logger(__name__)
-session = get_session()
 
 class MemoryItem:
     def __init__(self, memory_id: str, chat_id: str, memory_text: str, keywords: list[str]):
@@ -113,6 +112,7 @@ class InstantMemory:
             logger.info(f"不需要记忆：{text}")
 
     async def store_memory(self, memory_item: MemoryItem):
+        with get_db_session() as session:
             memory = Memory(
             memory_id=memory_item.memory_id,
             chat_id=memory_item.chat_id,
@@ -165,9 +165,11 @@ class InstantMemory:
                 logger.info(f"start_time: {start_time}, end_time: {end_time}")
                 # 检索包含关键词的记忆
                 memories_set = set()
+                with get_db_session() as session:
                     if start_time and end_time:
                         start_ts = start_time.timestamp()
                         end_ts = end_time.timestamp()
+                        
                         query = session.execute(select(Memory).where(
                             (Memory.chat_id == self.chat_id)
                             & (Memory.create_time >= start_ts)
@@ -175,7 +177,6 @@ class InstantMemory:
                         )).scalars()
                     else:
                         query = session.execute(select(Memory).where(Memory.chat_id == self.chat_id)).scalars()
-
                 for mem in query:
                     # 对每条记忆
                     mem_keywords = mem.keywords or ""

src/chat/message_receive/bot.py

@@ -274,6 +274,7 @@ class ChatBot:
             #     logger.warning(f"检测到消息中含有违法，色情，暴力，反动，敏感内容，消息内容：{message.processed_plain_text}，发送者：{message.message_info.user_info.user_nickname}")
             #     return
 
+            
             # 过滤检查
             if _check_ban_words(message.processed_plain_text, chat, user_info) or _check_ban_regex(  # type: ignore
                 message.raw_message,  # type: ignore

src/chat/message_receive/chat_stream.py

@@ -12,7 +12,7 @@ from sqlalchemy import select, text
 from sqlalchemy.dialects.sqlite import insert as sqlite_insert
 from sqlalchemy.dialects.mysql import insert as mysql_insert
 from src.common.database.sqlalchemy_models import ChatStreams  # 新增导入
-from src.common.database.sqlalchemy_database_api import get_session
+from src.common.database.sqlalchemy_database_api import get_db_session
 from src.config.config import global_config  # 新增导入
 # 避免循环导入，使用TYPE_CHECKING进行类型提示
 if TYPE_CHECKING:
@@ -23,7 +23,6 @@ install(extra_lines=3)
 
 
 logger = get_logger("chat_stream")
-session = get_session()
 
 class ChatMessageContext:
     """聊天消息上下文，存储消息的上下文信息"""
@@ -132,13 +131,14 @@ class ChatManager:
         if not self._initialized:
             self.streams: Dict[str, ChatStream] = {}  # stream_id -> ChatStream
             self.last_messages: Dict[str, "MessageRecv"] = {}  # stream_id -> last_message
-            try:
-                db.connect(reuse_if_open=True)
-                # 确保 ChatStreams 表存在
-                session.execute(text("CREATE TABLE IF NOT EXISTS chat_streams (stream_id TEXT PRIMARY KEY, platform TEXT, create_time REAL, last_active_time REAL, user_platform TEXT, user_id TEXT, user_nickname TEXT, user_cardname TEXT, group_platform TEXT, group_id TEXT, group_name TEXT)"))
-                session.commit()
-            except Exception as e:
-                logger.error(f"数据库连接或 ChatStreams 表创建失败: {e}")
+            # try:
+                # with get_db_session() as session:
+                #     db.connect(reuse_if_open=True)
+                #     # 确保 ChatStreams 表存在
+                #     session.execute(text("CREATE TABLE IF NOT EXISTS chat_streams (stream_id TEXT PRIMARY KEY, platform TEXT, create_time REAL, last_active_time REAL, user_platform TEXT, user_id TEXT, user_nickname TEXT, user_cardname TEXT, group_platform TEXT, group_id TEXT, group_name TEXT)"))
+                #     session.commit()
+            # except Exception as e:
+            #     logger.error(f"数据库连接或 ChatStreams 表创建失败: {e}")
 
             self._initialized = True
             # 在事件循环中启动初始化
@@ -236,6 +236,7 @@ class ChatManager:
 
             # 检查数据库中是否存在
             def _db_find_stream_sync(s_id: str):
+                with get_db_session() as session:
                     return session.execute(select(ChatStreams).where(ChatStreams.stream_id == s_id)).scalar()
 
             model_instance = await asyncio.to_thread(_db_find_stream_sync, stream_id)
@@ -331,6 +332,7 @@ class ChatManager:
         stream_data_dict = stream.to_dict()
 
         def _db_save_stream_sync(s_data_dict: dict):
+            with get_db_session() as session:
                 user_info_d = s_data_dict.get("user_info")
                 group_info_d = s_data_dict.get("group_info")
 
@@ -387,6 +389,7 @@ class ChatManager:
 
         def _db_load_all_streams_sync():
             loaded_streams_data = []
+            with get_db_session() as session:
                 for model_instance in session.execute(select(ChatStreams)).scalars():
                     user_info_data = {
                         "platform": model_instance.user_platform,
@@ -411,6 +414,7 @@ class ChatManager:
                         "last_active_time": model_instance.last_active_time,
                     }
                     loaded_streams_data.append(data_for_from_dict)
+                session.commit()
             return loaded_streams_data
 
         try:

src/chat/message_receive/storage.py

@@ -7,7 +7,7 @@ from src.common.database.sqlalchemy_models import Messages, Images
 from src.common.logger import get_logger
 from .chat_stream import ChatStream
 from .message import MessageSending, MessageRecv
-from src.common.database.sqlalchemy_database_api import get_session
+from src.common.database.sqlalchemy_database_api import get_db_session
 from sqlalchemy import select, update, desc
 
 logger = get_logger("message_storage")
@@ -70,7 +70,6 @@ class MessageStorage:
             priority_info_json = json.dumps(priority_info) if priority_info else None
 
             # 获取数据库会话
-            session = get_session()
 
             new_message = Messages(
                 message_id=msg_id,
@@ -104,8 +103,10 @@ class MessageStorage:
                 is_notify=is_notify,
                 is_command=is_command,
             )
+            with get_db_session() as session:
                 session.add(new_message)
                 session.commit()
+                
         except Exception:
             logger.exception("存储消息失败")
             logger.error(f"消息：{message}")
@@ -155,7 +156,8 @@ class MessageStorage:
                     session.execute(
                         update(Messages).where(Messages.id == matched_message.id).values(message_id=qq_message_id)
                     )
-                    # session.commit() 会在上下文管理器中自动调用
+                    session.commit()
+                    #  会在上下文管理器中自动调用
                     logger.debug(f"更新消息ID成功: {matched_message.message_id} -> {qq_message_id}")
                 else:
                     logger.warning(f"未找到匹配的消息记录: {mmc_message_id}")
@@ -184,6 +186,7 @@ class MessageStorage:
                     image_record = session.execute(
                         select(Images).where(Images.description == description).order_by(desc(Images.timestamp))
                     ).scalar()
+                    session.commit()
                     return f"[picid:{image_record.image_id}]" if image_record else match.group(0)
             except Exception:
                 return match.group(0)

src/chat/utils/chat_message_builder.py

@@ -10,7 +10,7 @@ from src.common.message_repository import find_messages, count_messages
 from src.common.database.sqlalchemy_models import ActionRecords, Images
 from src.person_info.person_info import PersonInfoManager, get_person_info_manager
 from src.chat.utils.utils import translate_timestamp_to_human_readable, assign_message_ids
-from src.common.database.sqlalchemy_database_api import get_session
+from src.common.database.sqlalchemy_database_api import get_db_session
 from sqlalchemy import select, and_
 
 install(extra_lines=3)

src/chat/utils/statistic.py

@@ -420,7 +420,7 @@ class StatisticOutputTask(AsyncTask):
                         stats[period_key][COST_BY_MODULE][module_name] += cost
                         
                         # 收集time_cost数据
-                        time_cost = record.time_cost or 0.0
+                        time_cost = record.get('time_cost') or 0.0
                         if time_cost > 0:  # 只记录有效的time_cost
                             stats[period_key][TIME_COST_BY_TYPE][request_type].append(time_cost)
                             stats[period_key][TIME_COST_BY_USER][user_id].append(time_cost)

src/chat/utils/utils_image.py

@@ -41,12 +41,12 @@ class ImageManager:
             self._initialized = True
             self.vlm = LLMRequest(model_set=model_config.model_task_config.vlm, request_type="image")
 
-            try:
-                db.connect(reuse_if_open=True)
-                # 使用SQLAlchemy创建表已在初始化时完成
-                logger.debug("使用SQLAlchemy进行表管理")
-            except Exception as e:
-                logger.error(f"数据库连接失败: {e}")
+            # try:
+            #     db.connect(reuse_if_open=True)
+            #     # 使用SQLAlchemy创建表已在初始化时完成
+            #     logger.debug("使用SQLAlchemy进行表管理")
+            # except Exception as e:
+            #     logger.error(f"数据库连接失败: {e}")
 
             self._initialized = True
 
@@ -105,7 +105,8 @@ class ImageManager:
                         timestamp=current_timestamp
                     )
                     session.add(new_desc)
-                # session.commit() 会在上下文管理器中自动调用
+                    session.commit()
+                #  会在上下文管理器中自动调用
         except Exception as e:
             logger.error(f"保存描述到数据库失败 (SQLAlchemy): {str(e)}")
             
@@ -246,7 +247,8 @@ class ImageManager:
                                 timestamp=current_timestamp,
                             )
                             session.add(new_img)
-                        # session.commit() 会在上下文管理器中自动调用
+                            session.commit()
+                        #  会在上下文管理器中自动调用
                 except Exception as e:
                     logger.error(f"保存到Images表失败: {str(e)}")
 
@@ -323,7 +325,7 @@ class ImageManager:
                         existing_image.image_id = str(uuid.uuid4())
                     if not hasattr(existing_image, "vlm_processed") or existing_image.vlm_processed is None:
                         existing_image.vlm_processed = True
-                    session.commit()
+                    
                     logger.debug(f"[数据库] 更新已有图片记录: {image_hash[:8]}...")
                 else:
                     new_img = Images(
@@ -337,7 +339,7 @@ class ImageManager:
                         count=1,
                     )
                     session.add(new_img)
-                    session.commit()
+                    
                     logger.debug(f"[数据库] 创建新图片记录: {image_hash[:8]}...")
             except Exception as e:
                 logger.error(f"保存图片文件或元数据失败: {str(e)}")
@@ -511,7 +513,7 @@ class ImageManager:
                             existing_image.vlm_processed = False
 
                     existing_image.count += 1
-                    session.commit()
+                    
                     return existing_image.image_id, f"[picid:{existing_image.image_id}]"
 
                 # print(f"图片不存在: {image_hash}")
@@ -581,7 +583,7 @@ class ImageManager:
                     logger.debug(f"[缓存复用] 从其他相同图片记录复用描述: {existing_with_description.description[:50]}...")
                     image.description = existing_with_description.description
                     image.vlm_processed = True
-                    session.commit()
+                    
                     # 同时保存到ImageDescriptions表作为备用缓存
                     self._save_description_to_db(image_hash, existing_with_description.description, "image")
                     return
@@ -591,7 +593,7 @@ class ImageManager:
                     logger.debug(f"[缓存复用] 从ImageDescriptions表复用描述: {cached_description[:50]}...")
                     image.description = cached_description
                     image.vlm_processed = True
-                    session.commit()
+                    
                     return
 
                 # 获取图片格式

src/common/database/database.py

@@ -6,7 +6,7 @@ from src.common.logger import get_logger
 
 # SQLAlchemy相关导入
 from src.common.database.sqlalchemy_init import initialize_database_compat
-from src.common.database.sqlalchemy_models import get_engine, get_session
+from src.common.database.sqlalchemy_models import get_engine, get_db_session
 
 install(extra_lines=3)
 
@@ -18,7 +18,7 @@ logger = get_logger("database")
 
 # 兼容性：为了不破坏现有代码，保留db变量但指向SQLAlchemy
 class DatabaseProxy:
-    """数据库代理类，提供Peewee到SQLAlchemy的兼容性接口"""
+    """数据库代理类"""
     
     def __init__(self):
         self._engine = None
@@ -28,56 +28,7 @@ class DatabaseProxy:
         """初始化数据库连接"""
         return initialize_database_compat()
     
-    def connect(self, reuse_if_open=True):
-        """连接数据库（兼容性方法）"""
-        try:
-            self._engine = get_engine()
-            return True
-        except Exception as e:
-            logger.error(f"数据库连接失败: {e}")
-            return False
 
-    def is_closed(self):
-        """检查数据库是否关闭（兼容性方法）"""
-        return self._engine is None
-    
-    def create_tables(self, models, safe=True):
-        """创建表（兼容性方法）"""
-        try:
-            from src.common.database.sqlalchemy_models import Base
-            engine = get_engine()
-            Base.metadata.create_all(bind=engine)
-            return True
-        except Exception as e:
-            logger.error(f"创建表失败: {e}")
-            return False
-    
-    def table_exists(self, model):
-        """检查表是否存在（兼容性方法）"""
-        try:
-            from sqlalchemy import inspect
-            engine = get_engine()
-            inspector = inspect(engine)
-            table_name = getattr(model, '_meta', {}).get('table_name', model.__name__.lower())
-            return table_name in inspector.get_table_names()
-        except Exception:
-            return False
-    
-    def execute_sql(self, sql):
-        """执行SQL（兼容性方法）"""
-        try:
-            from sqlalchemy import text
-            session = get_session()
-            result = session.execute(text(sql))
-            session.close()
-            return result
-        except Exception as e:
-            logger.error(f"执行SQL失败: {e}")
-            raise
-    
-    def atomic(self):
-        """事务上下文管理器（兼容性方法）"""
-        return SQLAlchemyTransaction()
 
 class SQLAlchemyTransaction:
     """SQLAlchemy事务上下文管理器"""
@@ -86,7 +37,7 @@ class SQLAlchemyTransaction:
         self.session = None
     
     def __enter__(self):
-        self.session = get_session()
+        self.session = get_db_session()
         return self.session
     
     def __exit__(self, exc_type, exc_val, exc_tb):

src/common/database/sqlalchemy_database_api.py

@@ -15,7 +15,7 @@ from src.common.logger import get_logger
 from src.common.database.sqlalchemy_models import (
     Base, get_db_session, Messages, ActionRecords, PersonInfo, ChatStreams,
     LLMUsage, Emoji, Images, ImageDescriptions, OnlineTime, Memory,
-    Expression, ThinkingLog, GraphNodes, GraphEdges, Schedule, MaiZoneScheduleStatus, get_session
+    Expression, ThinkingLog, GraphNodes, GraphEdges, Schedule, MaiZoneScheduleStatus
 )
 
 logger = get_logger("sqlalchemy_database_api")
@@ -41,38 +41,9 @@ MODEL_MAPPING = {
 }
 
 
-@contextmanager
-def get_db_session():
-    """数据库会话上下文管理器，自动处理事务和连接错误"""
-    session = None
-    max_retries = 3
-    retry_delay = 1.0
-
-    for attempt in range(max_retries):
-        try:
-            session = get_session()
-            yield session
-            session.commit()
-            break
-        except (DisconnectionError, OperationalError) as e:
-            logger.warning(f"数据库连接错误 (尝试 {attempt + 1}/{max_retries}): {e}")
-            if session:
-                session.rollback()
-                session.close()
-            if attempt < max_retries - 1:
-                time.sleep(retry_delay * (attempt + 1))
-            else:
-                raise
-        except Exception:
-            if session:
-                session.rollback()
-            raise
-        finally:
-            if session:
-                session.close()
 
 
-def build_filters(session: Session, model_class: Type[Base], filters: Dict[str, Any]):
+def build_filters(session, model_class: Type[Base], filters: Dict[str, Any]):
     """构建查询过滤条件"""
     conditions = []
 
@@ -296,6 +267,7 @@ async def db_save(
             # 创建新记录
             new_record = model_class(**data)
             session.add(new_record)
+            session.commit()
             session.flush()
 
             # 转换为字典格式返回
@@ -415,8 +387,3 @@ async def store_action_info(
         traceback.print_exc()
         return None
 
-
-# 兼容性函数，方便从Peewee迁移
-def get_model_class(model_name: str) -> Optional[Type[Base]]:
-    """根据模型名称获取模型类"""
-    return MODEL_MAPPING.get(model_name)

src/common/database/sqlalchemy_init.py

@@ -8,7 +8,7 @@ from typing import Optional
 from sqlalchemy.exc import SQLAlchemyError
 from src.common.logger import get_logger
 from src.common.database.sqlalchemy_models import (
-    Base, get_engine, get_session, initialize_database
+    Base, get_engine, initialize_database
 )
 
 logger = get_logger("sqlalchemy_init")
@@ -72,36 +72,6 @@ def create_all_tables() -> bool:
         return False
 
 
-def check_database_connection() -> bool:
-    """
-    检查数据库连接是否正常
-    
-    Returns:
-        bool: 连接是否正常
-    """
-    try:
-        session = get_session()
-        if session is None:
-            logger.error("无法获取数据库会话")
-            return False
-        
-        # 检查会话是否可用（如果能获取到会话说明连接正常）
-        if session is None:
-            logger.error("数据库会话无效")
-            return False
-        
-        session.close()
-        
-        logger.info("数据库连接检查通过")
-        return True
-        
-    except SQLAlchemyError as e:
-        logger.error(f"数据库连接检查失败: {e}")
-        return False
-    except Exception as e:
-        logger.error(f"数据库连接检查过程中发生未知错误: {e}")
-        return False
-
 
 def get_database_info() -> Optional[dict]:
     """
@@ -149,9 +119,6 @@ def initialize_database_compat() -> bool:
     if success:
         success = create_all_tables()
     
-    if success:
-        success = check_database_connection()
-    
     if success:
         _database_initialized = True
     

src/common/database/sqlalchemy_models.py

@@ -31,102 +31,6 @@ def get_string_field(max_length=255, **kwargs):
         return Text(**kwargs)
 
 
-
-class SessionProxy:
-    """线程安全的Session代理类，自动管理session生命周期"""
-
-    def __init__(self):
-        self._local = threading.local()
-
-    def _get_current_session(self):
-        """获取当前线程的session，如果没有则创建新的"""
-        if not hasattr(self._local, 'session') or self._local.session is None:
-            _, SessionLocal = initialize_database()
-            self._local.session = SessionLocal()
-        return self._local.session
-
-    def _close_current_session(self):
-        """关闭当前线程的session"""
-        if hasattr(self._local, 'session') and self._local.session is not None:
-            try:
-                self._local.session.close()
-            except:
-                pass
-            finally:
-                self._local.session = None
-
-    def __getattr__(self, name):
-        """代理所有session方法"""
-        session = self._get_current_session()
-        attr = getattr(session, name)
-
-        # 如果是方法，需要特殊处理一些关键方法
-        if callable(attr):
-            if name in ['commit', 'rollback']:
-                def wrapper(*args, **kwargs):
-                    try:
-                        result = attr(*args, **kwargs)
-                        if name == 'commit':
-                            # commit后不要清除session，只是刷新状态
-                            pass  # 保持session活跃
-                        return result
-                    except Exception:
-                        try:
-                            if session and hasattr(session, 'rollback'):
-                                session.rollback()
-                        except:
-                            pass
-                        # 发生错误时重新创建session
-                        self._close_current_session()
-                        raise
-                return wrapper
-            elif name == 'close':
-                def wrapper(*args, **kwargs):
-                    result = attr(*args, **kwargs)
-                    self._close_current_session()
-                    return result
-                return wrapper
-            elif name in ['execute', 'query', 'add', 'delete', 'merge']:
-                def wrapper(*args, **kwargs):
-                    try:
-                        return attr(*args, **kwargs)
-                    except Exception as e:
-                        # 如果是连接相关错误，重新创建session再试一次
-                        if "not bound to a Session" in str(e) or "provisioning a new connection" in str(e):
-                            logger.warning(f"Session问题，重新创建session: {e}")
-                            self._close_current_session()
-                            new_session = self._get_current_session()
-                            new_attr = getattr(new_session, name)
-                            return new_attr(*args, **kwargs)
-                        raise
-                return wrapper
-
-        return attr
-
-    def new_session(self):
-        """强制创建新的session（关闭当前的，创建新的）"""
-        self._close_current_session()
-        return self._get_current_session()
-
-    def ensure_fresh_session(self):
-        """确保使用新鲜的session（如果当前session有问题则重新创建）"""
-        if hasattr(self._local, 'session') and self._local.session is not None:
-            try:
-                # 测试session是否还可用
-                self._local.session.execute("SELECT 1")
-            except Exception:
-                # session有问题，重新创建
-                self._close_current_session()
-        return self._get_current_session()
-
-# 创建全局session代理实例
-_global_session_proxy = SessionProxy()
-
-def get_session():
-    """返回线程安全的session代理，自动管理生命周期"""
-    return _global_session_proxy
-
-
 class ChatStreams(Base):
     """聊天流模型"""
     __tablename__ = 'chat_streams'
@@ -482,6 +386,22 @@ class  MaiZoneScheduleStatus(Base):
     )
 
 
+class BanUser(Base):
+    """被禁用用户模型"""
+    __tablename__ = 'ban_users'
+
+    id = Column(Integer, primary_key=True, autoincrement=True)
+    user_id = Column(get_string_field(50), nullable=False, index=True)
+    violation_num = Column(Integer, nullable=False, default=0)
+    reason = Column(Text, nullable=False)
+    created_at = Column(DateTime, nullable=False, default=datetime.datetime.now)
+
+    __table_args__ = (
+        Index('idx_violation_num', 'violation_num'),
+        Index('idx_banuser_user_id', 'user_id'),
+    )
+
+
 # 数据库引擎和会话管理
 _engine = None
 _SessionLocal = None
@@ -593,7 +513,7 @@ def get_db_session():
         _, SessionLocal = initialize_database()
         session = SessionLocal()
         yield session
-        session.commit()
+        # session.commit()
     except Exception:
         if session:
             session.rollback()
@@ -603,6 +523,7 @@ def get_db_session():
             session.close()
             
 
+
 def get_engine():
     """获取数据库引擎"""
     engine, _ = initialize_database()

src/common/message_repository.py

@@ -8,7 +8,7 @@ from src.config.config import global_config
 
 # from src.common.database.database_model import Messages
 from src.common.database.sqlalchemy_models import Messages
-from src.common.database.sqlalchemy_database_api import get_session
+from src.common.database.sqlalchemy_database_api import get_db_session
 from src.common.logger import get_logger
 
 logger = get_logger(__name__)
@@ -44,7 +44,7 @@ def find_messages(
         消息字典列表，如果出错则返回空列表。
     """
     try:
-        session = get_session()
+        with get_db_session() as session:
             query = select(Messages)
 
             # 应用过滤器
@@ -152,7 +152,7 @@ def count_messages(message_filter: dict[str, Any]) -> int:
         符合条件的消息数量，如果出错则返回 0。
     """
     try:
-        session = get_session()
+        with get_db_session() as session:
             query = select(func.count(Messages.id))
 
             # 应用过滤器

src/llm_models/utils.py

@@ -5,7 +5,7 @@ from PIL import Image
 from datetime import datetime
 
 from src.common.logger import get_logger
-from src.common.database.sqlalchemy_models import LLMUsage, get_session
+from src.common.database.sqlalchemy_models import LLMUsage, get_db_session
 from src.config.api_ada_configs import ModelInfo
 from .payload_content.message import Message, MessageBuilder
 from .model_client.base_client import UsageRecord
@@ -156,8 +156,7 @@ class LLMUsageRecorder:
         session = None
         try:
             # 使用 SQLAlchemy 会话创建记录
-            session = get_session()
-            
+            with get_db_session() as session:
                 usage_record = LLMUsage(
                 model_name=model_info.model_identifier,
                 model_assign_name=model_info.name,
@@ -184,11 +183,7 @@ class LLMUsageRecorder:
                 f"总计: {model_usage.total_tokens}"
             )
         except Exception as e:
-            if session:
-                session.rollback()
             logger.error(f"记录token使用情况失败: {str(e)}")
-        finally:
-            if session:
-                session.close()
+
 
 llm_usage_recorder = LLMUsageRecorder()

src/manager/schedule_manager.py

@@ -212,6 +212,7 @@ class ScheduleManager:
                             setattr(new_schedule, 'date', today_str)
                             setattr(new_schedule, 'schedule_data', json.dumps(schedule_data))
                             session.add(new_schedule)
+                            session.commit()
                     
                     # 美化输出
                     schedule_str = f"已成功生成并保存今天的日程 ({today_str})：\n"

src/person_info/person_info.py

@@ -11,10 +11,9 @@ from sqlalchemy import select
 from src.common.logger import get_logger
 from src.common.database.database import db
 from src.common.database.sqlalchemy_models import PersonInfo
-from src.common.database.sqlalchemy_database_api import get_session
+from src.common.database.sqlalchemy_database_api import get_db_session
 from src.llm_models.utils_model import LLMRequest
 from src.config.config import global_config, model_config
-session = get_session()
 
 """
 PersonInfoManager 类方法功能摘要：
@@ -52,50 +51,31 @@ person_info_default = {
     "attitude": 50,
 }
 
-# 统一的会话管理函数
-def with_session(func):
-    """装饰器：为函数自动注入session参数"""
-    if asyncio.iscoroutinefunction(func):
-        async def async_wrapper(*args, **kwargs):
-            
-            return await func(session, *args, **kwargs)
-        return async_wrapper
-    else:
-        def sync_wrapper(*args, **kwargs):
-            
-            return func(session, *args, **kwargs)
-        return sync_wrapper
-
-# 全局会话获取函数，用于替换所有裸露的session使用
-def _get_session():
-    """获取数据库会话的统一函数"""
-    return get_session()
-
 
 class PersonInfoManager:
     def __init__(self):
         """初始化PersonInfoManager"""
-        from src.common.database.sqlalchemy_models import PersonInfo
         self.person_name_list = {}
         self.qv_name_llm = LLMRequest(model_set=model_config.model_task_config.utils, request_type="relation.qv_name")
-        try:
-            db.connect(reuse_if_open=True)
-            # 设置连接池参数（仅对SQLite有效）
-            if hasattr(db, "execute_sql"):
-                # 检查数据库类型，只对SQLite执行PRAGMA语句
-                if global_config.database.database_type == "sqlite":
-                    # 设置SQLite优化参数
-                    db.execute_sql("PRAGMA cache_size = -64000")  # 64MB缓存
-                    db.execute_sql("PRAGMA temp_store = memory")  # 临时存储在内存中
-                    db.execute_sql("PRAGMA mmap_size = 268435456")  # 256MB内存映射
-            db.create_tables([PersonInfo], safe=True)
-        except Exception as e:
-            logger.error(f"数据库连接或 PersonInfo 表创建失败: {e}")
+        # try:
+        #     with get_db_session() as session:
+        #         db.connect(reuse_if_open=True)
+        #         # 设置连接池参数（仅对SQLite有效）
+        #         if hasattr(db, "execute_sql"):
+        #             # 检查数据库类型，只对SQLite执行PRAGMA语句
+        #             if global_config.database.database_type == "sqlite":
+        #                 # 设置SQLite优化参数
+        #                 db.execute_sql("PRAGMA cache_size = -64000")  # 64MB缓存
+        #                 db.execute_sql("PRAGMA temp_store = memory")  # 临时存储在内存中
+        #                 db.execute_sql("PRAGMA mmap_size = 268435456")  # 256MB内存映射
+        #         db.create_tables([PersonInfo], safe=True)
+        # except Exception as e:
+        #         logger.error(f"数据库连接或 PersonInfo 表创建失败: {e}")
 
-        # 初始化时读取所有person_name
+        #     # 初始化时读取所有person_name
         try:
-            from src.common.database.sqlalchemy_models import PersonInfo
                 # 在这里获取会话
+            with get_db_session() as session:
                 for record in session.execute(select(PersonInfo.person_id, PersonInfo.person_name).where(
                         PersonInfo.person_name.is_not(None)
                     )).fetchall():
@@ -121,6 +101,7 @@ class PersonInfoManager:
 
         def _db_check_known_sync(p_id: str):
               # 在需要时获取会话
+            with get_db_session() as session:
                 return session.execute(select(PersonInfo).where(PersonInfo.person_id == p_id)).scalar() is not None
 
         try:
@@ -133,6 +114,7 @@ class PersonInfoManager:
         """根据用户名获取用户ID"""
         try:
               # 在需要时获取会话
+            with get_db_session() as session:
                 record = session.execute(select(PersonInfo).where(PersonInfo.person_name == person_name)).scalar()
             return record.person_id if record else ""
         except Exception as e:
@@ -176,13 +158,14 @@ class PersonInfoManager:
                 # If it's already a string, assume it's valid JSON or a non-JSON string field
 
         def _db_create_sync(p_data: dict):
+            with get_db_session() as session:
                 try:
                     new_person = PersonInfo(**p_data)
                     session.add(new_person)
                     session.commit()
+                    
                     return True
                 except Exception as e:
-                session.rollback()
                     logger.error(f"创建 PersonInfo 记录 {p_data.get('person_id')} 失败 (SQLAlchemy): {e}")
                     return False
 
@@ -223,6 +206,7 @@ class PersonInfoManager:
                     final_data[key] = json.dumps([], ensure_ascii=False)
 
         def _db_safe_create_sync(p_data: dict):
+            with get_db_session() as session:
                 try:
                     existing = session.execute(select(PersonInfo).where(PersonInfo.person_id == p_data["person_id"])).scalar()
                     if existing:
@@ -233,9 +217,9 @@ class PersonInfoManager:
                     new_person = PersonInfo(**p_data)
                     session.add(new_person)
                     session.commit()
+                    
                     return True
                 except Exception as e:
-                session.rollback()
                     if "UNIQUE constraint failed" in str(e):
                         logger.debug(f"检测到并发创建用户 {p_data.get('person_id')}，跳过错误")
                         return True  # 其他协程已创建，视为成功
@@ -263,13 +247,14 @@ class PersonInfoManager:
         def _db_update_sync(p_id: str, f_name: str, val_to_set):
 
             start_time = time.time()
+            with get_db_session() as session:
                 try:
                     record = session.execute(select(PersonInfo).where(PersonInfo.person_id == p_id)).scalar()
                     query_time = time.time()
 
                     if record:
                         setattr(record, f_name, val_to_set)
-                    session.commit()
+                        
                         save_time = time.time()
 
                         total_time = save_time - start_time
@@ -277,6 +262,7 @@ class PersonInfoManager:
                             logger.warning(
                                 f"数据库更新操作耗时 {total_time:.3f}秒 (查询: {query_time - start_time:.3f}s, 保存: {save_time - query_time:.3f}s) person_id={p_id}, field={f_name}"
                             )
+                        session.commit()
 
                         return True, False  # Found and updated, no creation needed
                     else:
@@ -285,7 +271,6 @@ class PersonInfoManager:
                             logger.warning(f"数据库查询操作耗时 {total_time:.3f}秒 person_id={p_id}, field={f_name}")
                         return False, True  # Not found, needs creation
                 except Exception as e:
-                session.rollback()
                     total_time = time.time() - start_time
                     logger.error(f"数据库操作异常，耗时 {total_time:.3f}秒: {e}")
                     raise
@@ -320,6 +305,7 @@ class PersonInfoManager:
             return False
 
         def _db_has_field_sync(p_id: str, f_name: str):
+            with get_db_session() as session:
                 record = session.execute(select(PersonInfo).where(PersonInfo.person_id == p_id)).scalar()
             return bool(record)
 
@@ -430,6 +416,7 @@ class PersonInfoManager:
             else:
 
                 def _db_check_name_exists_sync(name_to_check):
+                    with get_db_session() as session:
                         return session.execute(select(PersonInfo).where(PersonInfo.person_name == name_to_check)).scalar() is not None
 
                 if await asyncio.to_thread(_db_check_name_exists_sync, generated_nickname):
@@ -471,6 +458,7 @@ class PersonInfoManager:
 
         def _db_delete_sync(p_id: str):
             try:
+                with get_db_session() as session:
                     record = session.execute(select(PersonInfo).where(PersonInfo.person_id == p_id)).scalar()
                     if record:
                         session.delete(record)
@@ -478,7 +466,6 @@ class PersonInfoManager:
                     return 1
                 return 0
             except Exception as e:
-                session.rollback()
                 logger.error(f"删除 PersonInfo {p_id} 失败 (SQLAlchemy): {e}")
                 return 0
 
@@ -497,6 +484,7 @@ class PersonInfoManager:
             default_value_for_field = []  # Ensure JSON fields default to [] if not in DB
 
         def _db_get_value_sync(p_id: str, f_name: str):
+            with get_db_session() as session:
                 record = session.execute(select(PersonInfo).where(PersonInfo.person_id == p_id)).scalar()
             if record:
                 val = getattr(record, f_name, None)
@@ -531,6 +519,7 @@ class PersonInfoManager:
     def get_value_sync(person_id: str, field_name: str):
         """同步获取指定用户指定字段的值"""
         default_value_for_field = person_info_default.get(field_name)
+        with get_db_session() as session:
             if field_name in JSON_SERIALIZED_FIELDS and default_value_for_field is None:
                 default_value_for_field = []
 
@@ -563,6 +552,7 @@ class PersonInfoManager:
         result = {}
 
         def _db_get_record_sync(p_id: str):
+            with get_db_session() as session:
                 return session.execute(select(PersonInfo).where(PersonInfo.person_id == p_id)).scalar()
 
         record = await asyncio.to_thread(_db_get_record_sync, person_id)
@@ -608,6 +598,7 @@ class PersonInfoManager:
         def _db_get_specific_sync(f_name: str):
             found_results = {}
             try:
+                with get_db_session() as session:
                     for record in session.execute(select(PersonInfo.person_id, getattr(PersonInfo, f_name))).fetchall():
                         value = getattr(record, f_name)
                         if way(value):
@@ -634,6 +625,7 @@ class PersonInfoManager:
 
         def _db_get_or_create_sync(p_id: str, init_data: dict):
             """原子性的获取或创建操作"""
+            with get_db_session() as session:
                 # 首先尝试获取现有记录
                 record = session.execute(select(PersonInfo).where(PersonInfo.person_id == p_id)).scalar()
                 if record:
@@ -644,9 +636,9 @@ class PersonInfoManager:
                 new_person = PersonInfo(**init_data)
                 session.add(new_person)
                 session.commit()
+                
                 return session.execute(select(PersonInfo).where(PersonInfo.person_id == p_id)).scalar(), True  # 创建成功
             except Exception as e:
-                session.rollback()
                 # 如果创建失败（可能是因为竞态条件），再次尝试获取
                 if "UNIQUE constraint failed" in str(e):
                     logger.debug(f"检测到并发创建用户 {p_id}，获取现有记录")
@@ -709,6 +701,7 @@ class PersonInfoManager:
         if not found_person_id:
 
             def _db_find_by_name_sync(p_name_to_find: str):
+                with get_db_session() as session:
                     return session.execute(select(PersonInfo).where(PersonInfo.person_name == p_name_to_find)).scalar()
 
             record = await asyncio.to_thread(_db_find_by_name_sync, person_name)

src/plugin_system/apis/database_api.py

@@ -14,7 +14,6 @@ from src.common.database.sqlalchemy_database_api import (
     db_save,
     db_get,
     store_action_info,
-    get_model_class,
     MODEL_MAPPING
 )
 
@@ -24,6 +23,5 @@ __all__ = [
     'db_save',
     'db_get',
     'store_action_info',
-    'get_model_class',
     'MODEL_MAPPING'
 ]

src/plugins/built_in/maizone/scheduler.py

@@ -151,7 +151,7 @@ class ScheduleManager:
                     )
                     session.add(new_record)
                 
-                session.commit()
+                
                 logger.info(f"已更新日程处理状态: {datetime_hour} - {activity} - 成功: {success}")
                 
         except Exception as e: