refactor: 重构数据库orm为异步 #I9MRQS

ruoyi-fastapi-backend/module_admin/dao/config_dao.py

@@ -1,4 +1,5 @@
-from sqlalchemy.orm import Session
+from sqlalchemy import select, update, delete
+from sqlalchemy.ext.asyncio import AsyncSession
 from module_admin.entity.do.config_do import SysConfig
 from module_admin.entity.vo.config_vo import *
 from utils.page_util import PageUtil
@@ -11,36 +12,38 @@ class ConfigDao:
     """
 
     @classmethod
-    def get_config_detail_by_id(cls, db: Session, config_id: int):
+    async def get_config_detail_by_id(cls, db: AsyncSession, config_id: int):
         """
         根据参数配置id获取参数配置详细信息
         :param db: orm对象
         :param config_id: 参数配置id
         :return: 参数配置信息对象
         """
-        config_info = db.query(SysConfig) \
-            .filter(SysConfig.config_id == config_id) \
-            .first()
+        config_info = (await db.execute(
+            select(SysConfig)
+                .where(SysConfig.config_id == config_id)
+        )).scalars().first()
 
         return config_info
 
     @classmethod
-    def get_config_detail_by_info(cls, db: Session, config: ConfigModel):
+    async def get_config_detail_by_info(cls, db: AsyncSession, config: ConfigModel):
         """
         根据参数配置参数获取参数配置信息
         :param db: orm对象
         :param config: 参数配置参数对象
         :return: 参数配置信息对象
         """
-        config_info = db.query(SysConfig) \
-            .filter(SysConfig.config_key == config.config_key if config.config_key else True,
-                    SysConfig.config_value == config.config_value if config.config_value else True) \
-            .first()
+        config_info = (await db.execute(
+            select(SysConfig)
+                .where(SysConfig.config_key == config.config_key if config.config_key else True,
+                       SysConfig.config_value == config.config_value if config.config_value else True)
+        )).scalars().first()
 
         return config_info
 
     @classmethod
-    def get_config_list(cls, db: Session, query_object: ConfigPageQueryModel, is_page: bool = False):
+    async def get_config_list(cls, db: AsyncSession, query_object: ConfigPageQueryModel, is_page: bool = False):
         """
         根据查询参数获取参数配置列表信息
         :param db: orm对象
@@ -48,22 +51,21 @@ class ConfigDao:
         :param is_page: 是否开启分页
         :return: 参数配置列表信息对象
         """
-        query = db.query(SysConfig) \
-            .filter(SysConfig.config_name.like(f'%{query_object.config_name}%') if query_object.config_name else True,
-                    SysConfig.config_key.like(f'%{query_object.config_key}%') if query_object.config_key else True,
-                    SysConfig.config_type == query_object.config_type if query_object.config_type else True,
-                    SysConfig.create_time.between(
-                        datetime.combine(datetime.strptime(query_object.begin_time, '%Y-%m-%d'), time(00, 00, 00)),
-                        datetime.combine(datetime.strptime(query_object.end_time, '%Y-%m-%d'), time(23, 59, 59)))
-                    if query_object.begin_time and query_object.end_time else True
-                    ) \
+        query = select(SysConfig) \
+            .where(SysConfig.config_name.like(f'%{query_object.config_name}%') if query_object.config_name else True,
+                   SysConfig.config_key.like(f'%{query_object.config_key}%') if query_object.config_key else True,
+                   SysConfig.config_type == query_object.config_type if query_object.config_type else True,
+                   SysConfig.create_time.between(
+                       datetime.combine(datetime.strptime(query_object.begin_time, '%Y-%m-%d'), time(00, 00, 00)),
+                       datetime.combine(datetime.strptime(query_object.end_time, '%Y-%m-%d'), time(23, 59, 59)))
+                   if query_object.begin_time and query_object.end_time else True) \
             .distinct()
-        config_list = PageUtil.paginate(query, query_object.page_num, query_object.page_size, is_page)
+        config_list = await PageUtil.paginate(db, query, query_object.page_num, query_object.page_size, is_page)
 
         return config_list
 
     @classmethod
-    def add_config_dao(cls, db: Session, config: ConfigModel):
+    async def add_config_dao(cls, db: AsyncSession, config: ConfigModel):
         """
         新增参数配置数据库操作
         :param db: orm对象
@@ -72,30 +74,32 @@ class ConfigDao:
         """
         db_config = SysConfig(**config.model_dump())
         db.add(db_config)
-        db.flush()
+        await db.flush()
 
         return db_config
 
     @classmethod
-    def edit_config_dao(cls, db: Session, config: dict):
+    async def edit_config_dao(cls, db: AsyncSession, config: dict):
         """
         编辑参数配置数据库操作
         :param db: orm对象
         :param config: 需要更新的参数配置字典
         :return:
         """
-        db.query(SysConfig) \
-            .filter(SysConfig.config_id == config.get('config_id')) \
-            .update(config)
+        await db.execute(
+            update(SysConfig),
+            [config]
+        )
 
     @classmethod
-    def delete_config_dao(cls, db: Session, config: ConfigModel):
+    async def delete_config_dao(cls, db: AsyncSession, config: ConfigModel):
         """
         删除参数配置数据库操作
         :param db: orm对象
         :param config: 参数配置对象
         :return:
         """
-        db.query(SysConfig) \
-            .filter(SysConfig.config_id == config.config_id) \
-            .delete()
+        await db.execute(
+            delete(SysConfig)
+                .where(SysConfig.config_id.in_([config.config_id]))
+        )

ruoyi-fastapi-backend/module_admin/dao/dept_dao.py

@@ -1,4 +1,5 @@
-from sqlalchemy.orm import Session
+from sqlalchemy import select, update, delete
+from sqlalchemy.ext.asyncio import AsyncSession
 from module_admin.entity.do.dept_do import SysDept
 from module_admin.entity.do.role_do import SysRoleDept
 from module_admin.entity.vo.dept_vo import *
@@ -11,68 +12,72 @@ class DeptDao:
     """
 
     @classmethod
-    def get_dept_by_id(cls, db: Session, dept_id: int):
+    async def get_dept_by_id(cls, db: AsyncSession, dept_id: int):
         """
         根据部门id获取在用部门信息
         :param db: orm对象
         :param dept_id: 部门id
         :return: 在用部门信息对象
         """
-        dept_info = db.query(SysDept) \
-            .filter(SysDept.dept_id == dept_id,
-                    SysDept.status == 0,
-                    SysDept.del_flag == 0) \
-            .first()
+        dept_info = (await db.execute(
+            select(SysDept)
+                .where(SysDept.dept_id == dept_id,
+                       SysDept.status == 0,
+                       SysDept.del_flag == 0)
+        )).scalars().first()
 
         return dept_info
 
     @classmethod
-    def get_dept_by_id_for_list(cls, db: Session, dept_id: int):
+    async def get_dept_by_id_for_list(cls, db: AsyncSession, dept_id: int):
         """
         用于获取部门列表的工具方法
         :param db: orm对象
         :param dept_id: 部门id
         :return: 部门id对应的信息对象
         """
-        dept_info = db.query(SysDept) \
-            .filter(SysDept.dept_id == dept_id,
-                    SysDept.del_flag == 0) \
-            .first()
+        dept_info = (await db.execute(
+            select(SysDept)
+                .where(SysDept.dept_id == dept_id,
+                       SysDept.del_flag == 0)
+        )).scalars().first()
 
         return dept_info
 
     @classmethod
-    def get_dept_detail_by_id(cls, db: Session, dept_id: int):
+    async def get_dept_detail_by_id(cls, db: AsyncSession, dept_id: int):
         """
         根据部门id获取部门详细信息
         :param db: orm对象
         :param dept_id: 部门id
         :return: 部门信息对象
         """
-        dept_info = db.query(SysDept) \
-            .filter(SysDept.dept_id == dept_id,
-                    SysDept.del_flag == 0) \
-            .first()
+        dept_info = (await db.execute(
+            select(SysDept)
+                .where(SysDept.dept_id == dept_id,
+                       SysDept.del_flag == 0)
+        )).scalars().first()
 
         return dept_info
 
     @classmethod
-    def get_dept_detail_by_info(cls, db: Session, dept: DeptModel):
+    async def get_dept_detail_by_info(cls, db: AsyncSession, dept: DeptModel):
         """
         根据部门参数获取部门信息
         :param db: orm对象
         :param dept: 部门参数对象
         :return: 部门信息对象
         """
-        dept_info = db.query(SysDept) \
-            .filter(SysDept.parent_id == dept.parent_id if dept.parent_id else True,
-                    SysDept.dept_name == dept.dept_name if dept.dept_name else True) \
-            .first()
+        dept_info = (await db.execute(
+            select(SysDept)
+                .where(SysDept.parent_id == dept.parent_id if dept.parent_id else True,
+                       SysDept.dept_name == dept.dept_name if dept.dept_name else True)
+        )).scalars().first()
 
         return dept_info
 
     @classmethod
-    def get_dept_info_for_edit_option(cls, db: Session, dept_info: DeptModel, data_scope_sql: str):
+    async def get_dept_info_for_edit_option(cls, db: AsyncSession, dept_info: DeptModel, data_scope_sql: str):
         """
         获取部门编辑对应的在用部门列表信息
         :param db: orm对象
@@ -80,46 +85,50 @@ class DeptDao:
         :param data_scope_sql: 数据权限对应的查询sql语句
         :return: 部门列表信息
         """
-        dept_result = db.query(SysDept) \
-            .filter(SysDept.dept_id != dept_info.dept_id,
-                    SysDept.parent_id != dept_info.dept_id,
-                    SysDept.del_flag == 0, SysDept.status == 0,
-                    eval(data_scope_sql)) \
-            .order_by(SysDept.order_num) \
-            .distinct().all()
+        dept_result = (await db.execute(
+            select(SysDept)
+                .where(SysDept.dept_id != dept_info.dept_id,
+                       SysDept.parent_id != dept_info.dept_id,
+                       SysDept.del_flag == 0, SysDept.status == 0,
+                       eval(data_scope_sql))
+                .order_by(SysDept.order_num)
+                .distinct()
+        )).scalars().all()
 
         return list_format_datetime(dept_result)
 
     @classmethod
-    def get_children_dept(cls, db: Session, dept_id: int):
+    async def get_children_dept(cls, db: AsyncSession, dept_id: int):
         """
         根据部门id查询当前部门的子部门列表信息
         :param db: orm对象
         :param dept_id: 部门id
         :return: 子部门信息列表
         """
-        dept_result = db.query(SysDept) \
-            .filter(SysDept.parent_id == dept_id,
-                    SysDept.del_flag == 0) \
-            .all()
+        dept_result = (await db.execute(
+            select(SysDept)
+                .where(SysDept.parent_id == dept_id,
+                       SysDept.del_flag == 0)
+        )).scalars().all()
 
         return list_format_datetime(dept_result)
 
     @classmethod
-    def get_dept_all_ancestors(cls, db: Session):
+    async def get_dept_all_ancestors(cls, db: AsyncSession):
         """
         获取所有部门的ancestors信息
         :param db: orm对象
         :return: ancestors信息列表
         """
-        ancestors = db.query(SysDept.ancestors)\
-            .filter(SysDept.del_flag == 0)\
-            .all()
+        ancestors = (await db.execute(
+            select(SysDept.ancestors)
+                .where(SysDept.del_flag == 0)
+        )).scalars().all()
 
         return ancestors
 
     @classmethod
-    def get_dept_list_for_tree(cls, db: Session, dept_info: DeptModel, data_scope_sql: str):
+    async def get_dept_list_for_tree(cls, db: AsyncSession, dept_info: DeptModel, data_scope_sql: str):
         """
         获取所有在用部门列表信息
         :param db: orm对象
@@ -127,18 +136,20 @@ class DeptDao:
         :param data_scope_sql: 数据权限对应的查询sql语句
         :return: 在用部门列表信息
         """
-        dept_result = db.query(SysDept) \
-            .filter(SysDept.status == 0,
-                    SysDept.del_flag == 0,
-                    SysDept.dept_name.like(f'%{dept_info.dept_name}%') if dept_info.dept_name else True,
-                    eval(data_scope_sql)) \
-            .order_by(SysDept.order_num) \
-            .distinct().all()
+        dept_result = (await db.execute(
+            select(SysDept)
+                .where(SysDept.status == 0,
+                       SysDept.del_flag == 0,
+                       SysDept.dept_name.like(f'%{dept_info.dept_name}%') if dept_info.dept_name else True,
+                       eval(data_scope_sql))
+                .order_by(SysDept.order_num)
+                .distinct()
+        )).scalars().all()
 
         return dept_result
 
     @classmethod
-    def get_dept_list(cls, db: Session, page_object: DeptModel, data_scope_sql: str):
+    async def get_dept_list(cls, db: AsyncSession, page_object: DeptModel, data_scope_sql: str):
         """
         根据查询参数获取部门列表信息
         :param db: orm对象
@@ -146,18 +157,20 @@ class DeptDao:
         :param data_scope_sql: 数据权限对应的查询sql语句
         :return: 部门列表信息对象
         """
