fastapi数据库操作，添加数据，修改数据，删除数据，创建

from fastapi import  FastAPI,Depends,HTTPException,Path
from pydantic import BaseModel
import uvicorn
app = FastAPI()

from sqlalchemy import create_engine ,select,asc,Integer,String,update,delete
from sqlalchemy.orm import DeclarativeBase,sessionmaker,Mapped,mapped_column

engine = create_engine('mysql+pymysql://root:kobe123456@localhost/computer',echo=True)



# 修改数据的函数

def  set_attr(obj,data:dict):

      if data:
            for key ,value in data.items():

                 # 用这个函数修改数据
                 setattr(obj,key,value)


class  Base(DeclarativeBase):
     pass

class  StudentEntity(Base):
       __tablename__ = "students"
       id:Mapped[int] = mapped_column(Integer,primary_key=True)
       name:Mapped[str] = mapped_column(String(128),unique=True,nullable=False)
       gender:Mapped[str] = mapped_column(String(10),nullable=False)



Base.metadata.create_all(engine)
Session = sessionmaker(bind=engine)


class  StudentBase(BaseModel):
      name:str
      gender:str


class  StudentUpdate(StudentBase):
     ...

class CreateStudent(StudentBase):
     ...

class StudentOut(StudentBase):
     id:int


def  get_db_session():

     db_session = Session()
     try:

          yield db_session
     finally:

          db_session.close()


@app.get('/students',response_model=list[StudentOut])
async def get_students(db_students:Session = Depends(get_db_session)):
    query = select(StudentEntity).order_by(asc(StudentEntity.name))
    return  db_students.execute(query).scalars().all()


# 添加数据
@app.post('/create/student',response_model=StudentOut)
async  def  create_students(student:CreateStudent,create_student:Session = Depends(get_db_session)):

            # 判断
            query = select(StudentEntity).where(StudentEntity.name == student.name)
            records = create_student.execute(query).scalars().all()
            if records:
                  raise HTTPException(status_code=400,detail=f"{student.name} is  already  exists")

            # 如果records不存在,就执行
            student_entity = StudentEntity(name=student.name,gender=student.gender)
            create_student.add(student_entity)
            create_student.commit()
            return student_entity


# 检查学生使用的函数
def  check_student_exists(student_id:int,db_session:Session):
    query = select(StudentEntity).where(StudentEntity.id == student_id)
    exists_student = db_session.execute(query).scalar()

    # 判断是否存在
    if not exists_student:
        raise HTTPException(status_code=404, detail=f"id为:{student_id} ==>not  found...")

    return exists_student



# 修改数据
@app.put('/update/student/{studentId}',response_model=StudentOut)
async  def update_students(*,studentId:int=Path(...),student:StudentUpdate,update_student:Session = Depends(get_db_session)):



       # query = select(StudentEntity).where(StudentEntity.id == studentId)
       # exist_student= update_student.execute(query).scalar()
       # if not exist_student:
       #       raise HTTPException(status_code=401,detail=f'{studentId} not  exists')

       # 代替上面的三行
       exist_student = check_student_exists(studentId,update_student)
       # 修改数据的第一种方法
       # exist_student.name = student.name
       # exist_student.gender = student.gender

       # 第二种方法 但是有缺点
       # update_query  = update(StudentEntity).values(student.model_dump()).where(StudentEntity.id == studentId)
       # update_student.execute(update_query)
       # update_student.commit()


       # 第三种方法最简单，最实用
       set_attr(exist_student,student.model_dump())

       update_student.commit()
       return exist_student








# 删除记录的函数
@app.delete('/remove/sudent/{student_id}',response_model=StudentOut)
async  def  delete_student(student_id:int=Path(...),db_session:Session = Depends(get_db_session)):

        exists_student = check_student_exists(student_id,db_session)

        db_session.delete(exists_student)
        db_session.commit()
        return exists_student








if __name__ == '__main__':

    uvicorn.run('main:app',port=9999,reload=True)