flask-SQLAlchemy的ORM

1.创建表

import datetime
from sqlalchemy import create_engine
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import Column, Integer, String, Text, ForeignKey, DateTime, UniqueConstraint, Index
from sqlalchemy.orm import relationship, sessionmaker

Base = declarative_base()

# 一对多
class Users(Base):
    __tablename__ = 'users'

    id = Column(Integer, primary_key=True)
    name = Column(String(32), index=True, nullable=False)
    email = Column(String(32), unique=True)
    ctime = Column(DateTime, default=datetime.datetime.now)   # 传递函数
    extra = Column(Text, nullable=True)

    # 联级删除
    groupId = Column(Integer, ForeignKey("usergroup.id", ondelete='CASCADE'))
    userGroup = relationship("UserGroup", backref="gusers")

    __table_args__ = {
        # 字符编码
        'mysql_charset': 'utf8'
        # 引擎
        # UniqueConstraint('id', 'name', name='uix_id_name'),
        # Index('ix_id_name', 'name', 'email'),
    }
class UserGroup(Base):
    __tablename__ = 'usergroup'
    id = Column(Integer, primary_key=True)
    name = Column(String(50), nullable=False)

# 多对多
class Grade(Base):
    __tablename__ = 'grade'
    id = Column(Integer, primary_key=True, autoincrement=True)
    score = Column(Integer, default=0)

    # 联级删除,一般不会直接删除关联表，而是将state设置为0
    student_id = Column(Integer, ForeignKey('student.id', ondelete='CASCADE'))
    course_id = Column(Integer, ForeignKey('course.id', ondelete='CASCADE'))

class Student(Base):
    __tablename__ = 'student'
    id = Column(Integer, primary_key=True)
    name = Column(String(64), nullable=False)
    # age = Column(Integer)

    # 与生成表结构无关，仅用于查询方便
    courses = relationship('Course', secondary='grade', backref='students')

class Course(Base):
    __tablename__ = 'course'

    id = Column(Integer, primary_key=True, autoincrement=True)
    course_name = Column(String(64), nullable=False)

def init_db():
    engine = create_engine(
        "mysql+cymysql://root:123@127.0.0.1:3306/sqlalchemy1?charset=utf8",
        max_overflow=0,  # 超过连接池大小外最多创建的连接
        pool_size=5,  # 连接池大小
        pool_timeout=30,  # 池中没有线程最多等待的时间，否则报错
        pool_recycle=-1  # 多久之后对线程池中的线程进行一次连接的回收（重置）
    )
    Base.metadata.create_all(engine)

def del_db():
    """
        根据类删除数据库表
        :return:
        """
    engine = create_engine(
        "mysql+cymysql://root:123@127.0.0.1:3306/sqlalchemy1?charset=utf8",
        max_overflow=0,  # 超过连接池大小外最多创建的连接
        pool_size=5,  # 连接池大小
        pool_timeout=30,  # 池中没有线程最多等待的时间，否则报错
        pool_recycle=-1  # 多久之后对线程池中的线程进行一次连接的回收（重置）
    )

    Base.metadata.drop_all(engine)

def init_data1():
    engine = create_engine("mysql+cymysql://root:123@127.0.0.1:3306/sqlalchemy1?charset=utf8", max_overflow=0,
                           pool_size=5)
    Session = sessionmaker(bind=engine)

    session = Session()
    # 方式一
    # session.add_all([UserGroup(name='用户组1'), UserGroup(name='用户组2')])
    # session.add_all([Users(name='admin', email='666@qq.com', extra='简介', groupId=1),
    #                  Users(name='admin', email='888@qq.com', extra='简介2', groupId=2),])
    # 方式二
    g1 = UserGroup(name='用户组3')
    g1.gusers = [Users(name='admin', email='777@qq.com', extra='简介', groupId=1)]
    session.add(g1)
    g2 = UserGroup(name='用户组4')
    g2.gusers = [Users(name='admin', email='999@qq.com', extra='简介2', groupId=2)]
    session.add(g2)

    session.commit()
    session.close()

def init_data2():
    engine = create_engine("mysql+cymysql://root:123@127.0.0.1:3306/sqlalchemy1?charset=utf8", max_overflow=0,
                           pool_size=5)
    Session = sessionmaker(bind=engine)

    session = Session()
    # 方式一
    # session.add_all([Student(name='张三'), Student(name='李四'), ])
    # session.add_all([Course(course_name='java'), Course(course_name='python'), ])
    #
    # session.commit()  # 这里必须先提交
    #
    # session.add_all([Grade(student_id=1, course_id=1),
    #                  Grade(student_id=1, course_id=2),
    #                  Grade(student_id=2, course_id=1), ])

    # 方式二
    # 自动插入Grade数据，仅仅插入id
    stu1 = Student(name='张三')
    stu1.courses = [Course(course_name='java'), Course(course_name='python'), ]
    session.add(stu1)

    session.commit()
    session.close()

ORM

2.增删改查