-        dept_result = db.query(SysDept) \
-            .filter(SysDept.del_flag == 0,
-                    SysDept.status == page_object.status if page_object.status else True,
-                    SysDept.dept_name.like(f'%{page_object.dept_name}%') if page_object.dept_name else True,
-                    eval(data_scope_sql)) \
-            .order_by(SysDept.order_num) \
-            .distinct().all()
+        dept_result = (await db.execute(
+            select(SysDept)
+                .where(SysDept.del_flag == 0,
+                       SysDept.status == page_object.status if page_object.status else True,
+                       SysDept.dept_name.like(f'%{page_object.dept_name}%') if page_object.dept_name else True,
+                       eval(data_scope_sql))
+                .order_by(SysDept.order_num)
+                .distinct()
+        )).scalars().all()
 
         return dept_result
 
     @classmethod
-    def add_dept_dao(cls, db: Session, dept: DeptModel):
+    async def add_dept_dao(cls, db: AsyncSession, dept: DeptModel):
         """
         新增部门数据库操作
         :param db: orm对象
@@ -166,30 +179,33 @@ class DeptDao:
         """
         db_dept = SysDept(**dept.model_dump())
         db.add(db_dept)
-        db.flush()
+        await db.flush()
 
         return db_dept
 
     @classmethod
-    def edit_dept_dao(cls, db: Session, dept: dict):
+    async def edit_dept_dao(cls, db: AsyncSession, dept: dict):
         """
         编辑部门数据库操作
         :param db: orm对象
         :param dept: 需要更新的部门字典
         :return: 编辑校验结果
         """
-        db.query(SysDept) \
-            .filter(SysDept.dept_id == dept.get('dept_id')) \
-            .update(dept)
+        await db.execute(
+            update(SysDept),
+            [dept]
+        )
 
     @classmethod
-    def delete_dept_dao(cls, db: Session, dept: DeptModel):
+    async def delete_dept_dao(cls, db: AsyncSession, dept: DeptModel):
         """
         删除部门数据库操作
         :param db: orm对象
         :param dept: 部门对象
         :return:
         """
-        db.query(SysDept) \
-            .filter(SysDept.dept_id == dept.dept_id) \
-            .update({SysDept.del_flag: '2', SysDept.update_by: dept.update_by, SysDept.update_time: dept.update_time})
+        await db.execute(
+            update(SysDept)
+                .where(SysDept.dept_id == dept.dept_id)
+                .values(del_flag='2', update_by=dept.update_by, update_time=dept.update_time)
+        )

ruoyi-fastapi-backend/module_admin/dao/dict_dao.py

@@ -1,5 +1,5 @@
-from sqlalchemy import and_
-from sqlalchemy.orm import Session
+from sqlalchemy import select, update, delete, and_
+from sqlalchemy.ext.asyncio import AsyncSession
 from module_admin.entity.do.dict_do import SysDictType, SysDictData
 from module_admin.entity.vo.dict_vo import *
 from utils.time_format_util import list_format_datetime
@@ -13,47 +13,51 @@ class DictTypeDao:
     """
 
     @classmethod
-    def get_dict_type_detail_by_id(cls, db: Session, dict_id: int):
+    async def get_dict_type_detail_by_id(cls, db: AsyncSession, dict_id: int):
         """
         根据字典类型id获取字典类型详细信息
         :param db: orm对象
         :param dict_id: 字典类型id
         :return: 字典类型信息对象
         """
-        dict_type_info = db.query(SysDictType) \
-            .filter(SysDictType.dict_id == dict_id) \
-            .first()
+        dict_type_info = (await db.execute(
+            select(SysDictType)
+                .where(SysDictType.dict_id == dict_id)
+        )).scalars().first()
 
         return dict_type_info
 
     @classmethod
-    def get_dict_type_detail_by_info(cls, db: Session, dict_type: DictTypeModel):
+    async def get_dict_type_detail_by_info(cls, db: AsyncSession, dict_type: DictTypeModel):
         """
         根据字典类型参数获取字典类型信息
         :param db: orm对象
         :param dict_type: 字典类型参数对象
         :return: 字典类型信息对象
         """
-        dict_type_info = db.query(SysDictType) \
-            .filter(SysDictType.dict_type == dict_type.dict_type if dict_type.dict_type else True,
-                    SysDictType.dict_name == dict_type.dict_name if dict_type.dict_name else True) \
-            .first()
+        dict_type_info = (await db.execute(
+            select(SysDictType)
+                .where(SysDictType.dict_type == dict_type.dict_type if dict_type.dict_type else True,
+                       SysDictType.dict_name == dict_type.dict_name if dict_type.dict_name else True)
+        )).scalars().first()
 
         return dict_type_info
 
     @classmethod
-    def get_all_dict_type(cls, db: Session):
+    async def get_all_dict_type(cls, db: AsyncSession):
         """
         获取所有的字典类型信息
         :param db: orm对象
         :return: 字典类型信息列表对象
         """
-        dict_type_info = db.query(SysDictType).all()
+        dict_type_info = (await db.execute(
+            select(SysDictType)
+        )).scalars().all()
 
         return list_format_datetime(dict_type_info)
 
     @classmethod
-    def get_dict_type_list(cls, db: Session, query_object: DictTypePageQueryModel, is_page: bool = False):
+    async def get_dict_type_list(cls, db: AsyncSession, query_object: DictTypePageQueryModel, is_page: bool = False):
         """
         根据查询参数获取字典类型列表信息
         :param db: orm对象
@@ -61,57 +65,58 @@ class DictTypeDao:
         :param is_page: 是否开启分页
         :return: 字典类型列表信息对象
         """
-        query = db.query(SysDictType) \
-            .filter(SysDictType.dict_name.like(f'%{query_object.dict_name}%') if query_object.dict_name else True,
-                    SysDictType.dict_type.like(f'%{query_object.dict_type}%') if query_object.dict_type else True,
-                    SysDictType.status == query_object.status if query_object.status else True,
-                    SysDictType.create_time.between(
-                        datetime.combine(datetime.strptime(query_object.begin_time, '%Y-%m-%d'), time(00, 00, 00)),
-                        datetime.combine(datetime.strptime(query_object.end_time, '%Y-%m-%d'), time(23, 59, 59)))
-                    if query_object.begin_time and query_object.end_time else True
-                    ) \
+        query = select(SysDictType) \
+            .where(SysDictType.dict_name.like(f'%{query_object.dict_name}%') if query_object.dict_name else True,
+                   SysDictType.dict_type.like(f'%{query_object.dict_type}%') if query_object.dict_type else True,
+                   SysDictType.status == query_object.status if query_object.status else True,
+                   SysDictType.create_time.between(
+                       datetime.combine(datetime.strptime(query_object.begin_time, '%Y-%m-%d'), time(00, 00, 00)),
+                       datetime.combine(datetime.strptime(query_object.end_time, '%Y-%m-%d'), time(23, 59, 59)))
+                   if query_object.begin_time and query_object.end_time else True) \
             .distinct()
-        dict_type_list = PageUtil.paginate(query, query_object.page_num, query_object.page_size, is_page)
+        dict_type_list = await PageUtil.paginate(db, query, query_object.page_num, query_object.page_size, is_page)
 
         return dict_type_list
 
     @classmethod
-    def add_dict_type_dao(cls, db: Session, dict_type: DictTypeModel):
+    async def add_dict_type_dao(cls, db: AsyncSession, dict_type: DictTypeModel):
         """
         新增字典类型数据库操作
         :param db: orm对象
         :param dict_type: 字典类型对象
         :return:
         """
-        db_dict_type = SysDictType(**dict_type.dict())
+        db_dict_type = SysDictType(**dict_type.model_dump())
         db.add(db_dict_type)
-        db.flush()
+        await db.flush()
 
         return db_dict_type
 
     @classmethod
-    def edit_dict_type_dao(cls, db: Session, dict_type: dict):
+    async def edit_dict_type_dao(cls, db: AsyncSession, dict_type: dict):
         """
         编辑字典类型数据库操作
         :param db: orm对象
         :param dict_type: 需要更新的字典类型字典
         :return:
         """
-        db.query(SysDictType) \
-            .filter(SysDictType.dict_id == dict_type.get('dict_id')) \
-            .update(dict_type)
+        await db.execute(
+            update(SysDictType),
+            [dict_type]
+        )
 
     @classmethod
-    def delete_dict_type_dao(cls, db: Session, dict_type: DictTypeModel):
+    async def delete_dict_type_dao(cls, db: AsyncSession, dict_type: DictTypeModel):
         """
         删除字典类型数据库操作
         :param db: orm对象
         :param dict_type: 字典类型对象
         :return:
         """
-        db.query(SysDictType) \
-            .filter(SysDictType.dict_id == dict_type.dict_id) \
-            .delete()
+        await db.execute(
+            delete(SysDictType)
+                .where(SysDictType.dict_id.in_([dict_type.dict_id]))
+        )
 
 
 class DictDataDao:
@@ -120,37 +125,39 @@ class DictDataDao:
     """
 
     @classmethod
-    def get_dict_data_detail_by_id(cls, db: Session, dict_code: int):
+    async def get_dict_data_detail_by_id(cls, db: AsyncSession, dict_code: int):
         """
         根据字典数据id获取字典数据详细信息
         :param db: orm对象
         :param dict_code: 字典数据id
         :return: 字典数据信息对象
         """
-        dict_data_info = db.query(SysDictData) \
-            .filter(SysDictData.dict_code == dict_code) \
-            .first()
+        dict_data_info = (await db.execute(
+            select(SysDictData)
+                .where(SysDictData.dict_code == dict_code)
+        )).scalars().first()
 
         return dict_data_info
 
     @classmethod
-    def get_dict_data_detail_by_info(cls, db: Session, dict_data: DictDataModel):
+    async def get_dict_data_detail_by_info(cls, db: AsyncSession, dict_data: DictDataModel):
         """
         根据字典数据参数获取字典数据信息
         :param db: orm对象
         :param dict_data: 字典数据参数对象
         :return: 字典数据信息对象
         """
-        dict_data_info = db.query(SysDictData) \
-            .filter(SysDictData.dict_type == dict_data.dict_type if dict_data.dict_type else True,
-                    SysDictData.dict_label == dict_data.dict_label if dict_data.dict_label else True,
-                    SysDictData.dict_value == dict_data.dict_value if dict_data.dict_value else True) \
-            .first()
+        dict_data_info = (await db.execute(
+            select(SysDictData)
+                .where(SysDictData.dict_type == dict_data.dict_type if dict_data.dict_type else True,
+                       SysDictData.dict_label == dict_data.dict_label if dict_data.dict_label else True,
+                       SysDictData.dict_value == dict_data.dict_value if dict_data.dict_value else True)
+        )).scalars().first()
 
         return dict_data_info
 
     @classmethod
-    def get_dict_data_list(cls, db: Session, query_object: DictDataPageQueryModel, is_page: bool = False):
+    async def get_dict_data_list(cls, db: AsyncSession, query_object: DictDataPageQueryModel, is_page: bool = False):
         """
         根据查询参数获取字典数据列表信息
         :param db: orm对象
@@ -158,35 +165,37 @@ class DictDataDao:
         :param is_page: 是否开启分页
         :return: 字典数据列表信息对象
         """
-        query = db.query(SysDictData) \
-            .filter(SysDictData.dict_type == query_object.dict_type if query_object.dict_type else True,
-                    SysDictData.dict_label.like(f'%{query_object.dict_label}%') if query_object.dict_label else True,
-                    SysDictData.status == query_object.status if query_object.status else True
-                    ) \
-            .order_by(SysDictData.dict_sort) \
+        query = select(SysDictData) \
+            .where(SysDictData.dict_type == query_object.dict_type if query_object.dict_type else True,
+                   SysDictData.dict_label.like(f'%{query_object.dict_label}%') if query_object.dict_label else True,
+                   SysDictData.status == query_object.status if query_object.status else True)\
+            .order_by(SysDictData.dict_sort)\
             .distinct()
-        dict_data_list = PageUtil.paginate(query, query_object.page_num, query_object.page_size, is_page)
+        dict_data_list = await PageUtil.paginate(db, query, query_object.page_num, query_object.page_size, is_page)
 
         return dict_data_list
 
     @classmethod
-    def query_dict_data_list(cls, db: Session, dict_type: str):
+    async def query_dict_data_list(cls, db: AsyncSession, dict_type: str):
         """
         根据查询参数获取字典数据列表信息
         :param db: orm对象
         :param dict_type: 字典类型
         :return: 字典数据列表信息对象
         """
-        dict_data_list = db.query(SysDictData).select_from(SysDictType) \
-            .filter(SysDictType.dict_type == dict_type if dict_type else True, SysDictType.status == 0) \
-            .outerjoin(SysDictData, and_(SysDictType.dict_type == SysDictData.dict_type, SysDictData.status == 0)) \
-            .order_by(SysDictData.dict_sort) \
-            .distinct().all()
+        dict_data_list = (await db.execute(
+            select(SysDictData)
+                .select_from(SysDictType)
+                .where(SysDictType.dict_type == dict_type if dict_type else True, SysDictType.status == 0)
+                .join(SysDictData, and_(SysDictType.dict_type == SysDictData.dict_type, SysDictData.status == 0), isouter=True)
+                .order_by(SysDictData.dict_sort)
+                .distinct()
+        )).scalars().all()
 
         return dict_data_list
 
     @classmethod
