sqlalchemy 使用

合集 - flask从入门到进阶(6)

1.flask的简单使用2024-06-272.flask进阶使用2024-06-273.数据库和Flask项目搭建2024-06-274.flask定制Excel命令2024-06-27

5.sqlalchemy 使用2024-06-27

6.flask的进阶使用22024-06-27

收起

1 orm框架介绍

# 1 sqlalchemy 企业级orm框架
# 2 python界的orm框架
	-1 django-orm     #只能django框架用
    -2 peewee          # 小型orm框架：https://docs.peewee-orm.com/en/latest/peewee/quickstart.html
    -----同步orm框架-----
    -3 sqlalchemy     # 企业级，使用非常广泛：https://docs.sqlalchemy.org/en/20/orm/quickstart.html  # 可以用在flask上，还可以用在fastapi
    ---中间态----
    -4 Tortoise ORM  # fastapi用的比较多 
# 3 django ，flask---》同步框架--》新版本支持异步
# 4 fastapi，sanic，tornado---》异步框架--》支持同步的写法--》如果在异步框架上写同步
	-众多第三方库---》都是同步的--》导致异步框架性能发挥不出来
    -redis：aioredis  --》redis-py
    -mysql：aiomysql  --》pymysql 
# 5 异步框架上用同步第三方模块，不能发挥最佳性能？

1.1 快速使用

#  1 安装 pip3 insatll sqlalchemy   
	- 2.0.30版本
# 2 架构
    Engine，框架的引擎
    Connection Pooling ，数据库连接池
    Dialect，选择连接数据库的DB API种类 
    SQL Exprression Language，SQL表达式语言
    
# 3 链接不同数据库
## 3.1 postgresql
# default
engine = create_engine("postgresql://scott:tiger@localhost/mydatabase")
# psycopg2
engine = create_engine("postgresql+psycopg2://scott:tiger@localhost/mydatabase")
# pg8000
engine = create_engine("postgresql+pg8000://scott:tiger@localhost/mydatabase")
## 3.2 Mysql
# default
engine = create_engine("mysql://scott:tiger@localhost/foo")
# mysqlclient (a maintained fork of MySQL-Python)
engine = create_engine("mysql+mysqldb://scott:tiger@localhost/foo")
# PyMySQL
engine = create_engine("mysql+pymysql://scott:tiger@localhost/foo")

## 3.3 oracle
engine = create_engine("oracle://scott:tiger@127.0.0.1:1521/sidname")
engine = create_engine("oracle+cx_oracle://scott:tiger@tnsname")

## 3.4 Microsoft SQL Server
# pyodbc
engine = create_engine("mssql+pyodbc://scott:tiger@mydsn")
# pymssql
engine = create_engine("mssql+pymssql://scott:tiger@hostname:port/dbname")

## 3.5 sqlite
# Unix/Mac - 4 initial slashes in total
engine = create_engine("sqlite:////absolute/path/to/foo.db")
# Windows
engine = create_engine("sqlite:///C:\\path\\to\\foo.db")
# Windows alternative using raw string
engine = create_engine(r"sqlite:///C:\path\to\foo.db")

2 sqlalchemy 原生操作

#  1 创建 engin
from sqlalchemy import create_engine
engine = create_engine(
    "mysql+pymysql://root:123456@127.0.0.1:3307/flask_base?charset=utf8",
    max_overflow=0,  # 超过连接池大小外最多创建的连接
    pool_size=5,  # 连接池大小
    pool_timeout=30,  # 池中没有线程最多等待的时间，否则报错
    pool_recycle=-1  # 多久之后对线程池中的线程进行一次连接的回收（重置）
)

#2 原生操作mysql---》用了连接池---》就可以不用dbutils模块了
def task():
    conn = engine.raw_connection()
    cursor = conn.cursor()
    cursor.execute(
        "select * from article"
    )
    result = cursor.fetchall()
    print(result)
    cursor.close()
    conn.close()
#开启线程
for i in range(20):
    t = threading.Thread(target=task)
    t.start()

3 sqlalchemy操作表

3.1原生表的 创建和删除表

from sqlalchemy import Column, Integer, String, Text, ForeignKey, DateTime, UniqueConstraint, Index
import datetime
###### 第一步：创建基类，以后所有类，都必须继承基类

#### 1 老版本创建基类(不建议)
# from sqlalchemy.ext.declarative import declarative_base
# Base = declarative_base()

#### 2 新版本创建基类
from sqlalchemy.orm import DeclarativeBase
class Base(DeclarativeBase):
    pass


### 第二步：写个类，继承
### 第三步：写字段：传统方式，类型方式
class User(Base):
    __tablename__='user'
    id=Column(Integer,primary_key=True,autoincrement=True)
    name = Column(String(32), index=True, nullable=False)  # name列varchar32，索引，不可为空
    email = Column(String(32), unique=True)  # email 列，varchar32，唯一
    # datetime.datetime.now不能加括号，加了括号，以后永远是当前时间
    ctime = Column(DateTime, default=datetime.datetime.now)
    extra = Column(Text, nullable=True)


if __name__ == '__main__':
    from sqlalchemy import create_engine

    engine = create_engine(
        "mysql+pymysql://root:123456@127.0.0.1:3307/sqlalchemy001?charset=utf8",
        max_overflow=0,  # 超过连接池大小外最多创建的连接
        pool_size=5,  # 连接池大小
        pool_timeout=30,  # 池中没有线程最多等待的时间，否则报错
        pool_recycle=-1  # 多久之后对线程池中的线程进行一次连接的回收（重置）
    )
    ## 第四步：创建表(不能创建库，只能新增或删除表，不能增加删除字段)
    # Base.metadata.create_all(engine)

    ## 第五步：删除表
    Base.metadata.drop_all(engine)