# ################ 添加 ################
"""
obj1 = Users(name="wupeiqi")
session.add(obj1)

session.add_all([
    Users(name="wupeiqi"),
    Users(name="alex"),
    Hosts(name="c1.com"),
])
session.commit()
"""

# ################ 删除 ################
"""
session.query(Users).filter(Users.id > 2).delete()
session.commit()
"""
# ################ 修改 ################
"""
session.query(Users).filter(Users.id > 0).update({"name" : "099"})
session.query(Users).filter(Users.id > 0).update({Users.name: Users.name + "099"}, synchronize_session=False)
session.query(Users).filter(Users.id > 0).update({"age": Users.age + 1}, synchronize_session="evaluate")
session.commit()
"""
# ################ 查询 ################
filter:表达式
filter_by:参数
动态参数：text(id<:value and name=:name)
执行原生SQL：session.query(Users).from_statement(text("select * from users where id=:value")).params(name='')
"""
r1 = session.query(Users).all()
r2 = session.query(Users.name.label('xx'), Users.age).all()
r3 = session.query(Users).filter(Users.name == "alex").all()
r4 = session.query(Users).filter_by(name='alex').all()
r5 = session.query(Users).filter_by(name='alex').first()
r6 = session.query(Users).filter(text("id<:value and name=:name")).params(value=224, name='fred').order_by(Users.id).all()
r7 = session.query(Users).from_statement(text("SELECT * FROM users where name=:name")).params(name='ed').all()
"""

常用操作：

#　条件
in_
~ :非

ret = session.query(Users).filter_by(name='alex').all()
ret = session.query(Users).filter(Users.id > 1, Users.name == 'eric').all()
ret = session.query(Users).filter(Users.id.between(1, 3), Users.name == 'eric').all()
ret = session.query(Users).filter(Users.id.in_([1,3,4])).all()
ret = session.query(Users).filter(~Users.id.in_([1,3,4])).all()
# 连接查询
ret = session.query(Users).filter(Users.id.in_(session.query(Users.id).filter_by(name='eric'))).all()
from sqlalchemy import and_, or_
ret = session.query(Users).filter(and_(Users.id > 3, Users.name == 'eric')).all()
ret = session.query(Users).filter(or_(Users.id < 2, Users.name == 'eric')).all()
ret = session.query(Users).filter(
    or_(
        Users.id < 2,
        and_(Users.name == 'eric', Users.id > 3),
        Users.extra != ""
    )).all()

# 通配符
ret = session.query(Users).filter(Users.name.like('e%')).all()
ret = session.query(Users).filter(~Users.name.like('e%')).all()

# 限制
ret = session.query(Users)[1:2]

# 排序
ret = session.query(Users).order_by(Users.name.desc()).all()
ret = session.query(Users).order_by(Users.name.desc(), Users.id.asc()).all()

# 分组
from sqlalchemy.sql import func

ret = session.query(Users).group_by(Users.extra).all()
# 聚合函数
ret = session.query(
    func.max(Users.id),
    func.sum(Users.id),
    func.min(Users.id)).group_by(Users.name).all()

ret = session.query(
    func.max(Users.id),
    func.sum(Users.id),
    func.min(Users.id)).group_by(Users.name).having(func.min(Users.id) >2).all()

# 连表

ret = session.query(Users, Favor).filter(Users.id == Favor.nid).all()

# 默认使用外键关系，连接查询
ret = session.query(Person).join(Favor).all()

# left join  左外连接
ret = session.query(Person).join(Favor, isouter=True).all()
ret = session.query(Person， Favor).join(Favor, Favor.id == Person.id, isouter=True).all()
ret = session.query(Person, Favor).join(Favor, and_(Person.id>1, Person.id==Favor.id).all()

# 组合
q1 = session.query(Users.name).filter(Users.id > 2)
q2 = session.query(Favor.caption).filter(Favor.nid < 2)
ret = q1.union(q2).all()

q1 = session.query(Users.name).filter(Users.id > 2)
q2 = session.query(Favor.caption).filter(Favor.nid < 2)
ret = q1.union_all(q2).all()

原生SQL：

import time
import threading

from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import Column, Integer, String, ForeignKey, UniqueConstraint, Index
from sqlalchemy.orm import sessionmaker, relationship
from sqlalchemy import create_engine
from sqlalchemy.sql import text
from sqlalchemy.engine.result import ResultProxy
from db import Users, Hosts

engine = create_engine("mysql+pymysql://root:123@127.0.0.1:3306/s6", max_overflow=0, pool_size=5)
Session = sessionmaker(bind=engine)

session = Session()

# 查询
# cursor = session.execute('select * from users')
# result = cursor.fetchall()

# 添加
cursor = session.execute('insert into users(name) values(:value)',params={"value":'wupeiqi'})
session.commit()
print(cursor.lastrowid)

session.close()

关联子查询：

　　获取课程最高分：

select id as cid, course_name, (select max(score) from grade where course_id=cid) as maxgrade from course

　　

1.一对多

　　外键关系：

多对多关系：

book.py

user.py

关系表：gift.py

添加：db.session.add()

　　　 db.session.commit()

获取当前用户：current_user

事务回滚：