-    def add_dict_data_dao(cls, db: Session, dict_data: DictDataModel):
+    async def add_dict_data_dao(cls, db: AsyncSession, dict_data: DictDataModel):
         """
         新增字典数据数据库操作
         :param db: orm对象
@@ -195,30 +204,32 @@ class DictDataDao:
         """
         db_data_type = SysDictData(**dict_data.dict())
         db.add(db_data_type)
-        db.flush()
+        await db.flush()
 
         return db_data_type
 
     @classmethod
-    def edit_dict_data_dao(cls, db: Session, dict_data: dict):
+    async def edit_dict_data_dao(cls, db: AsyncSession, dict_data: dict):
         """
         编辑字典数据数据库操作
         :param db: orm对象
         :param dict_data: 需要更新的字典数据字典
         :return:
         """
-        db.query(SysDictData) \
-            .filter(SysDictData.dict_code == dict_data.get('dict_code')) \
-            .update(dict_data)
+        await db.execute(
+            update(SysDictData),
+            [dict_data]
+        )
 
     @classmethod
-    def delete_dict_data_dao(cls, db: Session, dict_data: DictDataModel):
+    async def delete_dict_data_dao(cls, db: AsyncSession, dict_data: DictDataModel):
         """
         删除字典数据数据库操作
         :param db: orm对象
         :param dict_data: 字典数据对象
         :return:
         """
-        db.query(SysDictData) \
-            .filter(SysDictData.dict_code == dict_data.dict_code) \
-            .delete()
+        await db.execute(
+            delete(SysDictData)
+                .where(SysDictData.dict_code.in_([dict_data.dict_code]))
+        )

ruoyi-fastapi-backend/module_admin/dao/job_dao.py

@@ -1,4 +1,5 @@
-from sqlalchemy.orm import Session
+from sqlalchemy import select, update, delete
+from sqlalchemy.ext.asyncio import AsyncSession
 from module_admin.entity.do.job_do import SysJob
 from module_admin.entity.vo.job_vo import *
 from utils.page_util import PageUtil
@@ -10,38 +11,40 @@ class JobDao:
     """
 
     @classmethod
-    def get_job_detail_by_id(cls, db: Session, job_id: int):
+    async def get_job_detail_by_id(cls, db: AsyncSession, job_id: int):
         """
         根据定时任务id获取定时任务详细信息
         :param db: orm对象
         :param job_id: 定时任务id
         :return: 定时任务信息对象
         """
-        job_info = db.query(SysJob) \
-            .filter(SysJob.job_id == job_id) \
-            .first()
+        job_info = (await db.execute(
+            select(SysJob)
+                .where(SysJob.job_id == job_id)
+        )).scalars().first()
 
         return job_info
 
     @classmethod
-    def get_job_detail_by_info(cls, db: Session, job: JobModel):
+    async def get_job_detail_by_info(cls, db: AsyncSession, job: JobModel):
         """
         根据定时任务参数获取定时任务信息
         :param db: orm对象
         :param job: 定时任务参数对象
         :return: 定时任务信息对象
         """
-        job_info = db.query(SysJob) \
-            .filter(SysJob.job_name == job.job_name if job.job_name else True,
-                    SysJob.job_group == job.job_group if job.job_group else True,
-                    SysJob.invoke_target == job.invoke_target if job.invoke_target else True,
-                    SysJob.cron_expression == job.cron_expression if job.cron_expression else True) \
-            .first()
+        job_info = (await db.execute(
+            select(SysJob)
+                .where(SysJob.job_name == job.job_name if job.job_name else True,
+                       SysJob.job_group == job.job_group if job.job_group else True,
+                       SysJob.invoke_target == job.invoke_target if job.invoke_target else True,
+                       SysJob.cron_expression == job.cron_expression if job.cron_expression else True)
+        )).scalars().first()
 
         return job_info
 
     @classmethod
-    def get_job_list(cls, db: Session, query_object: JobPageQueryModel, is_page: bool = False):
+    async def get_job_list(cls, db: AsyncSession, query_object: JobPageQueryModel, is_page: bool = False):
         """
         根据查询参数获取定时任务列表信息
         :param db: orm对象
@@ -49,31 +52,32 @@ class JobDao:
         :param is_page: 是否开启分页
         :return: 定时任务列表信息对象
         """
-        query = db.query(SysJob) \
-            .filter(SysJob.job_name.like(f'%{query_object.job_name}%') if query_object.job_name else True,
-                    SysJob.job_group == query_object.job_group if query_object.job_group else True,
-                    SysJob.status == query_object.status if query_object.status else True
-                    ) \
+        query = select(SysJob) \
+            .where(SysJob.job_name.like(f'%{query_object.job_name}%') if query_object.job_name else True,
+                   SysJob.job_group == query_object.job_group if query_object.job_group else True,
+                   SysJob.status == query_object.status if query_object.status else True) \
             .distinct()
-        job_list = PageUtil.paginate(query, query_object.page_num, query_object.page_size, is_page)
+        job_list = await PageUtil.paginate(db, query, query_object.page_num, query_object.page_size, is_page)
 
         return job_list
 
     @classmethod
-    def get_job_list_for_scheduler(cls, db: Session):
+    async def get_job_list_for_scheduler(cls, db: AsyncSession):
         """
         获取定时任务列表信息
         :param db: orm对象
         :return: 定时任务列表信息对象
         """
-        job_list = db.query(SysJob) \
-            .filter(SysJob.status == 0) \
-            .distinct().all()
+        job_list = (await db.execute(
+            select(SysJob)
+                .where(SysJob.status == 0)
+                .distinct()
+        )).scalars().all()
 
         return job_list
 
     @classmethod
-    def add_job_dao(cls, db: Session, job: JobModel):
+    async def add_job_dao(cls, db: AsyncSession, job: JobModel):
         """
         新增定时任务数据库操作
         :param db: orm对象
@@ -82,30 +86,32 @@ class JobDao:
         """
         db_job = SysJob(**job.model_dump())
         db.add(db_job)
-        db.flush()
+        await db.flush()
 
         return db_job
 
     @classmethod
-    def edit_job_dao(cls, db: Session, job: dict):
+    async def edit_job_dao(cls, db: AsyncSession, job: dict):
         """
         编辑定时任务数据库操作
         :param db: orm对象
         :param job: 需要更新的定时任务字典
         :return:
         """
-        db.query(SysJob) \
-            .filter(SysJob.job_id == job.get('job_id')) \
-            .update(job)
+        await db.execute(
+            update(SysJob),
+            [job]
+        )
 
     @classmethod
-    def delete_job_dao(cls, db: Session, job: JobModel):
+    async def delete_job_dao(cls, db: AsyncSession, job: JobModel):
         """
         删除定时任务数据库操作
         :param db: orm对象
         :param job: 定时任务对象
         :return:
         """
-        db.query(SysJob) \
-            .filter(SysJob.job_id == job.job_id) \
-            .delete()
+        await db.execute(
+            delete(SysJob)
+                .where(SysJob.job_id.in_([job.job_id]))
+        )

ruoyi-fastapi-backend/module_admin/dao/job_log_dao.py

@@ -1,3 +1,5 @@
+from sqlalchemy import select, delete
+from sqlalchemy.ext.asyncio import AsyncSession
 from sqlalchemy.orm import Session
 from module_admin.entity.do.job_do import SysJobLog
 from module_admin.entity.vo.job_vo import *
@@ -11,7 +13,7 @@ class JobLogDao:
     """
 
     @classmethod
-    def get_job_log_list(cls, db: Session, query_object: JobLogPageQueryModel, is_page: bool = False):
+    async def get_job_log_list(cls, db: AsyncSession, query_object: JobLogPageQueryModel, is_page: bool = False):
         """
         根据查询参数获取定时任务日志列表信息
         :param db: orm对象
@@ -19,17 +21,16 @@ class JobLogDao:
         :param is_page: 是否开启分页
         :return: 定时任务日志列表信息对象
         """
-        query = db.query(SysJobLog) \
-            .filter(SysJobLog.job_name.like(f'%{query_object.job_name}%') if query_object.job_name else True,
-                    SysJobLog.job_group == query_object.job_group if query_object.job_group else True,
-                    SysJobLog.status == query_object.status if query_object.status else True,
-                    SysJobLog.create_time.between(
-                        datetime.combine(datetime.strptime(query_object.begin_time, '%Y-%m-%d'), time(00, 00, 00)),
-                        datetime.combine(datetime.strptime(query_object.end_time, '%Y-%m-%d'), time(23, 59, 59)))
-                    if query_object.begin_time and query_object.end_time else True
-                    ) \
+        query = select(SysJobLog) \
+            .where(SysJobLog.job_name.like(f'%{query_object.job_name}%') if query_object.job_name else True,
+                   SysJobLog.job_group == query_object.job_group if query_object.job_group else True,
+                   SysJobLog.status == query_object.status if query_object.status else True,
+                   SysJobLog.create_time.between(
+                       datetime.combine(datetime.strptime(query_object.begin_time, '%Y-%m-%d'), time(00, 00, 00)),
+                       datetime.combine(datetime.strptime(query_object.end_time, '%Y-%m-%d'), time(23, 59, 59)))
+                   if query_object.begin_time and query_object.end_time else True) \
             .distinct()
-        job_log_list = PageUtil.paginate(query, query_object.page_num, query_object.page_size, is_page)
+        job_log_list = await PageUtil.paginate(db, query, query_object.page_num, query_object.page_size, is_page)
 
         return job_log_list
 
@@ -48,23 +49,25 @@ class JobLogDao:
         return db_job_log
 
     @classmethod
-    def delete_job_log_dao(cls, db: Session, job_log: JobLogModel):
+    async def delete_job_log_dao(cls, db: AsyncSession, job_log: JobLogModel):
         """
         删除定时任务日志数据库操作
         :param db: orm对象
         :param job_log: 定时任务日志对象
         :return:
         """
-        db.query(SysJobLog) \
-            .filter(SysJobLog.job_log_id == job_log.job_log_id) \
-            .delete()
+        await db.execute(
+            delete(SysJobLog)
+                .where(SysJobLog.job_log_id.in_([job_log.job_log_id]))
+        )
 
     @classmethod
-    def clear_job_log_dao(cls, db: Session):
+    async def clear_job_log_dao(cls, db: AsyncSession):
         """
         清除定时任务日志数据库操作
         :param db: orm对象
         :return:
         """
-        db.query(SysJobLog) \
-            .delete()
+        await db.execute(
+            delete(SysJobLog)
+        )

ruoyi-fastapi-backend/module_admin/dao/log_dao.py

@@ -1,5 +1,5 @@
-from sqlalchemy import asc, desc
-from sqlalchemy.orm import Session
+from sqlalchemy import select, update, delete, asc, desc
+from sqlalchemy.ext.asyncio import AsyncSession
 from module_admin.entity.do.log_do import SysOperLog, SysLogininfor
 from module_admin.entity.vo.log_vo import *
 from utils.page_util import PageUtil
@@ -11,8 +11,9 @@ class OperationLogDao:
     """
     操作日志管理模块数据库操作层
     """
+
     @classmethod
-    def get_operation_log_list(cls, db: Session, query_object: OperLogPageQueryModel, is_page: bool = False):
+    async def get_operation_log_list(cls, db: AsyncSession, query_object: OperLogPageQueryModel, is_page: bool = False):
         """
         根据查询参数获取操作日志列表信息
         :param db: orm对象
@@ -23,26 +24,27 @@ class OperationLogDao:
         if query_object.is_asc == 'ascending':
             order_by_column = asc(getattr(SysOperLog, CamelCaseUtil.camel_to_snake(query_object.order_by_column), None))
         elif query_object.is_asc == 'descending':
-            order_by_column = desc(getattr(SysOperLog, CamelCaseUtil.camel_to_snake(query_object.order_by_column), None))
+            order_by_column = desc(
+                getattr(SysOperLog, CamelCaseUtil.camel_to_snake(query_object.order_by_column), None))
         else:
             order_by_column = desc(SysOperLog.oper_time)
-        query = db.query(SysOperLog) \
-            .filter(SysOperLog.title.like(f'%{query_object.title}%') if query_object.title else True,
-                    SysOperLog.oper_name.like(f'%{query_object.oper_name}%') if query_object.oper_name else True,
-                    SysOperLog.business_type == query_object.business_type if query_object.business_type else True,
-                    SysOperLog.status == query_object.status if query_object.status else True,
-                    SysOperLog.oper_time.between(
-                        datetime.combine(datetime.strptime(query_object.begin_time, '%Y-%m-%d'), time(00, 00, 00)),
-                        datetime.combine(datetime.strptime(query_object.end_time, '%Y-%m-%d'), time(23, 59, 59)))
-                                if query_object.begin_time and query_object.end_time else True
-                    )\
-            .distinct().order_by(order_by_column)
-        operation_log_list = PageUtil.paginate(query, query_object.page_num, query_object.page_size, is_page)
+        query = select(SysOperLog) \
+            .where(SysOperLog.title.like(f'%{query_object.title}%') if query_object.title else True,
+                   SysOperLog.oper_name.like(f'%{query_object.oper_name}%') if query_object.oper_name else True,
+                   SysOperLog.business_type == query_object.business_type if query_object.business_type else True,
+                   SysOperLog.status == query_object.status if query_object.status else True,
+                   SysOperLog.oper_time.between(
+                       datetime.combine(datetime.strptime(query_object.begin_time, '%Y-%m-%d'), time(00, 00, 00)),
+                       datetime.combine(datetime.strptime(query_object.end_time, '%Y-%m-%d'), time(23, 59, 59)))
+                   if query_object.begin_time and query_object.end_time else True) \
+            .distinct() \
+            .order_by(order_by_column)
+        operation_log_list = await PageUtil.paginate(db, query, query_object.page_num, query_object.page_size, is_page)
 
         return operation_log_list
 
     @classmethod
-    def add_operation_log_dao(cls, db: Session, operation_log: OperLogModel):
+    async def add_operation_log_dao(cls, db: AsyncSession, operation_log: OperLogModel):
         """
         新增操作日志数据库操作
         :param db: orm对象