1.2 增删查改

from models import User
# 第一步：创建engine
from sqlalchemy import create_engine
engine = create_engine(
    "mysql+pymysql://root:123456@127.0.0.1:3307/sqlalchemy001?charset=utf8",
    max_overflow=0,  # 超过连接池大小外最多创建的连接
    pool_size=5,  # 连接池大小
    pool_timeout=30,  # 池中没有线程最多等待的时间，否则报错
    pool_recycle=-1  # 多久之后对线程池中的线程进行一次连接的回收（重置）
)

# 第二步：创建 session对象---老方式
# from sqlalchemy.orm import sessionmaker
# Session = sessionmaker(bind=engine)
# session=Session()
# 第二步：创建 session对象---新方式(推荐)
from sqlalchemy.orm import Session
session=Session(engine)

# 第三步：使用session对象
# 1 新增
user1=User(name='hope',email='333@qq.com')
user2=User(name='Tony',email='335@qq.com')
# session.add(user)
session.add_all([user1,user2])
session.commit()  #提交
session.close()


# 2 搜索--》简单
# res=session.query(User).filter_by(name='lqz').all()
# res=session.query(User).filter_by(id=1).all()
# print(res)
# print(res[0])

# 3 删除
# res=session.query(User).filter_by(name='lqz').delete()
# print(res)
# session.commit()

# 4 修改
# res=session.query(User).filter_by(id=2).update({'name':'ooo'})
# session.commit()
# user=session.query(User).filter_by(id=2).first()
# print(user.id)
# user.name='uuii'
# session.add(user) #[id字段在不在] 如果对象不存在，就是新增，如果对象存在，就是修改
# session.commit()

4 一对多关系

# 1 一对一   [本质就是一对多--》多的那个唯一]
# 2 一对多
# 3 多对多

4.1 建表

####  一对多关系
class Hobby(Base):
    __tablename__ = 'hobby'
    id = Column(Integer, primary_key=True)
    caption = Column(String(50), default='篮球')
    def __str__(self):
        return self.caption


class Person(Base):
    __tablename__ = 'person'
    nid = Column(Integer, primary_key=True)
    name = Column(String(32), index=True, nullable=True)
    # hobby指的是tablename而不是类名
    hobby_id = Column(Integer, ForeignKey("hobby.id"))  # 一个爱好，可以被多个人喜欢，一个人只能喜欢一个爱好

    # 跟数据库无关，不会新增字段，只用于快速链表操作
    # 类名，backref用于反向查询
    hobby = relationship('Hobby', backref='pers')
    def __str__(self):
        return self.name

    def __repr__(self):
        return self.name

from models import Person,Hobby
# 第一步：创建engine
from sqlalchemy import create_engine
engine = create_engine(
   "mysql+pymysql://root:123456@127.0.0.1:3307/sqlalchemy001?charset=utf8",
    max_overflow=0,  # 超过连接池大小外最多创建的连接
    pool_size=5,  # 连接池大小
    pool_timeout=30,  # 池中没有线程最多等待的时间，否则报错
    pool_recycle=-1  # 多久之后对线程池中的线程进行一次连接的回收（重置）
)

# 第二步：创建 session对象---老方式
from sqlalchemy.orm import Session
session=Session(engine)


if __name__ == '__main__':
    ### 笨办法增加
    #1 先增加一个hobby
    # hobby=Hobby()
    # session.add(hobby)
    # session.commit()
    #2 增加Person---》必须要有hobby_id
    # person=Person(name='lqz',hobby_id=1)
    # session.add(person)
    # session.commit()

    ### 简便方法--》增加person的同时，增加了Hobby
    # person = Person(name='lqz', hobby=Hobby(caption='乒乓球'))
    # session.add(person)
    # session.commit()
    # hobby=session.query(Hobby).filter_by(id=1).first()
    # person = Person(name='lqz3', hobby=hobby)
    # session.add(person)
    # session.commit()


    # 基于对象的跨表查询--->正向
    # person=session.query(Person).filter_by(nid=2).first()
    # print(person)
    # print(person.hobby_id)
    # print(person.hobby)

    # 基于对象的跨表查询--->反向
    hobby = session.query(Hobby).filter_by(id=1).first()
    print(hobby.caption)
    print(hobby.pers)

5 scoped线程安全

# 1 如果我们把session 做成全局 单例
	-每个视图函数，用同一个session，有问题
    
#2 如果在每个视图函数中，都对session实例化一次
	-代码有点麻烦
    
# 3 全局就用一个session对象，它在不同线程中---》都是这个线程自己的

from models import User
import threading
# 第一步：创建engine
from sqlalchemy import create_engine
engine = create_engine(
    "mysql+pymysql://root:123456@127.0.0.1:3307/sqlalchemy001?charset=utf8",
    max_overflow=0,  # 超过连接池大小外最多创建的连接
    pool_size=5,  # 连接池大小
    pool_timeout=30,  # 池中没有线程最多等待的时间，否则报错
    pool_recycle=-1  # 多久之后对线程池中的线程进行一次连接的回收（重置）
)

# 第二步：创建 线程安全的 session
from sqlalchemy.orm import sessionmaker
from sqlalchemy.orm import scoped_session
Session = sessionmaker(bind=engine)
session=scoped_session(Session)

# 第三步：正常使用-->再flask中，使用全局的session即可，实现：不同线程使用线程自己的session对象
def task(se,i):
    session=se()
    session.add(User(name='xxx',email=f'{i}@qq.com'))
    session.commit()
    print('=========',session)

if __name__ == '__main__':
    l=[]
    for i in range(10):
        t=threading.Thread(target=task,args=[session,i])
        t.start()
        l.append(t)
    for i in l:
        i.join()