mysql级别的外键,还不够ORM,必须拿到一个表的外键,然后通过这个外键再去另外一张表中查找,这样太麻烦了。SQLAlchemy提供了一个relationship
,这个类可以定义属性,以后在访问相关联的表的时候就直接可以通过属性访问的方式就可以访问得到了。示例代码:
class User(Base):
__tablename__ = 'user'
id = Column(Integer,primary_key=True,autoincrement=True)
username = Column(String(50),nullable=False)
# articles = relationship("Article")
def __repr__(self):
return "<User(username:%s)>" % self.username
class Article(Base):
__tablename__ = 'article'
id = Column(Integer,primary_key=True,autoincrement=True)
title = Column(String(50),nullable=False)
content = Column(Text,nullable=False)
uid = Column(Integer,ForeignKey("user.id"))
author = relationship("User", backref='articles')
def __repr__(self):
return "<Article(title:%s)>" % self.title
找到某个用户的所有文章:
user = session.query(User).filter_by(username='ying').first()
print(user.articles)
这里的user.articles
是一个List的子类,可以使用append(article)
添加绑定新的文章
relationship指定的是模型,之前的ForeignKey指定的是表
另外,可以通过backref
进行反向引用,上面的例子中,在Article中,author = relationship("User", backref='articles')
相当于在User中添加了articles = relationship("Article")
user = User(username='ying')
article1.author = user
在sqlalchemy中,如果想要将两个模型映射成一对一的关系,那么应该在父模型中,指定引用的时候,要传递一个uselist=False
这个参数进去。就是告诉父模型,以后引用这个从模型的时候,不再是一个列表了,而是一个对象了。示例代码如下:
user.extend
是一个List的继承类,所以使用uselist=False
使用sqlalchemy.orm.backref
来定义relationship
的反向引用:
class User(Base):
__tablename__ = 'user'
id = Column(Integer,primary_key=True,autoincrement=True)
username = Column(String(50),nullable=False)
# extend = relationship("UserExtend",uselist=False)
def __repr__(self):
return "<User(username:%s)>" % self.username
# 存放一些用户不常用的字段
class UserExtend(Base):
__tablename__ = 'user_extend'
id = Column(Integer, primary_key=True, autoincrement=True)
school = Column(String(50))
uid = Column(Integer,ForeignKey("user.id", ondelete='CASCADE'))
user = relationship("User",backref=backref("extend",uselist=False))
# 定义中间表
article_tag = Table(
"article_tag", # 表名
Base.metadata,
Column("article_id", Integer, ForeignKey("article.id"), primary_key=True),
Column("tag_id", Integer, ForeignKey("tag.id"), primary_key=True)
)
class Article(Base):
__tablename__ = 'article'
id = Column(Integer, autoincrement=True, primary_key=True)
title = Column(String(50), nullable=False)
tag = relationship("Tag", backref="articles", secondary=article_tag)
class Tag(Base):
__tablename__ = 'tag'
id = Column(Integer, autoincrement=True, primary_key=True)
name = Column(String(50), nullable=False)
注意:
sqlalchemy.Table
secondary
参数,填写中间表的名称ORM代码删除数据时会无视数据表之间的约束,直接删除数据。然后将外键的数据设置为NULL。就像约束SET NULL
一样。但是,如果数据项被设置为nullable=False
的时候,删除会报错。
ORM层面删除数据,会无视mysql级别的外键约束。直接会将对应的数据删除,然后将从表中的那个外键设置为NULL。如果想要避免这种行为,应该将从表中的外键的nullable=False
。
relationship
中的cascade
参数在SQLAlchemy,只要将一个数据添加到session中,和他相关联的数据都可以一起存入到数据库中了。这些是怎么设置的呢?其实是通过relationship的时候,有一个关键字参数cascade可以设置这些属性:
class User(Base):
__tablename__ = 'user'
id = Column(Integer,primary_key=True,autoincrement=True)
username = Column(String(50),nullable=False)
# articles = relationship("Article")
def __repr__(self):
return "<User(username:%s)>" % self.username
class Article(Base):
__tablename__ = 'article'
id = Column(Integer,primary_key=True,autoincrement=True)
title = Column(String(50),nullable=False)
content = Column(Text,nullable=False)
uid = Column(Integer,ForeignKey("user.id"))
author = relationship("User", backref='articles', cascade='')
def __repr__(self):
return "<Article(title:%s)>" % self.title
user = User(username='ying')
article1 = Article(title='123', content='xxx')
article1.author = user
session.add(article1)
session.commit()
这里Article的author中relationship
的参数cascade
设置为空字符串,下面添加数据的时候,只添加article是不会通过添加user的。程序运行的时候也会提出警告。cascade
默认是同时添加。
当cascade
有多个参数的时候,使用英文逗号分隔,如:cascade='save-update, delete'
books = session.query(Book).order_by(Book.price.desc()).all()
或者
books = session.query(Book).order_by(-Book.price).all()
或者
books = session.query(Book).order_by("-price").all()
__mapper_args__ = { "order_by" : price.desc() } 即可让文章使用标题来进行排序。
class Book(Base):
__tablename__ = 'book'
id = Column(Integer, primary_key=True, autoincrement=True)
title = Column(String(100), nullable=False)
price = Column(Float, nullable=False)
__mapper_args__ = {
"order_by" : price.desc()
}
def __repr__(self):
return "%s" % self.title
books = session.query(Book).all()
print(books)
desc()
方法,或者是在排序的时候使用这个字段的字符串名字,然后在前面加一个负号。books = session.query(Book).limit(5).all()
结果:[title0, title1, title2, title3, title4]
books = session.query(Book).offset(5).limit(3).all()
结果:[title5, title6, title7]
slice(start,stop)
方法来做切片操作。也可以使用[start:stop]
的方式来进行切片操作。一般在实际开发中,中括号的形式是用得比较多的。希望大家一定要掌握。示例代码如下:books = session.query(Book).all()[5:9]
结果:[title5, title6, title7, title8]
实例: 分页, 数据分3页
books = session.query(Book)#.all()
pages = 3
every_page = 3
for i in range(pages):
print(books[every_page*i : every_page*(i + 1)])
这里可以不用加.all()
,使用切片会自动把结果转换成list。仅限切片可以不用加.all()
在一对多,或者多对多的时候,如果想要获取多的这一部分的数据的时候,往往能通过一个属性就可以全部获取了。比如有一个作者,想要或者这个作者的所有文章,那么可以通过user.articles就可以获取所有的。但有时候我们不想获取所有的数据,比如只想获取这个作者今天发表的文章,那么这时候我们可以给relationship传递一个lazy=’dynamic’,以后通过user.articles获取到的就不是一个列表,而是一个AppenderQuery对象了。这样就可以对这个对象再进行一层过滤和排序等操作。
通过lazy='dynamic'
,获取出来的多的那一部分的数据,就是一个AppenderQuery
对象了。这种对象既可以添加新数据,也可以跟Query
一样,可以再进行一层过滤。
总而言之一句话:如果你在获取数据的时候,想要对数据再进行一层过滤时,可以考虑使用lazy='dynamic'
。
lazy可用的选项:
select
:这个是默认选项。还是拿user.articles
的例子来讲。如果你没有访问user.articles
这个属性,那么sqlalchemy就不会从数据库中查找文章。一旦你访问了这个属性,那么sqlalchemy就会立马从数据库中查找所有的文章,并把查找出来的数据组装成一个列表返回。这也是懒加载。dynamic
:这个就是我们刚刚讲的。就是在访问user.articles
的时候返回回来的不是一个列表,而是AppenderQuery
对象。使用dynamic
后,使用relationship
返回的对象就是一个query的结果对象,然后就可以使用filter进行数据过滤。
class User(Base):
__tablename__ = 'user'
id = Column(Integer, primary_key=True, autoincrement=True)
username = Column(String(50),nullable=False)
class Article(Base):
__tablename__ = 'article'
id = Column(Integer, primary_key=True, autoincrement=True)
title = Column(String(50), nullable=False)
create_time = Column(DateTime,nullable=False,default=datetime.now)
uid = Column(Integer,ForeignKey("user.id"))
author = relationship("User",backref=backref("articles",lazy="dynamic"))
def __repr__(self):
return "<Article(title: %s)>" % self.title
user = session.query(User).first()
user.books.append(Book(title='title100', price=random.randint(50, 100)))
session.commit()
print(user.books.filter(Book.price>86).all())
此时也可以使用append进行添加对象操作
根据某个字段进行分组。比如想要根据性别进行分组,来统计每个分组分别有多少人,那么可以使用以下代码来完成:
session.query(User.gender,func.count(User.id)).group_by(User.gender).all()
class GenderEnum(enum.Enum):
male = "male"
female = "female"
def __repr__(self):
return "%s" % self.value
class Person(Base):
__tablename__ = 'person'
id = Column(Integer, primary_key=True, autoincrement=True)
name = Column(String(50), nullable=False)
gender = Column(Enum(GenderEnum))
age = Column(Integer, nullable=False)
def __repr__(self):
return '%s' % self.name
Base.metadata.drop_all()
Base.metadata.create_all()
for i in range(20):
p = Person(name="小%s" % i, gender=random.choice([name for name, member in GenderEnum.__members__.items()]), age=random.randint(1, 30))
session.add(p)
session.commit()
peoples = session.query(Person.gender, func.count(Person.id)).group_by(Person.gender).all()
having是对查找结果进一步过滤。对分组进行having过滤。示例代码如下:
peoples = session.query(Person.gender, func.count(Person.id)).group_by(Person.gender).having(Person.gender=='male').all()
result = session.query(User,func.count(Article.id)).join(Article).group_by(User.id).order_by(func.count(Article.id).desc()).all()
子查询可以让多个查询变成一个查询,只要查找一次数据库,性能相对来讲更加高效一点。不用写多个sql语句就可以实现一些复杂的查询。那么在sqlalchemy中,要实现一个子查询,应该使用以下几个步骤:
1. 将子查询按照传统的方式写好查询代码,然后在query
对象后面执行subquery
方法,将这个查询变成一个子查询。
2. 在子查询中,将以后需要用到的字段通过label
方法,取个别名。
3. 在父查询中,如果想要使用子查询的字段,那么可以通过子查询的返回值上的c
属性拿到。
整体的示例代码如下:
stmt = session.query(User.city.label("city"),User.age.label("age")).filter(User.username=='李A').subquery()
result = session.query(User).filter(User.city==stmt.c.city,User.age==stmt.c.age).all()
stmt.c.city
这里的c是Column的简写
SQL练习
pip install flask-sqlalchemy
SQLALCHEMY_DATABASE_URI
这个键放到app.config
中。示例代码:app.config["SQLALCHEMY_DATABASE_URI"] = DB_URI
.flask_sqlalchemy.SQLAlchemy
这个类定义一个对象,并将app
传入进去。示例代码:db = SQLAlchemy(app)
。delarative_base
来创建一个基类。而是使用db.Model
来作为基类。Column
、String
、Integer
以及relationship
等,都不需要导入了,直接使用db
下面相应的属性名就可以了。__tablename__
,那么flask_sqlalchemy
会默认使用当前的模型的名字转换成小写来作为表的名字,并且如果这个模型的名字使用了多个单词并且使用了驼峰命名法,那么会在多个单词之间使用下划线来进行连接。虽然flask_sqlalchemy给我们提供了这个特性,但是不推荐使用。以后session也不需要使用sessionmaker
来创建了。直接使用db.session
就可以了。操作这个session的时候就跟之前的sqlalchemy
的session
是iyimoyiyang的。
如果查找数据只是查找一个模型上的数据,那么可以通过模型.query
的方式进行查找。query
就跟之前的sqlalchemy中的query方法是一样用的。示例代码如下:
users = User.query.order_by(User.id.desc()).all()
print(users)
alembic
是由SQLAlchemy
的作者(Michael Bayer)开发。用来做ORM模型与数据库的迁移与映射。alembic
的方式类似git,表现在:
alembic
所有的命令都以alembic
开头;alembic
的迁移文件也是通过版本进行控制的pip install alembic
使用alembic的步骤:
class User(Base):
__tablename__ = 'user'
id = Column(Integer, primary_key=True, autoincrement=True)
username = Column(String(50), nullable=False)
def __repr__(self):
return "%s" % self.username
alembic init [仓库的名字,推荐使用alembic]
。
alembic.ini
中,给sqlalchemy.url
设置数据库的连接方式。这个连接方式跟sqlalchemy的方式一样的。alembic/env.py
中的target_metadata
设置模型的Base.metadata
。但是要导入models
,需要将models所在的路径添加到这个文件中。示例代码如下:
python
import sys,os
sys.path.append(os.path.dirname(os.path.dirname(__file__)))
from alembic_demo import Base
target_metadata = Base.metadata
os.path.dirname(__file__)
可以获取当前文件的目录
alembic revision --autogenerate -m 'message'
。
alembic upgrade head
。
alembic upgrade head
upgrade head
时报某个表已经存在的错误: 创建flask项目,创建好模型
alembic init alembic
修改配置文件
import sys, os
sys.path.append(os.path.dirname(os.path.dirname(__file__)))
from app import db
target_metadata = db.Model.metadata
这里和之前不同, 这里还要注意加入路径和导入db的顺序
alembic revision --autogenerate -m "first commit"
alembic upgrade head