@@ -51,31 +53,33 @@ class OperationLogDao:
         """
         db_operation_log = SysOperLog(**operation_log.model_dump())
         db.add(db_operation_log)
-        db.flush()
+        await db.flush()
 
         return db_operation_log
 
     @classmethod
-    def delete_operation_log_dao(cls, db: Session, operation_log: OperLogModel):
+    async def delete_operation_log_dao(cls, db: AsyncSession, operation_log: OperLogModel):
         """
         删除操作日志数据库操作
         :param db: orm对象
         :param operation_log: 操作日志对象
         :return:
         """
-        db.query(SysOperLog) \
-            .filter(SysOperLog.oper_id == operation_log.oper_id) \
-            .delete()
+        await db.execute(
+            delete(SysOperLog)
+                .where(SysOperLog.oper_id.in_([operation_log.oper_id]))
+        )
 
     @classmethod
-    def clear_operation_log_dao(cls, db: Session):
+    async def clear_operation_log_dao(cls, db: AsyncSession):
         """
         清除操作日志数据库操作
         :param db: orm对象
         :return:
         """
-        db.query(SysOperLog) \
-            .delete()
+        await db.execute(
+            delete(SysOperLog)
+        )
 
 
 class LoginLogDao:
@@ -84,7 +88,7 @@ class LoginLogDao:
     """
 
     @classmethod
-    def get_login_log_list(cls, db: Session, query_object: LoginLogPageQueryModel, is_page: bool = False):
+    async def get_login_log_list(cls, db: AsyncSession, query_object: LoginLogPageQueryModel, is_page: bool = False):
         """
         根据查询参数获取登录日志列表信息
         :param db: orm对象
@@ -93,27 +97,29 @@ class LoginLogDao:
         :return: 登录日志列表信息对象
         """
         if query_object.is_asc == 'ascending':
-            order_by_column = asc(getattr(SysLogininfor, CamelCaseUtil.camel_to_snake(query_object.order_by_column), None))
+            order_by_column = asc(
+                getattr(SysLogininfor, CamelCaseUtil.camel_to_snake(query_object.order_by_column), None))
         elif query_object.is_asc == 'descending':
-            order_by_column = desc(getattr(SysLogininfor, CamelCaseUtil.camel_to_snake(query_object.order_by_column), None))
+            order_by_column = desc(
+                getattr(SysLogininfor, CamelCaseUtil.camel_to_snake(query_object.order_by_column), None))
         else:
             order_by_column = desc(SysLogininfor.login_time)
-        query = db.query(SysLogininfor) \
-            .filter(SysLogininfor.ipaddr.like(f'%{query_object.ipaddr}%') if query_object.ipaddr else True,
-                    SysLogininfor.user_name.like(f'%{query_object.user_name}%') if query_object.user_name else True,
-                    SysLogininfor.status == query_object.status if query_object.status else True,
-                    SysLogininfor.login_time.between(
-                        datetime.combine(datetime.strptime(query_object.begin_time, '%Y-%m-%d'), time(00, 00, 00)),
-                        datetime.combine(datetime.strptime(query_object.end_time, '%Y-%m-%d'), time(23, 59, 59)))
-                                if query_object.begin_time and query_object.end_time else True
-                    )\
-            .distinct().order_by(order_by_column)
-        login_log_list = PageUtil.paginate(query, query_object.page_num, query_object.page_size, is_page)
+        query = select(SysLogininfor) \
+            .where(SysLogininfor.ipaddr.like(f'%{query_object.ipaddr}%') if query_object.ipaddr else True,
+                   SysLogininfor.user_name.like(f'%{query_object.user_name}%') if query_object.user_name else True,
+                   SysLogininfor.status == query_object.status if query_object.status else True,
+                   SysLogininfor.login_time.between(
+                       datetime.combine(datetime.strptime(query_object.begin_time, '%Y-%m-%d'), time(00, 00, 00)),
+                       datetime.combine(datetime.strptime(query_object.end_time, '%Y-%m-%d'), time(23, 59, 59)))
+                   if query_object.begin_time and query_object.end_time else True) \
+            .distinct() \
+            .order_by(order_by_column)
+        login_log_list = await PageUtil.paginate(db, query, query_object.page_num, query_object.page_size, is_page)
 
         return login_log_list
 
     @classmethod
-    def add_login_log_dao(cls, db: Session, login_log: LogininforModel):
+    async def add_login_log_dao(cls, db: AsyncSession, login_log: LogininforModel):
         """
         新增登录日志数据库操作
         :param db: orm对象
@@ -122,28 +128,30 @@ class LoginLogDao:
         """
         db_login_log = SysLogininfor(**login_log.model_dump())
         db.add(db_login_log)
-        db.flush()
+        await db.flush()
 
         return db_login_log
 
     @classmethod
-    def delete_login_log_dao(cls, db: Session, login_log: LogininforModel):
+    async def delete_login_log_dao(cls, db: AsyncSession, login_log: LogininforModel):
         """
         删除登录日志数据库操作
         :param db: orm对象
         :param login_log: 登录日志对象
         :return:
         """
-        db.query(SysLogininfor) \
-            .filter(SysLogininfor.info_id == login_log.info_id) \
-            .delete()
+        await db.execute(
+            delete(SysLogininfor)
+                .where(SysLogininfor.info_id.in_([login_log.info_id]))
+        )
 
     @classmethod
-    def clear_login_log_dao(cls, db: Session):
+    async def clear_login_log_dao(cls, db: AsyncSession):
         """
         清除登录日志数据库操作
         :param db: orm对象
         :return:
         """
-        db.query(SysLogininfor) \
-            .delete()
+        await db.execute(
+            delete(SysLogininfor)
+        )

ruoyi-fastapi-backend/module_admin/dao/login_dao.py

@@ -1,20 +1,21 @@
-from sqlalchemy.orm import Session
-from sqlalchemy import and_
+from sqlalchemy import select, and_
+from sqlalchemy.ext.asyncio import AsyncSession
 from module_admin.entity.do.user_do import SysUser
 from module_admin.entity.do.dept_do import SysDept
 
 
-def login_by_account(db: Session, user_name: str):
+async def login_by_account(db: AsyncSession, user_name: str):
     """
     根据用户名查询用户信息
     :param db: orm对象
     :param user_name: 用户名
     :return: 用户对象
     """
-    user = db.query(SysUser, SysDept)\
-        .filter(SysUser.user_name == user_name, SysUser.del_flag == '0') \
-        .outerjoin(SysDept, and_(SysUser.dept_id == SysDept.dept_id, SysDept.status == 0, SysDept.del_flag == 0)) \
-        .distinct() \
-        .first()
+    user = (await db.execute(
+        select(SysUser, SysDept)
+            .where(SysUser.user_name == user_name, SysUser.del_flag == '0')
+            .join(SysDept, and_(SysUser.dept_id == SysDept.dept_id, SysDept.status == 0, SysDept.del_flag == 0), isouter=True)
+            .distinct()
+    )).first()
 
     return user

ruoyi-fastapi-backend/module_admin/dao/menu_dao.py

@@ -1,5 +1,5 @@
-from sqlalchemy import and_
-from sqlalchemy.orm import Session
+from sqlalchemy import select, update, delete, and_
+from sqlalchemy.ext.asyncio import AsyncSession
 from module_admin.entity.do.menu_do import SysMenu
 from module_admin.entity.do.user_do import SysUser, SysUserRole
 from module_admin.entity.do.role_do import SysRole, SysRoleMenu
@@ -12,37 +12,39 @@ class MenuDao:
     """
 
     @classmethod
-    def get_menu_detail_by_id(cls, db: Session, menu_id: int):
+    async def get_menu_detail_by_id(cls, db: AsyncSession, menu_id: int):
         """
         根据菜单id获取菜单详细信息
         :param db: orm对象
         :param menu_id: 菜单id
         :return: 菜单信息对象
         """
-        menu_info = db.query(SysMenu) \
-            .filter(SysMenu.menu_id == menu_id) \
-            .first()
+        menu_info = (await db.execute(
+            select(SysMenu)
+                .where(SysMenu.menu_id == menu_id)
+        )).scalars().first()
 
         return menu_info
 
     @classmethod
-    def get_menu_detail_by_info(cls, db: Session, menu: MenuModel):
+    async def get_menu_detail_by_info(cls, db: AsyncSession, menu: MenuModel):
         """
         根据菜单参数获取菜单信息
         :param db: orm对象
         :param menu: 菜单参数对象
         :return: 菜单信息对象
         """
-        menu_info = db.query(SysMenu) \
-            .filter(SysMenu.parent_id == menu.parent_id if menu.parent_id else True,
-                    SysMenu.menu_name == menu.menu_name if menu.menu_name else True,
-                    SysMenu.menu_type == menu.menu_type if menu.menu_type else True) \
-            .first()
+        menu_info = (await db.execute(
+            select(SysMenu)
+                .where(SysMenu.parent_id == menu.parent_id if menu.parent_id else True,
+                       SysMenu.menu_name == menu.menu_name if menu.menu_name else True,
+                       SysMenu.menu_type == menu.menu_type if menu.menu_type else True)
+        )).scalars().first()
 
         return menu_info
 
     @classmethod
-    def get_menu_list_for_tree(cls, db: Session, user_id: int, role: list):
+    async def get_menu_list_for_tree(cls, db: AsyncSession, user_id: int, role: list):
         """
         根据角色信息获取所有在用菜单列表信息
         :param db: orm对象
@@ -52,25 +54,31 @@ class MenuDao:
         """
         role_id_list = [item.role_id for item in role]
         if 1 in role_id_list:
-            menu_query_all = db.query(SysMenu) \
-                .filter(SysMenu.status == 0) \
-                .order_by(SysMenu.order_num) \
-                .distinct().all()
+            menu_query_all = (await db.execute(
+                select(SysMenu)
+                    .where(SysMenu.status == 0)
+                    .order_by(SysMenu.order_num)
+                    .distinct()
+            )).scalars().all()
         else:
-            menu_query_all = db.query(SysMenu).select_from(SysUser) \
-                .filter(SysUser.status == 0, SysUser.del_flag == 0, SysUser.user_id == user_id) \
-                .outerjoin(SysUserRole, SysUser.user_id == SysUserRole.user_id) \
-                .outerjoin(SysRole,
-                           and_(SysUserRole.role_id == SysRole.role_id, SysRole.status == 0, SysRole.del_flag == 0)) \
-                .outerjoin(SysRoleMenu, SysRole.role_id == SysRoleMenu.role_id) \
-                .join(SysMenu, and_(SysRoleMenu.menu_id == SysMenu.menu_id, SysMenu.status == 0,)) \
-                .order_by(SysMenu.order_num) \
-                .distinct().all()
+            menu_query_all = (await db.execute(
+                select(SysMenu)
+                    .select_from(SysUser)
+                    .where(SysUser.status == 0, SysUser.del_flag == 0, SysUser.user_id == user_id)
+                    .join(SysUserRole, SysUser.user_id == SysUserRole.user_id, isouter=True)
+                    .join(SysRole,
+                          and_(SysUserRole.role_id == SysRole.role_id, SysRole.status == 0, SysRole.del_flag == 0),
+                          isouter=True)
+                    .join(SysRoleMenu, SysRole.role_id == SysRoleMenu.role_id, isouter=True)
+                    .join(SysMenu, and_(SysRoleMenu.menu_id == SysMenu.menu_id, SysMenu.status == 0))
+                    .order_by(SysMenu.order_num)
+                    .distinct()
+            )).scalars().all()
 
         return menu_query_all
 
     @classmethod
-    def get_menu_list(cls, db: Session, page_object: MenuQueryModel, user_id: int, role: list):
+    async def get_menu_list(cls, db: AsyncSession, page_object: MenuQueryModel, user_id: int, role: list):
         """
         根据查询参数获取菜单列表信息
         :param db: orm对象
