refactor(db): 修复异步连接池无界增长，并完成 SQLAlchemy 2.0 迁移与分层归位 (#6320)

app/db/models/mediaserver.py

@@ -1,13 +1,13 @@
 from datetime import datetime
-from typing import Optional, List
+from typing import Any, List, Optional
 
-from sqlalchemy import Column, Integer, String, JSON, Index, or_
+from sqlalchemy import Integer, String, JSON, Index, delete, or_
 from sqlalchemy import select
 from sqlalchemy.ext.asyncio import AsyncSession
-from sqlalchemy.orm import Session
+from sqlalchemy.orm import Mapped, Session, mapped_column
 
-from app.db import db_query, db_update, get_id_column, async_db_query, Base
-from app.db.models.media_identity import media_identity_constraint
+from app.db import Base, async_db_query, db_query, db_update, execute_dml, get_id_column
+from app.db.models._constraints import media_identity_constraint
 from app.schemas.types import MediaSource
 
 
@@ -17,30 +17,30 @@ class MediaServerItem(Base):
     """
     id = get_id_column()
     # 服务器类型
-    server = Column(String)
+    server: Mapped[Optional[str]] = mapped_column(String)
     # 媒体库ID
-    library = Column(String)
+    library: Mapped[Optional[str]] = mapped_column(String)
     # ID
-    item_id = Column(String, index=True)
+    item_id: Mapped[Optional[str]] = mapped_column(String, index=True)
     # 类型
-    item_type = Column(String)
+    item_type: Mapped[Optional[str]] = mapped_column(String)
     # 标题
-    title = Column(String, index=True)
+    title: Mapped[Optional[str]] = mapped_column(String, index=True)
     # 原标题
-    original_title = Column(String)
+    original_title: Mapped[Optional[str]] = mapped_column(String)
     # 年份
-    year = Column(String)
+    year: Mapped[Optional[str]] = mapped_column(String)
     # 媒体数据源与原生ID
-    media_source = Column(String, index=True)
-    media_id = Column(String, index=True)
+    media_source: Mapped[Optional[str]] = mapped_column(String, index=True)
+    media_id: Mapped[Optional[str]] = mapped_column(String, index=True)
     # 路径
-    path = Column(String)
+    path: Mapped[Optional[str]] = mapped_column(String)
     # 季集
-    seasoninfo = Column(JSON, default=dict)
+    seasoninfo: Mapped[Optional[Any]] = mapped_column(JSON, default=dict)
     # 备注
-    note = Column(JSON)
+    note: Mapped[Optional[Any]] = mapped_column(JSON)
     # 同步时间
-    lst_mod_date = Column(String, default=datetime.now().strftime("%Y-%m-%d %H:%M:%S"))
+    lst_mod_date: Mapped[Optional[str]] = mapped_column(String, default=datetime.now().strftime("%Y-%m-%d %H:%M:%S"))
 
     __table_args__ = (
         media_identity_constraint("mediaserveritem"),
@@ -54,36 +54,46 @@ class MediaServerItem(Base):
     @classmethod
     @db_query
     def get_by_itemid(cls, db: Session, item_id: str):
-        return db.query(cls).filter(cls.item_id == item_id).first()
+        return db.execute(select(cls).where(cls.item_id == item_id)).scalars().first()
 
     @classmethod
     @db_query
     def get_by_server_itemid(cls, db: Session, server: str, item_id: str):
-        return db.query(cls).filter(cls.server == server,
-                                    cls.item_id == item_id).first()
+        return db.execute(
+            select(cls).where(cls.server == server, cls.item_id == item_id)
+        ).scalars().first()
 
     @classmethod
     @db_update
     def empty(cls, db: Session, server: Optional[str] = None):
-        if server is None:
-            db.query(cls).delete(synchronize_session=False)
-        else:
-            db.query(cls).filter(cls.server == server).delete(synchronize_session=False)
+        statement = delete(cls)
+        if server is not None:
+            statement = statement.where(cls.server == server)
+        db.execute(statement, execution_options={"synchronize_session": False})
 
     @classmethod
     @db_update
     def delete_stale(cls, db: Session, server: str, sync_time: str):
-        return db.query(cls).filter(cls.server == server,
-                                    or_(cls.lst_mod_date.is_(None),
-                                        cls.lst_mod_date != sync_time)).delete(synchronize_session=False)
+        return execute_dml(
+            db,
+            delete(cls).where(
+                cls.server == server,
+                or_(cls.lst_mod_date.is_(None), cls.lst_mod_date != sync_time),
+            ),
+            execution_options={"synchronize_session": False},
+        )
 
     @classmethod
     @db_update
     def delete_excluded_servers(cls, db: Session, servers: List[str]):
-        if not servers:
-            return db.query(cls).delete(synchronize_session=False)
-        return db.query(cls).filter(or_(cls.server.is_(None),
-                                        ~cls.server.in_(servers))).delete(synchronize_session=False)
+        statement = delete(cls)
+        if servers:
+            statement = statement.where(
+                or_(cls.server.is_(None), ~cls.server.in_(servers))
+            )
+        return execute_dml(
+            db, statement, execution_options={"synchronize_session": False}
+        )
 
     @classmethod
     @db_query
@@ -91,26 +101,21 @@ class MediaServerItem(Base):
             cls, db: Session, media_source: MediaSource, media_id: str, mtype: str,
     ):
         """按规范媒体身份和类型查询媒体服务器条目。"""
-        return db.query(cls).filter(
+        return db.execute(select(cls).where(
             cls.media_source == str(media_source),
             cls.media_id == str(media_id),
             cls.item_type == mtype,
-        ).first()
+        )).scalars().first()
 
     @classmethod
     @db_query
     def exists_by_title(cls, db: Session, title: str, mtype: str, year: str):
-        if not mtype and not year:
-            return db.query(cls).filter(cls.title == title).first()
-        elif not year:
-            return db.query(cls).filter(cls.title == title,
-                                        cls.item_type == mtype).first()
-        elif not mtype:
-            return db.query(cls).filter(cls.title == title,
-                                        cls.year == str(year)).first()
-        return db.query(cls).filter(cls.title == title,
-                                    cls.item_type == mtype,
-                                    cls.year == str(year)).first()
+        statement = select(cls).where(cls.title == title)
+        if mtype:
+            statement = statement.where(cls.item_type == mtype)
+        if year:
+            statement = statement.where(cls.year == str(year))
+        return db.execute(statement).scalars().first()
 
     @classmethod
     @async_db_query