234 lines
9.7 KiB
Python
234 lines
9.7 KiB
Python
#!/usr/bin/python
|
||
# -*- coding: utf-8 -*-
|
||
# @version : 1.0
|
||
# @Creaet Time : 2021/10/18 22:18
|
||
# @File : crud.py
|
||
# @IDE : PyCharm
|
||
# @desc : 数据库 增删改查操作
|
||
|
||
# sqlalchemy 查询操作：https://segmentfault.com/a/1190000016767008
|
||
# sqlalchemy 增删改操作：https://www.osgeo.cn/sqlalchemy/tutorial/orm_data_manipulation.html#updating-orm-objects
|
||
# SQLAlchemy lazy load和eager load: https://www.jianshu.com/p/dfad7c08c57a
|
||
# Mysql中内连接,左连接和右连接的区别总结:https://www.cnblogs.com/restartyang/articles/9080993.html
|
||
# SQLAlchemy join 内连接
|
||
# selectinload 官方文档：
|
||
# https://www.osgeo.cn/sqlalchemy/orm/loading_relationships.html?highlight=selectinload#sqlalchemy.orm.selectinload
|
||
import datetime
|
||
from typing import List, Union
|
||
from fastapi import HTTPException
|
||
from fastapi.encoders import jsonable_encoder
|
||
from sqlalchemy import func, delete, update, or_
|
||
from sqlalchemy.future import select
|
||
from sqlalchemy.ext.asyncio import AsyncSession
|
||
from sqlalchemy.orm import selectinload
|
||
from starlette import status
|
||
from core.logger import logger
|
||
from sqlalchemy.sql.selectable import Select
|
||
from pydantic import BaseModel
|
||
|
||
|
||
class DalBase:
|
||
|
||
def __init__(self, db: AsyncSession, model, schema, key_models: dict = None):
|
||
self.db = db
|
||
self.model = model
|
||
self.schema = schema
|
||
self.key_models = key_models
|
||
|
||
async def get_data(self, data_id: int = None, options: list = None, schema=None, keys: dict = None, **kwargs):
|
||
"""
|
||
获取单个数据，默认使用 ID 查询，否则使用关键词查询
|
||
|
||
@param data_id:
|
||
@param keys: 外键字段查询，内连接
|
||
@param options: 指示应使用select在预加载中加载给定的属性。
|
||
@param schema: 指定使用的序列化对象
|
||
@param kwargs: 关键词参数,
|
||
@param kwargs: order，排序，默认正序，为 desc 是倒叙
|
||
@param kwargs: return_none，是否返回空 None，否认 抛出异常，默认抛出异常
|
||
"""
|
||
order = kwargs.get("order", None)
|
||
return_none = kwargs.get("return_none", False)
|
||
keys_exist = False
|
||
if keys:
|
||
for key, value in keys.items():
|
||
if value and isinstance(value, dict):
|
||
for k, v in value.items():
|
||
if v:
|
||
keys_exist = True
|
||
break
|
||
kwargs_exist = False
|
||
if kwargs:
|
||
for key, value in kwargs.items():
|
||
if key != "order" and key != "return_none" and value and getattr(self.model, key, None):
|
||
kwargs_exist = True
|
||
break
|
||
sql = select(self.model).where(self.model.delete_datetime.is_(None))
|
||
if data_id or kwargs_exist or keys_exist:
|
||
if data_id:
|
||
sql = sql.where(self.model.id == data_id)
|
||
sql = self.add_filter_condition(sql, keys, options, **kwargs)
|
||
if order and order == "desc":
|
||
sql = sql.order_by(self.model.create_datetime.desc())
|
||
queryset = await self.db.execute(sql)
|
||
data = queryset.scalars().first()
|
||
if not data and return_none:
|
||
return None
|
||
if data and schema:
|
||
return schema.from_orm(data).dict()
|
||
if data:
|
||
return data
|
||
raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="未找到此数据")
|
||
|
||
async def get_datas(self, page: int = 1, limit: int = 10, keys: dict = None, options: list = None, schema=None,
|
||
**kwargs):
|
||
"""
|
||
获取数据列表
|
||
|
||
@param page: 页码
|
||
@param limit: 当前页数据量
|
||
@param keys: 外键字段查询
|
||
@param options: 指示应使用select在预加载中加载给定的属性。
|
||
@param schema: 指定使用的序列化对象
|
||
@param kwargs: order，排序，默认正序，为 desc 是倒叙
|
||
@param kwargs: order_field，排序字段
|
||
@param kwargs: return_objs，是否返回对象
|
||
@param kwargs: start_sql，初始 sql
|
||
"""
|
||
order = kwargs.get("order", None)
|
||
order_field = kwargs.get("order_field", None)
|
||
return_objs = kwargs.get("return_objs", False)
|
||
start_sql = kwargs.get("start_sql", None)
|
||
if not isinstance(start_sql, Select):
|
||
start_sql = select(self.model).where(self.model.delete_datetime.is_(None))
|
||
sql = self.add_filter_condition(start_sql, keys, options, **kwargs)
|
||
if order_field and order == "desc":
|
||
sql = sql.order_by(getattr(self.model, order_field).desc(), self.model.id.desc())
|
||
elif order_field:
|
||
sql = sql.order_by(getattr(self.model, order_field), self.model.id)
|
||
elif order == "desc":
|
||
sql = sql.order_by(self.model.id.desc())
|
||
if limit != 0:
|
||
sql = sql.offset((page - 1) * limit).limit(limit)
|
||
queryset = await self.db.execute(sql)
|
||
if return_objs:
|
||
return queryset.scalars().all()
|
||
if schema:
|
||
return [schema.from_orm(i).dict() for i in queryset.scalars().all()]
|
||
return [self.out_dict(i) for i in queryset.scalars().all()]
|
||
|
||
async def get_count(self, keys: dict = None, **kwargs):
|
||
"""获取数据总数"""
|
||
sql = select(func.count(self.model.id).label('total')).where(self.model.delete_datetime.is_(None))
|
||
sql = self.add_filter_condition(sql, keys, **kwargs)
|
||
queryset = await self.db.execute(sql)
|
||
return queryset.one()['total']
|
||
|
||
async def create_data(self, data, return_obj: bool = False, options: list = None, schema=None):
|
||
"""创建数据"""
|
||
if isinstance(data, dict):
|
||
obj = self.model(**data)
|
||
else:
|
||
obj = self.model(**data.dict())
|
||
self.db.add(obj)
|
||
await self.db.flush()
|
||
await self.db.refresh(obj)
|
||
if options:
|
||
obj = await self.get_data(obj.id, options=options)
|
||
if return_obj:
|
||
return obj
|
||
if schema:
|
||
return schema.from_orm(obj).dict()
|
||
return self.out_dict(obj)
|
||
|
||
async def put_data(self, data_id: int, data, return_obj: bool = False, options: list = None, schema=None):
|
||
"""
|
||
更新单个数据
|
||
"""
|
||
obj = await self.get_data(data_id, options=options)
|
||
obj_dict = jsonable_encoder(data)
|
||
for key, value in obj_dict.items():
|
||
setattr(obj, key, value)
|
||
await self.db.flush()
|
||
await self.db.refresh(obj)
|
||
if return_obj:
|
||
return obj
|
||
if schema:
|
||
return schema.from_orm(obj).dict()
|
||
return self.out_dict(obj)
|
||
|
||
async def delete_datas(self, ids: List[int], soft: bool = False):
|
||
"""
|
||
删除多条数据
|
||
@param ids: 数据集
|
||
@param soft: 是否执行软删除
|
||
"""
|
||
if soft:
|
||
await self.db.execute(update(self.model).where(self.model.id.in_(ids)).
|
||
values(delete_datetime=datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")))
|
||
else:
|
||
await self.db.execute(delete(self.model).where(self.model.id.in_(ids)))
|
||
|
||
def add_filter_condition(self, sql: select, keys: dict = None, options: list = None, **kwargs) -> select:
|
||
"""
|
||
添加过滤条件，以及内连接过滤条件
|
||
@param sql:
|
||
@param keys: 外键字段查询，内连接
|
||
@param options: 指示应使用select在预加载中加载给定的属性。
|
||
@param kwargs: 关键词参数
|
||
"""
|
||
if keys and self.key_models:
|
||
for key, value in keys.items():
|
||
model = self.key_models.get(key)
|
||
if model:
|
||
sql = sql.join(model)
|
||
for v_key, v_value in value.items():
|
||
if v_value is not None and v_value != "":
|
||
v_attr = getattr(model, v_key, None)
|
||
sql = self.filter_condition(sql, v_attr, v_value)
|
||
else:
|
||
logger.error(f"外键查询报错：{key}模型不存在，无法进行下一步查询。")
|
||
elif keys and not self.key_models:
|
||
logger.error(f"外键查询报错：key_models 外键模型无配置项，无法进行下一步查询。")
|
||
for field in kwargs:
|
||
value = kwargs.get(field)
|
||
if value is not None and value != "":
|
||
attr = getattr(self.model, field, None)
|
||
sql = self.filter_condition(sql, attr, value)
|
||
if options:
|
||
sql = sql.options(*[selectinload(i) for i in options])
|
||
return sql
|
||
|
||
@classmethod
|
||
def filter_condition(cls, sql, attr, value):
|
||
"""
|
||
过滤条件
|
||
"""
|
||
if not attr:
|
||
return sql
|
||
if isinstance(value, tuple):
|
||
if value[0] == "date" and value[1]:
|
||
# 根据日期查询， 关键函数是：func.time_format和func.date_format
|
||
sql = sql.where(func.date_format(attr, "%Y-%m-%d") == value[1])
|
||
elif value[0] == "like" and value[1]:
|
||
sql = sql.where(attr.like(f"%{value[1]}%"))
|
||
elif value[0] == "or" and value[1]:
|
||
sql = sql.where(or_(i for i in value[1]))
|
||
elif value[0] == "in" and value[1]:
|
||
sql = sql.where(attr.in_(value[1]))
|
||
elif value[0] == "between" and value[1]:
|
||
sql = sql.where(attr.between(value[1][0], value[1][1]))
|
||
elif value[0] == "month" and value[1]:
|
||
sql = sql.where(func.date_format(attr, "%Y-%m") == value[1])
|
||
else:
|
||
sql = sql.where(attr == value)
|
||
return sql
|
||
|
||
def out_dict(self, data):
|
||
"""
|
||
序列化
|
||
@param data:
|
||
@return:
|
||
"""
|
||
return self.schema.from_orm(data).dict()
|