@@ -81,30 +89,36 @@ class MenuDao:
         """
         role_id_list = [item.role_id for item in role]
         if 1 in role_id_list:
-            menu_query_all = db.query(SysMenu) \
-                .filter(SysMenu.status == page_object.status if page_object.status else True,
-                        SysMenu.menu_name.like(
-                            f'%{page_object.menu_name}%') if page_object.menu_name else True) \
-                .order_by(SysMenu.order_num) \
-                .distinct().all()
+            menu_query_all = (await db.execute(
+                select(SysMenu)
+                    .where(SysMenu.status == page_object.status if page_object.status else True,
+                           SysMenu.menu_name.like(
+                               f'%{page_object.menu_name}%') if page_object.menu_name else True)
+                    .order_by(SysMenu.order_num)
+                    .distinct()
+            )).scalars().all()
         else:
-            menu_query_all = db.query(SysMenu).select_from(SysUser) \
-                .filter(SysUser.status == 0, SysUser.del_flag == 0, SysUser.user_id == user_id) \
-                .outerjoin(SysUserRole, SysUser.user_id == SysUserRole.user_id) \
-                .outerjoin(SysRole,
-                           and_(SysUserRole.role_id == SysRole.role_id, SysRole.status == 0, SysRole.del_flag == 0)) \
-                .outerjoin(SysRoleMenu, SysRole.role_id == SysRoleMenu.role_id) \
-                .join(SysMenu, and_(SysRoleMenu.menu_id == SysMenu.menu_id,
-                                    SysMenu.status == page_object.status if page_object.status else True,
-                                    SysMenu.menu_name.like(
-                                        f'%{page_object.menu_name}%') if page_object.menu_name else True)) \
-                .order_by(SysMenu.order_num) \
-                .distinct().all()
+            menu_query_all = (await db.execute(
+                select(SysMenu)
+                    .select_from(SysUser)
+                    .where(SysUser.status == 0, SysUser.del_flag == 0, SysUser.user_id == user_id)
+                    .join(SysUserRole, SysUser.user_id == SysUserRole.user_id, isouter=True)
+                    .join(SysRole,
+                          and_(SysUserRole.role_id == SysRole.role_id, SysRole.status == 0, SysRole.del_flag == 0),
+                          isouter=True)
+                    .join(SysRoleMenu, SysRole.role_id == SysRoleMenu.role_id, isouter=True)
+                    .join(SysMenu, and_(SysRoleMenu.menu_id == SysMenu.menu_id,
+                                        SysMenu.status == page_object.status if page_object.status else True,
+                                        SysMenu.menu_name.like(
+                                            f'%{page_object.menu_name}%') if page_object.menu_name else True))
+                    .order_by(SysMenu.order_num)
+                    .distinct()
+            )).scalars().all()
 
         return menu_query_all
 
     @classmethod
-    def add_menu_dao(cls, db: Session, menu: MenuModel):
+    async def add_menu_dao(cls, db: AsyncSession, menu: MenuModel):
         """
         新增菜单数据库操作
         :param db: orm对象
@@ -113,30 +127,32 @@ class MenuDao:
         """
         db_menu = SysMenu(**menu.model_dump())
         db.add(db_menu)
-        db.flush()
+        await db.flush()
 
         return db_menu
 
     @classmethod
-    def edit_menu_dao(cls, db: Session, menu: dict):
+    async def edit_menu_dao(cls, db: AsyncSession, menu: dict):
         """
         编辑菜单数据库操作
         :param db: orm对象
         :param menu: 需要更新的菜单字典
         :return:
         """
-        db.query(SysMenu) \
-            .filter(SysMenu.menu_id == menu.get('menu_id')) \
-            .update(menu)
+        await db.execute(
+            update(SysMenu),
+            [menu]
+        )
 
     @classmethod
-    def delete_menu_dao(cls, db: Session, menu: MenuModel):
+    async def delete_menu_dao(cls, db: AsyncSession, menu: MenuModel):
         """
         删除菜单数据库操作
         :param db: orm对象
         :param menu: 菜单对象
         :return:
         """
-        db.query(SysMenu) \
-            .filter(SysMenu.menu_id == menu.menu_id) \
-            .delete()
+        await db.execute(
+            delete(SysMenu)
+                .where(SysMenu.menu_id.in_([menu.menu_id]))
+        )

ruoyi-fastapi-backend/module_admin/dao/notice_dao.py

@@ -1,4 +1,5 @@
-from sqlalchemy.orm import Session
+from sqlalchemy import select, update, delete
+from sqlalchemy.ext.asyncio import AsyncSession
 from module_admin.entity.do.notice_do import SysNotice
 from module_admin.entity.vo.notice_vo import *
 from utils.page_util import PageUtil
@@ -11,37 +12,39 @@ class NoticeDao:
     """
 
     @classmethod
-    def get_notice_detail_by_id(cls, db: Session, notice_id: int):
+    async def get_notice_detail_by_id(cls, db: AsyncSession, notice_id: int):
         """
         根据通知公告id获取通知公告详细信息
         :param db: orm对象
         :param notice_id: 通知公告id
         :return: 通知公告信息对象
         """
-        notice_info = db.query(SysNotice) \
-            .filter(SysNotice.notice_id == notice_id) \
-            .first()
+        notice_info = (await db.execute(
+            select(SysNotice)
+                .where(SysNotice.notice_id == notice_id)
+        )).scalars().first()
 
         return notice_info
 
     @classmethod
-    def get_notice_detail_by_info(cls, db: Session, notice: NoticeModel):
+    async def get_notice_detail_by_info(cls, db: AsyncSession, notice: NoticeModel):
         """
         根据通知公告参数获取通知公告信息
         :param db: orm对象
         :param notice: 通知公告参数对象
         :return: 通知公告信息对象
         """
-        notice_info = db.query(SysNotice) \
-            .filter(SysNotice.notice_title == notice.notice_title if notice.notice_title else True,
-                    SysNotice.notice_type == notice.notice_type if notice.notice_type else True,
-                    SysNotice.notice_content == notice.notice_content if notice.notice_content else True) \
-            .first()
+        notice_info = (await db.execute(
+            select(SysNotice)
+                .where(SysNotice.notice_title == notice.notice_title if notice.notice_title else True,
+                       SysNotice.notice_type == notice.notice_type if notice.notice_type else True,
+                       SysNotice.notice_content == notice.notice_content if notice.notice_content else True)
+        )).scalars().first()
 
         return notice_info
 
     @classmethod
-    def get_notice_list(cls, db: Session, query_object: NoticePageQueryModel, is_page: bool = False):
+    async def get_notice_list(cls, db: AsyncSession, query_object: NoticePageQueryModel, is_page: bool = False):
         """
         根据查询参数获取通知公告列表信息
         :param db: orm对象
@@ -49,22 +52,21 @@ class NoticeDao:
         :param is_page: 是否开启分页
         :return: 通知公告列表信息对象
         """
-        query = db.query(SysNotice) \
-            .filter(SysNotice.notice_title.like(f'%{query_object.notice_title}%') if query_object.notice_title else True,
-                    SysNotice.create_by.like(f'%{query_object.create_by}%') if query_object.create_by else True,
-                    SysNotice.notice_type == query_object.notice_type if query_object.notice_type else True,
-                    SysNotice.create_time.between(
-                        datetime.combine(datetime.strptime(query_object.begin_time, '%Y-%m-%d'), time(00, 00, 00)),
-                        datetime.combine(datetime.strptime(query_object.end_time, '%Y-%m-%d'), time(23, 59, 59)))
-                                      if query_object.begin_time and query_object.end_time else True
-                    ) \
+        query = select(SysNotice) \
+            .where(SysNotice.notice_title.like(f'%{query_object.notice_title}%') if query_object.notice_title else True,
+                   SysNotice.create_by.like(f'%{query_object.create_by}%') if query_object.create_by else True,
+                   SysNotice.notice_type == query_object.notice_type if query_object.notice_type else True,
+                   SysNotice.create_time.between(
+                       datetime.combine(datetime.strptime(query_object.begin_time, '%Y-%m-%d'), time(00, 00, 00)),
+                       datetime.combine(datetime.strptime(query_object.end_time, '%Y-%m-%d'), time(23, 59, 59)))
+                   if query_object.begin_time and query_object.end_time else True) \
             .distinct()
-        notice_list = PageUtil.paginate(query, query_object.page_num, query_object.page_size, is_page)
+        notice_list = await PageUtil.paginate(db, query, query_object.page_num, query_object.page_size, is_page)
 
         return notice_list
 
     @classmethod
-    def add_notice_dao(cls, db: Session, notice: NoticeModel):
+    async def add_notice_dao(cls, db: AsyncSession, notice: NoticeModel):
         """
         新增通知公告数据库操作
         :param db: orm对象
@@ -73,30 +75,32 @@ class NoticeDao:
         """
         db_notice = SysNotice(**notice.model_dump())
         db.add(db_notice)
-        db.flush()
+        await db.flush()
 
         return db_notice
 
     @classmethod
-    def edit_notice_dao(cls, db: Session, notice: dict):
+    async def edit_notice_dao(cls, db: AsyncSession, notice: dict):
         """
         编辑通知公告数据库操作
         :param db: orm对象
         :param notice: 需要更新的通知公告字典
         :return:
         """
-        db.query(SysNotice) \
-            .filter(SysNotice.notice_id == notice.get('notice_id')) \
-            .update(notice)
+        await db.execute(
+            update(SysNotice),
+            [notice]
+        )
 
     @classmethod
-    def delete_notice_dao(cls, db: Session, notice: NoticeModel):
+    async def delete_notice_dao(cls, db: AsyncSession, notice: NoticeModel):
         """
         删除通知公告数据库操作
         :param db: orm对象
         :param notice: 通知公告对象
         :return:
         """
-        db.query(SysNotice) \
-            .filter(SysNotice.notice_id == notice.notice_id) \
-            .delete()
+        await db.execute(
+            delete(SysNotice)
+                .where(SysNotice.notice_id.in_([notice.notice_id]))
+        )

ruoyi-fastapi-backend/module_admin/dao/post_dao.py

@@ -1,4 +1,5 @@
-from sqlalchemy.orm import Session
+from sqlalchemy import select, update, delete
+from sqlalchemy.ext.asyncio import AsyncSession
 from module_admin.entity.do.post_do import SysPost
 from module_admin.entity.vo.post_vo import *
 from utils.page_util import PageUtil
@@ -10,52 +11,55 @@ class PostDao:
     """
 
     @classmethod
-    def get_post_by_id(cls, db: Session, post_id: int):
+    async def get_post_by_id(cls, db: AsyncSession, post_id: int):
         """
         根据岗位id获取在用岗位详细信息
         :param db: orm对象
         :param post_id: 岗位id
         :return: 在用岗位信息对象
         """
-        post_info = db.query(SysPost) \
-            .filter(SysPost.post_id == post_id,
-                    SysPost.status == 0) \
-            .first()
+        post_info = (await db.execute(
+            select(SysPost)
+                .where(SysPost.post_id == post_id,
+                       SysPost.status == 0)
+        )).scalars().first()
 
         return post_info
 
     @classmethod
-    def get_post_detail_by_id(cls, db: Session, post_id: int):
+    async def get_post_detail_by_id(cls, db: AsyncSession, post_id: int):
         """
         根据岗位id获取岗位详细信息
         :param db: orm对象
         :param post_id: 岗位id
         :return: 岗位信息对象
         """
-        post_info = db.query(SysPost) \
-            .filter(SysPost.post_id == post_id) \
-            .first()
+        post_info = (await db.execute(
+            select(SysPost)
+                .where(SysPost.post_id == post_id)
+        )).scalars().first()
 
         return post_info
 
     @classmethod
-    def get_post_detail_by_info(cls, db: Session, post: PostModel):
+    async def get_post_detail_by_info(cls, db: AsyncSession, post: PostModel):
         """
         根据岗位参数获取岗位信息
         :param db: orm对象
         :param post: 岗位参数对象
         :return: 岗位信息对象
         """
-        post_info = db.query(SysPost) \
-            .filter(SysPost.post_name == post.post_name if post.post_name else True,
-                    SysPost.post_code == post.post_code if post.post_code else True,
-                    SysPost.post_sort == post.post_sort if post.post_sort else True) \
-            .first()
+        post_info = (await db.execute(
+            select(SysPost)
+                .where(SysPost.post_name == post.post_name if post.post_name else True,
+                       SysPost.post_code == post.post_code if post.post_code else True,
+                       SysPost.post_sort == post.post_sort if post.post_sort else True)
+        )).scalars().first()
 
         return post_info
 
     @classmethod
-    def get_post_list(cls, db: Session, query_object: PostPageQueryModel, is_page: bool = False):
+    async def get_post_list(cls, db: AsyncSession, query_object: PostPageQueryModel, is_page: bool = False):
         """
         根据查询参数获取岗位列表信息
         :param db: orm对象
@@ -63,19 +67,18 @@ class PostDao:
         :param is_page: 是否开启分页
         :return: 岗位列表信息对象
         """
-        query = db.query(SysPost) \
-            .filter(SysPost.post_code.like(f'%{query_object.post_code}%') if query_object.post_code else True,
-                    SysPost.post_name.like(f'%{query_object.post_name}%') if query_object.post_name else True,
-                    SysPost.status == query_object.status if query_object.status else True
-                    ) \
+        query = select(SysPost) \
+            .where(SysPost.post_code.like(f'%{query_object.post_code}%') if query_object.post_code else True,
+                   SysPost.post_name.like(f'%{query_object.post_name}%') if query_object.post_name else True,
+                   SysPost.status == query_object.status if query_object.status else True) \
             .order_by(SysPost.post_sort) \
             .distinct()
-        post_list = PageUtil.paginate(query, query_object.page_num, query_object.page_size, is_page)
+        post_list = await PageUtil.paginate(db, query, query_object.page_num, query_object.page_size, is_page)
 
         return post_list
 
     @classmethod
-    def add_post_dao(cls, db: Session, post: PostModel):
+    async def add_post_dao(cls, db: AsyncSession, post: PostModel):
         """
         新增岗位数据库操作
         :param db: orm对象
@@ -84,30 +87,32 @@ class PostDao:
         """
         db_post = SysPost(**post.model_dump())
         db.add(db_post)
-        db.flush()
+        await db.flush()
 
         return db_post
 
     @classmethod
-    def edit_post_dao(cls, db: Session, post: dict):
+    async def edit_post_dao(cls, db: AsyncSession, post: dict):
         """
         编辑岗位数据库操作
         :param db: orm对象
         :param post: 需要更新的岗位字典
         :return:
         """
-        db.query(SysPost) \
-            .filter(SysPost.post_id == post.get('post_id')) \
-            .update(post)
+        await db.execute(
+            update(SysPost),
+            [post]
+        )
 
     @classmethod
-    def delete_post_dao(cls, db: Session, post: PostModel):
+    async def delete_post_dao(cls, db: AsyncSession, post: PostModel):
         """
         删除岗位数据库操作
         :param db: orm对象
         :param post: 岗位对象
         :return:
         """
-        db.query(SysPost) \
-            .filter(SysPost.post_id == post.post_id) \
-            .delete()
+        await db.execute(
+            delete(SysPost)
+                .where(SysPost.post_id.in_([post.post_id]))
+        )

ruoyi-fastapi-backend/module_admin/dao/role_dao.py

@@ -1,5 +1,5 @@
-from sqlalchemy import desc, func
-from sqlalchemy.orm import Session
+from sqlalchemy import select, update, delete, desc, func
+from sqlalchemy.ext.asyncio import AsyncSession
 from module_admin.entity.do.role_do import SysRole, SysRoleMenu, SysRoleDept
 from module_admin.entity.do.dept_do import SysDept
 from module_admin.entity.vo.role_vo import *
@@ -13,80 +13,90 @@ class RoleDao:
     """
 
     @classmethod
-    def get_role_by_name(cls, db: Session, role_name: str):
+    async def get_role_by_name(cls, db: AsyncSession, role_name: str):
         """
         根据角色名获取在用角色信息
         :param db: orm对象
         :param role_name: 角色名
         :return: 当前角色名的角色信息对象
         """
-        query_role_info = db.query(SysRole) \
-            .filter(SysRole.status == 0, SysRole.del_flag == 0, SysRole.role_name == role_name) \
-            .order_by(desc(SysRole.create_time)).distinct().first()
+        query_role_info = (await db.execute(
+            select(SysRole)
+                .where(SysRole.status == 0, SysRole.del_flag == 0, SysRole.role_name == role_name)
+                .order_by(desc(SysRole.create_time))
+                .distinct()
+        )).scalars().first()
 
         return query_role_info
 
     @classmethod
-    def get_role_by_info(cls, db: Session, role: RoleModel):
+    async def get_role_by_info(cls, db: AsyncSession, role: RoleModel):
         """
         根据角色参数获取角色信息
         :param db: orm对象
         :param role: 角色参数
         :return: 当前角色参数的角色信息对象
         """
-        query_role_info = db.query(SysRole) \
-            .filter(SysRole.del_flag == 0,
-                    SysRole.role_name == role.role_name if role.role_name else True,
-                    SysRole.role_key == role.role_key if role.role_key else True) \
-            .order_by(desc(SysRole.create_time)).distinct().first()
+        query_role_info = (await db.execute(
+            select(SysRole)
+                .where(SysRole.del_flag == 0,
+                       SysRole.role_name == role.role_name if role.role_name else True,
+                       SysRole.role_key == role.role_key if role.role_key else True)
+                .order_by(desc(SysRole.create_time))
+                .distinct()
+        )).scalars().first()
 
         return query_role_info
 
     @classmethod
-    def get_role_by_id(cls, db: Session, role_id: int):
+    async def get_role_by_id(cls, db: AsyncSession, role_id: int):
         """
         根据角色id获取在用角色信息
         :param db: orm对象
         :param role_id: 角色id
         :return: 当前角色id的角色信息对象
         """
-        role_info = db.query(SysRole) \
-            .filter(SysRole.role_id == role_id,
-                    SysRole.status == 0,
-                    SysRole.del_flag == 0) \
-            .first()
+        role_info = (await db.execute(
+            select(SysRole)
+                .where(SysRole.role_id == role_id,
+                       SysRole.status == 0,
+                       SysRole.del_flag == 0)
+        )).scalars().first()
 
         return role_info
 
     @classmethod
-    def get_role_detail_by_id(cls, db: Session, role_id: int):
+    async def get_role_detail_by_id(cls, db: AsyncSession, role_id: int):
         """
         根据role_id获取角色详细信息
         :param db: orm对象
         :param role_id: 角色id
         :return: 当前role_id的角色信息对象
         """
-        query_role_info = db.query(SysRole) \
-            .filter(SysRole.del_flag == 0, SysRole.role_id == role_id) \
-            .distinct().first()
+        query_role_info = (await db.execute(
+            select(SysRole)
+                .where(SysRole.del_flag == 0, SysRole.role_id == role_id)
+                .distinct()
+        )).scalars().first()
 
         return query_role_info
 
     @classmethod
-    def get_role_select_option_dao(cls, db: Session):
+    async def get_role_select_option_dao(cls, db: AsyncSession):
         """
         获取编辑页面对应的在用角色列表信息
         :param db: orm对象
         :return: 角色列表信息
         """
-        role_info = db.query(SysRole) \
-            .filter(SysRole.role_id != 1, SysRole.status == 0, SysRole.del_flag == 0) \
-            .all()
+        role_info = (await db.execute(
+            select(SysRole)
+                .where(SysRole.role_id != 1, SysRole.status == 0, SysRole.del_flag == 0)
+        )).scalars().all()
 
         return role_info
 
     @classmethod
-    def get_role_list(cls, db: Session, query_object: RolePageQueryModel, is_page: bool = False):
+    async def get_role_list(cls, db: AsyncSession, query_object: RolePageQueryModel, is_page: bool = False):
         """
         根据查询参数获取角色列表信息
         :param db: orm对象
@@ -94,24 +104,23 @@ class RoleDao:
         :param is_page: 是否开启分页
         :return: 角色列表信息对象
         """
-        query = db.query(SysRole) \
-            .filter(SysRole.del_flag == 0,
-                    SysRole.role_name.like(f'%{query_object.role_name}%') if query_object.role_name else True,
-                    SysRole.role_key.like(f'%{query_object.role_key}%') if query_object.role_key else True,
-                    SysRole.status == query_object.status if query_object.status else True,
-                    SysRole.create_time.between(
-                        datetime.combine(datetime.strptime(query_object.begin_time, '%Y-%m-%d'), time(00, 00, 00)),
-                        datetime.combine(datetime.strptime(query_object.end_time, '%Y-%m-%d'), time(23, 59, 59)))
-                    if query_object.begin_time and query_object.end_time else True
-                    ) \
+        query = select(SysRole) \
+            .where(SysRole.del_flag == 0,
+                   SysRole.role_name.like(f'%{query_object.role_name}%') if query_object.role_name else True,
+                   SysRole.role_key.like(f'%{query_object.role_key}%') if query_object.role_key else True,
+                   SysRole.status == query_object.status if query_object.status else True,
+                   SysRole.create_time.between(
+                       datetime.combine(datetime.strptime(query_object.begin_time, '%Y-%m-%d'), time(00, 00, 00)),
+                       datetime.combine(datetime.strptime(query_object.end_time, '%Y-%m-%d'), time(23, 59, 59)))
+                   if query_object.begin_time and query_object.end_time else True) \
             .order_by(SysRole.role_sort) \
             .distinct()
-        role_list = PageUtil.paginate(query, query_object.page_num, query_object.page_size, is_page)
+        role_list = await PageUtil.paginate(db, query, query_object.page_num, query_object.page_size, is_page)
 
         return role_list
 
     @classmethod
-    def add_role_dao(cls, db: Session, role: RoleModel):
+    async def add_role_dao(cls, db: AsyncSession, role: RoleModel):
         """
         新增角色数据库操作
         :param db: orm对象
@@ -120,50 +129,55 @@ class RoleDao:
         """
         db_role = SysRole(**role.model_dump(exclude={'admin'}))
         db.add(db_role)
-        db.flush()
+        await db.flush()
 
         return db_role
 
     @classmethod
-    def edit_role_dao(cls, db: Session, role: dict):
+    async def edit_role_dao(cls, db: AsyncSession, role: dict):
         """
         编辑角色数据库操作
         :param db: orm对象
         :param role: 需要更新的角色字典
         :return:
         """
-        db.query(SysRole) \
-            .filter(SysRole.role_id == role.get('role_id')) \
-            .update(role)
+        await db.execute(
+            update(SysRole),
+            [role]
+        )
 
     @classmethod
-    def delete_role_dao(cls, db: Session, role: RoleModel):
+    async def delete_role_dao(cls, db: AsyncSession, role: RoleModel):
         """
         删除角色数据库操作
         :param db: orm对象
         :param role: 角色对象
         :return:
         """
-        db.query(SysRole) \
-            .filter(SysRole.role_id == role.role_id) \
-            .update({SysRole.del_flag: '2', SysRole.update_by: role.update_by, SysRole.update_time: role.update_time})
+        await db.execute(
+            update(SysRole)
+                .where(SysRole.role_id == role.role_id)
+                .values(del_flag='2', update_by=role.update_by, update_time=role.update_time)
+        )
 
     @classmethod
-    def get_role_menu_dao(cls, db: Session, role_id: int):
+    async def get_role_menu_dao(cls, db: AsyncSession, role_id: int):
         """
         根据角色id获取角色菜单关联列表信息
         :param db: orm对象
         :param role_id: 角色id
         :return: 角色菜单关联列表信息
         """
-        role_menu_query_all = db.query(SysRoleMenu) \
-            .filter(SysRoleMenu.role_id == role_id) \
-            .distinct().all()
+        role_menu_query_all = (await db.execute(
+            select(SysRoleMenu)
+                .where(SysRoleMenu.role_id == role_id)
+                .distinct()
+        )).scalars().all()
 
         return role_menu_query_all
 
     @classmethod
-    def add_role_menu_dao(cls, db: Session, role_menu: RoleMenuModel):
+    async def add_role_menu_dao(cls, db: AsyncSession, role_menu: RoleMenuModel):
         """
         新增角色菜单关联信息数据库操作
         :param db: orm对象
@@ -174,35 +188,37 @@ class RoleDao:
         db.add(db_role_menu)
 
     @classmethod
-    def delete_role_menu_dao(cls, db: Session, role_menu: RoleMenuModel):
+    async def delete_role_menu_dao(cls, db: AsyncSession, role_menu: RoleMenuModel):
         """
         删除角色菜单关联信息数据库操作
         :param db: orm对象
         :param role_menu: 角色菜单关联对象
         :return:
         """
-        db.query(SysRoleMenu) \
-            .filter(SysRoleMenu.role_id == role_menu.role_id) \
-            .delete()
+        await db.execute(
+            delete(SysRoleMenu)
+                .where(SysRoleMenu.role_id.in_([role_menu.role_id]))
+        )
 
     @classmethod
-    def get_role_dept_dao(cls, db: Session, role_id: int):
+    async def get_role_dept_dao(cls, db: AsyncSession, role_id: int):
         """
         根据角色id获取角色部门关联列表信息
         :param db: orm对象
         :param role_id: 角色id
         :return: 角色部门关联列表信息
         """
-        role_dept_query_all = db.query(SysRoleDept) \
-            .filter(SysRoleDept.role_id == role_id,
-                    ~db.query(SysDept).filter(func.find_in_set(SysRoleDept.dept_id, SysDept.ancestors)).exists()
-                    ) \
-            .distinct().all()
+        role_dept_query_all = (await db.execute(
+            select(SysRoleDept)
+                .where(SysRoleDept.role_id == role_id,
+                       ~select(SysDept).where(func.find_in_set(SysRoleDept.dept_id, SysDept.ancestors)).exists())
+                .distinct()
+        )).scalars().all()
 
         return role_dept_query_all
 
     @classmethod
-    def add_role_dept_dao(cls, db: Session, role_dept: RoleDeptModel):
+    async def add_role_dept_dao(cls, db: AsyncSession, role_dept: RoleDeptModel):
         """
         新增角色部门关联信息数据库操作
         :param db: orm对象
@@ -213,13 +229,14 @@ class RoleDao:
         db.add(db_role_dept)
 
     @classmethod
-    def delete_role_dept_dao(cls, db: Session, role_dept: RoleDeptModel):
+    async def delete_role_dept_dao(cls, db: AsyncSession, role_dept: RoleDeptModel):
         """
         删除角色部门关联信息数据库操作
         :param db: orm对象
         :param role_dept: 角色部门关联对象
         :return:
         """
-        db.query(SysRoleDept) \
-            .filter(SysRoleDept.role_id == role_dept.role_id) \
-            .delete()
+        await db.execute(
+            delete(SysRoleDept)
+                .where(SysRoleDept.role_id.in_([role_dept.role_id]))
+        )

ruoyi-fastapi-backend/module_admin/dao/user_dao.py

@@ -1,5 +1,5 @@
-from sqlalchemy import and_, or_, desc, func
-from sqlalchemy.orm import Session
+from sqlalchemy import select, update, delete, and_, or_, desc, func
+from sqlalchemy.ext.asyncio import AsyncSession
 from module_admin.entity.do.user_do import SysUser, SysUserRole, SysUserPost
 from module_admin.entity.do.role_do import SysRole, SysRoleDept, SysRoleMenu
 from module_admin.entity.do.dept_do import SysDept
@@ -16,73 +16,96 @@ class UserDao:
     """
 
     @classmethod
-    def get_user_by_name(cls, db: Session, user_name: str):
+    async def get_user_by_name(cls, db: AsyncSession, user_name: str):
         """
         根据用户名获取用户信息
         :param db: orm对象
         :param user_name: 用户名
         :return: 当前用户名的用户信息对象
         """
-        query_user_info = db.query(SysUser) \
-            .filter(SysUser.status == 0, SysUser.del_flag == 0, SysUser.user_name == user_name) \
-            .order_by(desc(SysUser.create_time)).distinct().first()
+        query_user_info = (await db.execute(
+            select(SysUser)
+                .where(SysUser.status == 0, SysUser.del_flag == 0, SysUser.user_name == user_name)
+                .order_by(desc(SysUser.create_time))
+                .distinct()
+        )).scalars().first()
 
         return query_user_info
 
     @classmethod
-    def get_user_by_info(cls, db: Session, user: UserModel):
+    async def get_user_by_info(cls, db: AsyncSession, user: UserModel):
         """
         根据用户参数获取用户信息
         :param db: orm对象
         :param user: 用户参数
         :return: 当前用户参数的用户信息对象
         """
-        query_user_info = db.query(SysUser) \
-            .filter(SysUser.del_flag == 0,
-                    SysUser.user_name == user.user_name) \
-            .order_by(desc(SysUser.create_time)).distinct().first()
+        query_user_info = (await db.execute(
+            select(SysUser)
+                .where(SysUser.del_flag == 0, SysUser.user_name == user.user_name)
+                .order_by(desc(SysUser.create_time))
+                .distinct()
+        )).scalars().first()
 
         return query_user_info
 
     @classmethod
-    def get_user_by_id(cls, db: Session, user_id: int):
+    async def get_user_by_id(cls, db: AsyncSession, user_id: int):
         """
         根据user_id获取用户信息
         :param db: orm对象
         :param user_id: 用户id
         :return: 当前user_id的用户信息对象
         """
-        query_user_basic_info = db.query(SysUser) \
-            .filter(SysUser.status == 0, SysUser.del_flag == 0, SysUser.user_id == user_id) \
-            .distinct().first()
-        query_user_dept_info = db.query(SysDept).select_from(SysUser) \
-            .filter(SysUser.status == 0, SysUser.del_flag == 0, SysUser.user_id == user_id) \
-            .join(SysDept, and_(SysUser.dept_id == SysDept.dept_id, SysDept.status == 0, SysDept.del_flag == 0)) \
-            .distinct().first()
-        query_user_role_info = db.query(SysRole).select_from(SysUser) \
-            .filter(SysUser.status == 0, SysUser.del_flag == 0, SysUser.user_id == user_id) \
-            .outerjoin(SysUserRole, SysUser.user_id == SysUserRole.user_id) \
-            .join(SysRole, and_(SysUserRole.role_id == SysRole.role_id, SysRole.status == 0, SysRole.del_flag == 0)) \
-            .distinct().all()
-        query_user_post_info = db.query(SysPost).select_from(SysUser) \
-            .filter(SysUser.status == 0, SysUser.del_flag == 0, SysUser.user_id == user_id) \
-            .outerjoin(SysUserPost, SysUser.user_id == SysUserPost.user_id) \
-            .join(SysPost, and_(SysUserPost.post_id == SysPost.post_id, SysPost.status == 0)) \
-            .distinct().all()
+        query_user_basic_info = (await db.execute(
+            select(SysUser)
+                .where(SysUser.status == 0, SysUser.del_flag == 0, SysUser.user_id == user_id)
+                .distinct()
+        )).scalars().first()
+        query_user_dept_info = (await db.execute(
+            select(SysDept)
+                .select_from(SysUser)
+                .where(SysUser.status == 0, SysUser.del_flag == 0, SysUser.user_id == user_id)
+                .join(SysDept, and_(SysUser.dept_id == SysDept.dept_id, SysDept.status == 0, SysDept.del_flag == 0))
+                .distinct()
+        )).scalars().first()
+        query_user_role_info = (await db.execute(
+            select(SysRole)
+                .select_from(SysUser)
+                .where(SysUser.status == 0, SysUser.del_flag == 0, SysUser.user_id == user_id)
+                .join(SysUserRole, SysUser.user_id == SysUserRole.user_id, isouter=True)
+                .join(SysRole, and_(SysUserRole.role_id == SysRole.role_id, SysRole.status == 0, SysRole.del_flag == 0))
+                .distinct()
+        )).scalars().all()
+        query_user_post_info = (await db.execute(
+            select(SysPost)
+                .select_from(SysUser)
+                .where(SysUser.status == 0, SysUser.del_flag == 0, SysUser.user_id == user_id)
+                .join(SysUserPost, SysUser.user_id == SysUserPost.user_id, isouter=True)
+                .join(SysPost, and_(SysUserPost.post_id == SysPost.post_id, SysPost.status == 0))
+                .distinct()
+        )).scalars().all()
         role_id_list = [item.role_id for item in query_user_role_info]
         if 1 in role_id_list:
-            query_user_menu_info = db.query(SysMenu) \
-                .filter(SysMenu.status == 0) \
-                .distinct().all()
+            query_user_menu_info = (await db.execute(
+                select(SysMenu)
+                    .where(SysMenu.status == 0)
+                    .distinct()
+            )).scalars().all()
         else:
-            query_user_menu_info = db.query(SysMenu).select_from(SysUser) \
-                .filter(SysUser.status == 0, SysUser.del_flag == 0, SysUser.user_id == user_id) \
-                .outerjoin(SysUserRole, SysUser.user_id == SysUserRole.user_id) \
-                .outerjoin(SysRole, and_(SysUserRole.role_id == SysRole.role_id, SysRole.status == 0, SysRole.del_flag == 0)) \
-                .outerjoin(SysRoleMenu, SysRole.role_id == SysRoleMenu.role_id) \
-                .join(SysMenu, and_(SysRoleMenu.menu_id == SysMenu.menu_id, SysMenu.status == 0)) \
-                .order_by(SysMenu.order_num) \
-                .distinct().all()
+            query_user_menu_info = (await db.execute(
+                select(SysMenu)
+                    .select_from(SysUser)
+                    .where(SysUser.status == 0, SysUser.del_flag == 0, SysUser.user_id == user_id)
+                    .join(SysUserRole, SysUser.user_id == SysUserRole.user_id, isouter=True)
+                    .join(SysRole,
+                          and_(SysUserRole.role_id == SysRole.role_id, SysRole.status == 0, SysRole.del_flag == 0),
+                          isouter=True)
+                    .join(SysRoleMenu, SysRole.role_id == SysRoleMenu.role_id, isouter=True)
+                    .join(SysMenu, and_(SysRoleMenu.menu_id == SysMenu.menu_id, SysMenu.status == 0))
+                    .order_by(SysMenu.order_num)
+                    .distinct()
+            )).scalars().all()
 
         results = dict(
             user_basic_info=query_user_basic_info,
@@ -95,37 +118,52 @@ class UserDao:
         return results
 
     @classmethod
-    def get_user_detail_by_id(cls, db: Session, user_id: int):
+    async def get_user_detail_by_id(cls, db: AsyncSession, user_id: int):
         """
         根据user_id获取用户详细信息
         :param db: orm对象
         :param user_id: 用户id
         :return: 当前user_id的用户信息对象
         """
-        query_user_basic_info = db.query(SysUser) \
-            .filter(SysUser.del_flag == 0, SysUser.user_id == user_id) \
-            .distinct().first()
-        query_user_dept_info = db.query(SysDept).select_from(SysUser) \
-            .filter(SysUser.del_flag == 0, SysUser.user_id == user_id) \
-            .join(SysDept, and_(SysUser.dept_id == SysDept.dept_id, SysDept.status == 0, SysDept.del_flag == 0)) \
-            .distinct().first()
-        query_user_role_info = db.query(SysRole).select_from(SysUser) \
-            .filter(SysUser.del_flag == 0, SysUser.user_id == user_id) \
-            .outerjoin(SysUserRole, SysUser.user_id == SysUserRole.user_id) \
-            .join(SysRole, and_(SysUserRole.role_id == SysRole.role_id, SysRole.status == 0, SysRole.del_flag == 0)) \
-            .distinct().all()
-        query_user_post_info = db.query(SysPost).select_from(SysUser) \
-            .filter(SysUser.del_flag == 0, SysUser.user_id == user_id) \
-            .outerjoin(SysUserPost, SysUser.user_id == SysUserPost.user_id) \
-            .join(SysPost, and_(SysUserPost.post_id == SysPost.post_id, SysPost.status == 0)) \
-            .distinct().all()
-        query_user_menu_info = db.query(SysMenu).select_from(SysUser) \
-            .filter(SysUser.del_flag == 0, SysUser.user_id == user_id) \
-            .outerjoin(SysUserRole, SysUser.user_id == SysUserRole.user_id) \
-            .outerjoin(SysRole, and_(SysUserRole.role_id == SysRole.role_id, SysRole.status == 0, SysRole.del_flag == 0)) \
-            .outerjoin(SysRoleMenu, SysRole.role_id == SysRoleMenu.role_id) \
-            .join(SysMenu, and_(SysRoleMenu.menu_id == SysMenu.menu_id, SysMenu.status == 0)) \
-            .distinct().all()
+        query_user_basic_info = (await db.execute(
+            select(SysUser)
+                .where(SysUser.del_flag == 0, SysUser.user_id == user_id)
+                .distinct()
+        )).scalars().first()
+        query_user_dept_info = (await db.execute(
+            select(SysDept)
+                .select_from(SysUser)
+                .where(SysUser.del_flag == 0, SysUser.user_id == user_id)
+                .join(SysDept, and_(SysUser.dept_id == SysDept.dept_id, SysDept.status == 0, SysDept.del_flag == 0))
+                .distinct()
+        )).scalars().first()
+        query_user_role_info = (await db.execute(
+            select(SysRole)
+                .select_from(SysUser)
+                .where(SysUser.del_flag == 0, SysUser.user_id == user_id)
+                .join(SysUserRole, SysUser.user_id == SysUserRole.user_id, isouter=True)
+                .join(SysRole, and_(SysUserRole.role_id == SysRole.role_id, SysRole.status == 0, SysRole.del_flag == 0))
+                .distinct()
+        )).scalars().all()
+        query_user_post_info = (await db.execute(
+            select(SysPost)
+                .select_from(SysUser)
+                .where(SysUser.del_flag == 0, SysUser.user_id == user_id)
+                .join(SysUserPost, SysUser.user_id == SysUserPost.user_id, isouter=True)
+                .join(SysPost, and_(SysUserPost.post_id == SysPost.post_id, SysPost.status == 0))
+                .distinct()
+        )).scalars().all()
+        query_user_menu_info = (await db.execute(
+            select(SysMenu)
+                .select_from(SysUser)
+                .where(SysUser.del_flag == 0, SysUser.user_id == user_id)
+                .join(SysUserRole, SysUser.user_id == SysUserRole.user_id, isouter=True)
+                .join(SysRole, and_(SysUserRole.role_id == SysRole.role_id, SysRole.status == 0, SysRole.del_flag == 0),
+                      isouter=True)
+                .join(SysRoleMenu, SysRole.role_id == SysRoleMenu.role_id, isouter=True)
+                .join(SysMenu, and_(SysRoleMenu.menu_id == SysMenu.menu_id, SysMenu.status == 0))
+                .distinct()
+        )).scalars().all()
         results = dict(
             user_basic_info=query_user_basic_info,
             user_dept_info=query_user_dept_info,
@@ -137,7 +175,8 @@ class UserDao:
         return results
 
     @classmethod
-    def get_user_list(cls, db: Session, query_object: UserPageQueryModel, data_scope_sql: str, is_page: bool = False):
+    async def get_user_list(cls, db: AsyncSession, query_object: UserPageQueryModel, data_scope_sql: str,
+                            is_page: bool = False):
         """
         根据查询参数获取用户列表信息
         :param db: orm对象
@@ -146,31 +185,32 @@ class UserDao:
         :param is_page: 是否开启分页
         :return: 用户列表信息对象
         """
-        query = db.query(SysUser, SysDept) \
-            .filter(SysUser.del_flag == 0,
-                    or_(SysUser.dept_id == query_object.dept_id, SysUser.dept_id.in_(
-                        db.query(SysDept.dept_id).filter(func.find_in_set(query_object.dept_id, SysDept.ancestors))
-                    )) if query_object.dept_id else True,
-                    SysUser.user_name.like(f'%{query_object.user_name}%') if query_object.user_name else True,
-                    SysUser.nick_name.like(f'%{query_object.nick_name}%') if query_object.nick_name else True,
-                    SysUser.email.like(f'%{query_object.email}%') if query_object.email else True,
-                    SysUser.phonenumber.like(f'%{query_object.phonenumber}%') if query_object.phonenumber else True,
-                    SysUser.status == query_object.status if query_object.status else True,
-                    SysUser.sex == query_object.sex if query_object.sex else True,
-                    SysUser.create_time.between(
-                        datetime.combine(datetime.strptime(query_object.begin_time, '%Y-%m-%d'), time(00, 00, 00)),
-                        datetime.combine(datetime.strptime(query_object.end_time, '%Y-%m-%d'), time(23, 59, 59)))
-                    if query_object.begin_time and query_object.end_time else True,
-                    eval(data_scope_sql)
-                    ) \
-            .outerjoin(SysDept, and_(SysUser.dept_id == SysDept.dept_id, SysDept.status == 0, SysDept.del_flag == 0)) \
+        query = select(SysUser, SysDept) \
+            .where(SysUser.del_flag == 0,
+                   or_(SysUser.dept_id == query_object.dept_id, SysUser.dept_id.in_(
+                       select(SysDept.dept_id).where(func.find_in_set(query_object.dept_id, SysDept.ancestors))
+                   )) if query_object.dept_id else True,
+                   SysUser.user_name.like(f'%{query_object.user_name}%') if query_object.user_name else True,
+                   SysUser.nick_name.like(f'%{query_object.nick_name}%') if query_object.nick_name else True,
+                   SysUser.email.like(f'%{query_object.email}%') if query_object.email else True,
+                   SysUser.phonenumber.like(f'%{query_object.phonenumber}%') if query_object.phonenumber else True,
+                   SysUser.status == query_object.status if query_object.status else True,
+                   SysUser.sex == query_object.sex if query_object.sex else True,
+                   SysUser.create_time.between(
+                       datetime.combine(datetime.strptime(query_object.begin_time, '%Y-%m-%d'), time(00, 00, 00)),
+                       datetime.combine(datetime.strptime(query_object.end_time, '%Y-%m-%d'), time(23, 59, 59)))
+                   if query_object.begin_time and query_object.end_time else True,
+                   eval(data_scope_sql)
+                   ) \
+            .join(SysDept, and_(SysUser.dept_id == SysDept.dept_id, SysDept.status == 0, SysDept.del_flag == 0),
+                  isouter=True) \
             .distinct()
-        user_list = PageUtil.paginate(query, query_object.page_num, query_object.page_size, is_page)
+        user_list = await PageUtil.paginate(db, query, query_object.page_num, query_object.page_size, is_page)
 
         return user_list
 
     @classmethod
-    def add_user_dao(cls, db: Session, user: UserModel):
+    async def add_user_dao(cls, db: AsyncSession, user: UserModel):
         """
         新增用户数据库操作
         :param db: orm对象
@@ -179,57 +219,62 @@ class UserDao:
         """
         db_user = SysUser(**user.model_dump(exclude={'admin'}))
         db.add(db_user)
-        db.flush()
+        await db.flush()
 
         return db_user
 
     @classmethod
-    def edit_user_dao(cls, db: Session, user: dict):
+    async def edit_user_dao(cls, db: AsyncSession, user: dict):
         """
         编辑用户数据库操作
         :param db: orm对象
         :param user: 需要更新的用户字典
         :return: 编辑校验结果
         """
-        db.query(SysUser) \
-            .filter(SysUser.user_id == user.get('user_id')) \
-            .update(user)
+        await db.execute(
+            update(SysUser),
+            [user]
+        )
 
     @classmethod
-    def delete_user_dao(cls, db: Session, user: UserModel):
+    async def delete_user_dao(cls, db: AsyncSession, user: UserModel):
         """
         删除用户数据库操作
         :param db: orm对象
         :param user: 用户对象
         :return:
         """
-        db.query(SysUser) \
-            .filter(SysUser.user_id == user.user_id) \
-            .update({SysUser.del_flag: '2', SysUser.update_by: user.update_by, SysUser.update_time: user.update_time})
+        await db.execute(
+            update(SysUser)
+                .where(SysUser.user_id == user.user_id)
+                .values(del_flag='2', update_by=user.update_by, update_time=user.update_time)
+        )
 
     @classmethod
-    def get_user_role_allocated_list_by_user_id(cls, db: Session, query_object: UserRoleQueryModel):
+    async def get_user_role_allocated_list_by_user_id(cls, db: AsyncSession, query_object: UserRoleQueryModel):
         """
         根据用户id获取用户已分配的角色列表信息数据库操作
         :param db: orm对象
         :param query_object: 用户角色查询对象
         :return: 用户已分配的角色列表信息
         """
-        allocated_role_list = db.query(SysRole) \
-            .filter(
-            SysRole.del_flag == 0,
-            SysRole.role_id != 1,
-            SysRole.role_name == query_object.role_name if query_object.role_name else True,
-            SysRole.role_key == query_object.role_key if query_object.role_key else True,
-            SysRole.role_id.in_(
-                db.query(SysUserRole.role_id).filter(SysUserRole.user_id == query_object.user_id)
-            )
-        ).distinct().all()
+        allocated_role_list = (await db.execute(
+            select(SysRole)
+                .where(SysRole.del_flag == 0,
+                       SysRole.role_id != 1,
+                       SysRole.role_name == query_object.role_name if query_object.role_name else True,
+                       SysRole.role_key == query_object.role_key if query_object.role_key else True,
+                       SysRole.role_id.in_(
+                           select(SysUserRole.role_id).where(SysUserRole.user_id == query_object.user_id)
+                       ))
+                .distinct()
+        )).scalars().all()
 
         return allocated_role_list
 
     @classmethod
-    def get_user_role_allocated_list_by_role_id(cls, db: Session, query_object: UserRolePageQueryModel, is_page: bool = False):
+    async def get_user_role_allocated_list_by_role_id(cls, db: AsyncSession, query_object: UserRolePageQueryModel,
+                                                      is_page: bool = False):
         """
         根据角色id获取已分配的用户列表信息
         :param db: orm对象
@@ -237,22 +282,22 @@ class UserDao:
         :param is_page: 是否开启分页
         :return: 角色已分配的用户列表信息
         """
-        query = db.query(SysUser) \
-            .filter(
-            SysUser.del_flag == 0,
-            SysUser.user_id != 1,
-            SysUser.user_name == query_object.user_name if query_object.user_name else True,
-            SysUser.phonenumber == query_object.phonenumber if query_object.phonenumber else True,
-            SysUser.user_id.in_(
-                db.query(SysUserRole.user_id).filter(SysUserRole.role_id == query_object.role_id)
-            )
-        ).distinct()
-        allocated_user_list = PageUtil.paginate(query, query_object.page_num, query_object.page_size, is_page)
+        query = select(SysUser) \
+            .where(SysUser.del_flag == 0,
+                   SysUser.user_id != 1,
+                   SysUser.user_name == query_object.user_name if query_object.user_name else True,
+                   SysUser.phonenumber == query_object.phonenumber if query_object.phonenumber else True,
+                   SysUser.user_id.in_(
+                       select(SysUserRole.user_id).where(SysUserRole.role_id == query_object.role_id)
+                   )) \
+            .distinct()
+        allocated_user_list = await PageUtil.paginate(db, query, query_object.page_num, query_object.page_size, is_page)
 
         return allocated_user_list
 
     @classmethod
-    def get_user_role_unallocated_list_by_role_id(cls, db: Session, query_object: UserRolePageQueryModel, is_page: bool = False):
+    async def get_user_role_unallocated_list_by_role_id(cls, db: AsyncSession, query_object: UserRolePageQueryModel,
+                                                        is_page: bool = False):
         """
         根据角色id获取未分配的用户列表信息
         :param db: orm对象
@@ -260,22 +305,22 @@ class UserDao:
         :param is_page: 是否开启分页
         :return: 角色未分配的用户列表信息
         """
-        query = db.query(SysUser) \
-            .filter(
-            SysUser.del_flag == 0,
-            SysUser.user_id != 1,
-            SysUser.user_name == query_object.user_name if query_object.user_name else True,
-            SysUser.phonenumber == query_object.phonenumber if query_object.phonenumber else True,
-            ~SysUser.user_id.in_(
-                db.query(SysUserRole.user_id).filter(SysUserRole.role_id == query_object.role_id)
-            )
-        ).distinct()
-        unallocated_user_list = PageUtil.paginate(query, query_object.page_num, query_object.page_size, is_page)
+        query = select(SysUser) \
+            .where(SysUser.del_flag == 0,
+                   SysUser.user_id != 1,
+                   SysUser.user_name == query_object.user_name if query_object.user_name else True,
+                   SysUser.phonenumber == query_object.phonenumber if query_object.phonenumber else True,
+                   ~SysUser.user_id.in_(
+                       select(SysUserRole.user_id).where(SysUserRole.role_id == query_object.role_id)
+                   )) \
+            .distinct()
+        unallocated_user_list = await PageUtil.paginate(db, query, query_object.page_num, query_object.page_size,
+                                                        is_page)
 
         return unallocated_user_list
 
     @classmethod
-    def add_user_role_dao(cls, db: Session, user_role: UserRoleModel):
+    async def add_user_role_dao(cls, db: AsyncSession, user_role: UserRoleModel):
         """
         新增用户角色关联信息数据库操作
         :param db: orm对象
@@ -286,46 +331,50 @@ class UserDao:
         db.add(db_user_role)
 
     @classmethod
-    def delete_user_role_dao(cls, db: Session, user_role: UserRoleModel):
+    async def delete_user_role_dao(cls, db: AsyncSession, user_role: UserRoleModel):
         """
         删除用户角色关联信息数据库操作
         :param db: orm对象
         :param user_role: 用户角色关联对象
         :return:
         """
-        db.query(SysUserRole) \
-            .filter(SysUserRole.user_id == user_role.user_id) \
-            .delete()
+        await db.execute(
+            delete(SysUserRole)
+                .where(SysUserRole.user_id.in_([user_role.user_id]))
+        )
 
     @classmethod
-    def delete_user_role_by_user_and_role_dao(cls, db: Session, user_role: UserRoleModel):
+    async def delete_user_role_by_user_and_role_dao(cls, db: AsyncSession, user_role: UserRoleModel):
         """
         根据用户id及角色id删除用户角色关联信息数据库操作
         :param db: orm对象
         :param user_role: 用户角色关联对象
         :return:
         """
-        db.query(SysUserRole) \
-            .filter(SysUserRole.user_id == user_role.user_id,
-                    SysUserRole.role_id == user_role.role_id if user_role.role_id else True) \
-            .delete()
+        await db.execute(
+            delete(SysUserRole)
+                .where(SysUserRole.user_id.in_([user_role.user_id]),
+                       SysUserRole.role_id == user_role.role_id if user_role.role_id else True)
+        )
 
     @classmethod
-    def get_user_role_detail(cls, db: Session, user_role: UserRoleModel):
+    async def get_user_role_detail(cls, db: AsyncSession, user_role: UserRoleModel):
         """
         根据用户角色关联获取用户角色关联详细信息
         :param db: orm对象
         :param user_role: 用户角色关联对象
         :return: 用户角色关联信息
         """
-        user_role_info = db.query(SysUserRole) \
-            .filter(SysUserRole.user_id == user_role.user_id, SysUserRole.role_id == user_role.role_id) \
-            .distinct().first()
+        user_role_info = (await db.execute(
+            select(SysUserRole)
+                .where(SysUserRole.user_id == user_role.user_id, SysUserRole.role_id == user_role.role_id)
+                .distinct()
+        )).scalars().first()
 
         return user_role_info
 
     @classmethod
-    def add_user_post_dao(cls, db: Session, user_post: UserPostModel):
+    async def add_user_post_dao(cls, db: AsyncSession, user_post: UserPostModel):
         """
         新增用户岗位关联信息数据库操作
         :param db: orm对象
@@ -336,22 +385,24 @@ class UserDao:
         db.add(db_user_post)
 
     @classmethod
-    def delete_user_post_dao(cls, db: Session, user_post: UserPostModel):
+    async def delete_user_post_dao(cls, db: AsyncSession, user_post: UserPostModel):
         """
         删除用户岗位关联信息数据库操作
         :param db: orm对象
         :param user_post: 用户岗位关联对象
         :return:
         """
-        db.query(SysUserPost) \
-            .filter(SysUserPost.user_id == user_post.user_id) \
-            .delete()
+        await db.execute(
+            delete(SysUserPost)
+                .where(SysUserPost.user_id.in_([user_post.user_id]))
+        )
 
     @classmethod
-    def get_user_dept_info(cls, db: Session, dept_id: int):
-        dept_basic_info = db.query(SysDept) \
-            .filter(SysDept.dept_id == dept_id,
-                    SysDept.status == 0,
-                    SysDept.del_flag == 0) \
-            .first()
+    async def get_user_dept_info(cls, db: AsyncSession, dept_id: int):
+        dept_basic_info = (await db.execute(
+            select(SysDept)
+                .where(SysDept.dept_id == dept_id,
+                       SysDept.status == 0,
+                       SysDept.del_flag == 0)
+        )).scalars().first()
         return dept_basic_info