SqlAlchemy学习笔记

前言

　　SqlAlchemy 是在python中最有名的ORM(Objet Relational Mapping)框架，主要的任务是把关系数据库的表结构映射到python中的额对象。

　　以前python通过原生的sql访问操作数据库，那种方式很繁琐，且没有安全感，现在通过ORM这个壳来访问操作数据库，这个壳具有python的style，壳里面包裹着sql。这样就大大方便了python使用者。

　　Alembic是SQLAlchemy数据库迁移工具，由SQLAlchemy作者所创建，是对后台SQLAIchemy数据库执行迁移的事实上的标准工具。换句话说，Alembic可以对SQLAIchemy数据库进行版本控制(类似于git)。

 创建模型类

from sqlalchemy import create_engine,Column,Integer,String
from sqlalchemy.ext.declarative import declarative_base

# HOSTNAME = '127.0.0.1'
# PORT = '3306'
# DATABASE = 'first_sqlalchemy'
# USERNAME = 'ROOT'
# PASSWORD = '123456'

engine = create_engine("mysql+pymysql://root:123456@127.0.0.1/first_sqlalchemy?charset=utf8")
BO = declarative_base(engine)
# 1、用declarative_base创建一个ORM基类；
# 2、创建一个ORM模型类，继承自sqlalchemy提供的基类；类中创建属性，跟表中的字段一一映射，
# 这些属性必须是sqlalchemy给我们提供好的数据类型
class Person(BO):
    __tablename__ = 'Person'
    id = Column(Integer,primary_key=True,autoincrement=True)
    name = Column(String(50))
    age = Column(Integer)
# 3、将建好的ORM模型类映射到数据库中；
BO.metadata.create_all()

增删改查

#encoding: utf-8

from sqlalchemy import create_engine,Column,Integer,String
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker

HOSTNAME = '127.0.0.1'
PORT = '3306'
DATABASE = 'first_sqlalchemy'
USERNAME = 'root'
PASSWORD = '123456'

# dialect+driver://username:password@host:port/database
DB_URI = "mysql+pymysql://{username}:{password}@{host}:{port}/{db}?charset=utf8".format(username=USERNAME,password=PASSWORD,host=HOSTNAME,port=PORT,db=DATABASE)
engine = create_engine(DB_URI)
Base = declarative_base(engine)
session = sessionmaker(engine)()

class Person(Base):
    __tablename__ = 'person'
    id = Column(Integer,primary_key=True,autoincrement=True)
    name = Column(String(50))
    age = Column(Integer)
    country = Column(String(50))
    def __str__(self):
        return "<Person(name:%s,age:%s,country:%s)>" % (self.name,self.age,self.country)


Base.metadata.drop_all()
Base.metadata.create_all()

# 增
def add_data():
    p1 = Person(name='刘亦菲',age=22,country='America')
    p2 = Person(name='李沁',age=20,country='China')
    p3 = Person(name='高圆圆',age=23,country='China')
    session.add_all([p1,p2,p3]) # 添加多条数据
    session.commit() # 提交

# 查
def search_data():
    # all_person = session.query(Person).all()  # 使用all方法获取结果集中的所有数据
    # for p in all_person:
    #     print(p)
    # all_person = session.query(Person).filter_by(name='wy').all() #过滤器，条件查询
    # for x in all_person:
    #     print(x)
    # all_person = session.query(Person).filter(Person.name=='wy').all()
    # for x in all_person:
    #     print(x)
    person = session.query(Person).first() # 使用first方法获取结果集中的第一条数据
    print(person)
# 改

def update_data():
    person = session.query(Person).first()
    person.name = 'wangyi'
    session.commit()

# 删
def delete_data():
    person = session.query(Person).first()
    session.delete(person)
    session.commit()

if __name__ == '__main__':

    # add_data()
    search_data()
    # update_data()
    # delete_data()

条件查询

#encoding: utf-8
from sqlalchemy import create_engine,Column,Integer,Float,Boolean,DECIMAL,Enum,Date,DateTime,Time,String,Text,func,and_,or_
from sqlalchemy.dialects.mysql import LONGTEXT
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker
# 在Python3中才有这个enum模块，在python2中没有
import enum
from datetime import datetime
import random
HOSTNAME = '127.0.0.1'
PORT = '3306'
DATABASE = 'first_sqlalchemy'
USERNAME = 'root'
PASSWORD = '123456'
# dialect+driver://username:password@host:port/database
DB_URI = "mysql+pymysql://{username}:{password}@{host}:{port}/{db}?charset=utf8mb4".format(username=USERNAME,password=PASSWORD,host=HOSTNAME,port=PORT,db=DATABASE)
engine = create_engine(DB_URI)
Base = declarative_base(engine)
session = sessionmaker(engine)()

class Article(Base):
    __tablename__ = 'article'
    id = Column(Integer,primary_key=True,autoincrement=True)
    title = Column(String(50),nullable=False)
    price = Column(Float,nullable=False)
    content = Column(Text)

    def __repr__(self):
        return "<Article(title:%s)>" % self.title

# session.query(Article).filter(Article.id == 1)
# session.query(Article).filter_by(id = 1)

# 1. equal
# article = session.query(Article).filter(Article.title == "title0").first()
# print(article)

# 2. not equal
# articles = session.query(Article).filter(Article.title != 'title0').all()
# print(articles)

# 3. like & ilike（不区分大小写）
# articles = session.query(Article).filter(Article.title.ilike('title%')).all()
# print(articles)

# 4. in：
# for xxx in xxx
# def _in()
# articles = session.query(Article).filter(Article.title.in_(['title1','title2'])).all()
# print(articles)

# not in
# articles = session.query(Article).filter(~Article.title.in_(['title1','title2'])).all()
# print(articles)
# articles = session.query(Article).filter(Article.title.notin_(['title1','title2'])).all()
# print(articles)

# is null
# articles = session.query(Article).filter(Article.content==None).all()
# print(articles)

# is not null
# articles = session.query(Article).filter(Article.content!=None).all()
# print(articles)

# and
# articles = session.query(Article).filter(Article.title=='abc',Article.content=='abc').all()
# print(articles)

# or
articles = session.query(Article).filter(or_(Article.title=='abc',Article.content=='abc'))
print(articles)

# 以上不写all()会直接打印底层原生的sql语句

外键

外键构建和四种约束

#encoding: utf-8
from sqlalchemy import create_engine,Column,Integer,Float,Boolean,DECIMAL,Enum,Date,DateTime,Time,String,Text,func,and_,or_,ForeignKey
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker

HOSTNAME = '127.0.0.1'
PORT = '3306'
DATABASE = 'first_sqlalchemy'
USERNAME = 'root'
PASSWORD = '123456'

# dialect+driver://username:password@host:port/database
DB_URI = "mysql+pymysql://{username}:{password}@{host}:{port}/{db}?charset=utf8mb4".format(username=USERNAME,password=PASSWORD,host=HOSTNAME,port=PORT,db=DATABASE)

engine = create_engine(DB_URI)
Base = declarative_base(engine)
session = sessionmaker(engine)()

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)
    content = Column(Text,nullable=False)

    uid = Column(Integer,ForeignKey('user.id', ondelete="CASCADE"))  # 这里uid的数据类型要和user表中的id的数据类型一致
"""
外键约束:
1、RESTRICT：默认ondelete=RESTRICT,此时删除主表的被关联数据，会报错，如：
ERROR 1451 (23000): Cannot delete or update a parent row: a foreign key constraint
fails (`first_sqlalchemy`.`article`, CONSTRAINT `article_ibfk_1` FOREIGN KEY (`uid`) REFERENCES `user` (`id`))
2、NO ACTION：在mysql中等同于RESTRICT；
3、CASCADE：级联删除
4、SET NULL:主表数据删除后副表置空。此时从表的外键nullable不能为False。
"""

Base.metadata.drop_all()
Base.metadata.create_all()

user1 = User(username='刘亦菲')
user2 = User(username='杨幂')
session.add_all([user1,user2])
session.commit()

article1 = Article(title='hello world',content='这是内容',uid=1)
session.add(article1)
session.commit()

ORM层外键关联

实现迅速在另一个表中找到相关联的数据：

#encoding: utf-8
from sqlalchemy import create_engine,Column,Integer,Float,Boolean,DECIMAL,Enum,Date,DateTime,Time,String,Text,func,and_,or_,ForeignKey
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker,relationship

HOSTNAME = '127.0.0.1'
PORT = '3306'
DATABASE = 'first_sqlalchemy'
USERNAME = 'root'
PASSWORD = '123456'

# dialect+driver://username:password@host:port/database
DB_URI = "mysql+pymysql://{username}:{password}@{host}:{port}/{db}?charset=utf8mb4".format(username=USERNAME,password=PASSWORD,host=HOSTNAME,port=PORT,db=DATABASE)

engine = create_engine(DB_URI)
Base = declarative_base(engine)
session = sessionmaker(engine)()

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{id:%s,username:%s}>"%(self.id,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")   # 这两个可以通过backref反转合二为一
    def __repr__(self):
        return "<article{id:%s,title:%s,content:%s,uid:%s}>"%(self.id,self.title,self.content,self.uid)

Base.metadata.drop_all()
Base.metadata.create_all()

user1 = User(username='刘亦菲')
user2 = User(username='杨幂')
session.add_all([user1,user2])
session.commit()

article1 = Article(title='文章1',content='内容1',uid=1)
article2 = Article(title='文章2',content='内容2',uid=2)
article3 = Article(title='文章3',content='内容3',uid=2)
session.add_all([article1,article2,article3])
session.commit()

# 对于都有数据的两张表user和article，正常情况下，要拿到第一篇article对应的username，通过如下方式：
# article = session.query(Article).first()
# uid = article.uid
# user = session.query(User).get(uid)
# print(user)


# 现在，通过ORM层外键实现：在Article模型中添加 author = relationship("User")
article = session.query(Article).filter(Article.title=="文章3").first()
print(article.author.username) # 杨幂


# 一个用户可以写多篇文章，一对多的关系，那么怎么拿到一个用户的所有文章的标题呢？同样，在User中添加 articles = relationship("Article")

user = session.query(User).filter(User.username=="杨幂").first()
for i in range(len(user.articles)):
    print(user.articles[i].title)

这两个relationship可以通过backref反转合二为一： author = relationship("User",backref="articles") 

ORM层面添加关联数据

#encoding: utf-8
from sqlalchemy import create_engine,Column,Integer,Float,Boolean,DECIMAL,Enum,Date,DateTime,Time,String,Text,func,and_,or_,ForeignKey
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker,relationship

HOSTNAME = '127.0.0.1'
PORT = '3306'
DATABASE = 'first_sqlalchemy'
USERNAME = 'root'
PASSWORD = '123456'

# dialect+driver://username:password@host:port/database
DB_URI = "mysql+pymysql://{username}:{password}@{host}:{port}/{db}?charset=utf8mb4".format(username=USERNAME,password=PASSWORD,host=HOSTNAME,port=PORT,db=DATABASE)

engine = create_engine(DB_URI)
Base = declarative_base(engine)
session = sessionmaker(engine)()

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{id:%s,username:%s}>"%(self.id,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{id:%s,title:%s,content:%s,uid:%s}>"%(self.id,self.title,self.content,self.uid)

Base.metadata.drop_all()
Base.metadata.create_all()
#
user1 = User(username='刘亦菲')
user2 = User(username='杨幂')
session.add_all([user1,user2])
session.commit()

article1 = Article(title='文章1',content='内容1',uid=1)
article2 = Article(title='文章2',content='内容2',uid=2)
article3 = Article(title='文章3',content='内容3',uid=2)
session.add_all([article1,article2,article3])
session.commit()


# ORM层面给用户添加文章：
article4 = Article(title='文章4',content='内容4')
article5 = Article(title='文章5',content='内容5')
user = User(username='高圆圆') # 顺着id直接新增，可以重名
user.articles.append(article4)
user.articles.append(article5)
session.add(user)
session.commit()

#ORM层面给文章指定作者
article6 = Article(title='文章6',content='内容6')
user = User(username='李沁')
article6.author = user
session.add(article6)
session.commit()

添加结果：

这有个疑问，为什么上面代码56行是append，而64行是赋值？

这是因为建立外键关联后，默认两张表是一对多的关系，主1从多。具体如下：

 一对一

将用户的不常用的静态字段如毕业学校，手机号，住址等放到单独的表里，外键关联选择一对一：

这里一对一的关键：

user = relationship("User",backref=backref("school",uselist=False))

#encoding: utf-8
from sqlalchemy import create_engine,Column,Integer,Float,Boolean,DECIMAL,Enum,Date,DateTime,Time,String,Text,func,and_,or_,ForeignKey
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker,relationship,backref

HOSTNAME = '127.0.0.1'
PORT = '3306'
DATABASE = 'first_sqlalchemy'
USERNAME = 'root'
PASSWORD = '123456'

# dialect+driver://username:password@host:port/database
DB_URI = "mysql+pymysql://{username}:{password}@{host}:{port}/{db}?charset=utf8mb4".format(username=USERNAME,password=PASSWORD,host=HOSTNAME,port=PORT,db=DATABASE)

engine = create_engine(DB_URI)
Base = declarative_base(engine)
session = sessionmaker(engine)()

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{id:%s,username:%s}>"%(self.id,self.username)

class Uschool(Base):
    '''新增毕业学校表'''
    __tablename__ = 'uschool'
    id = Column(Integer, primary_key=True, autoincrement=True)
    school = Column(String(50),nullable=False)
    uid = Column(Integer,ForeignKey("user.id"))

    user = relationship("User",backref=backref("school",uselist=False)) # 要导入backref
    # uselist=False 就表明主从表是一对一的关系

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{id:%s,title:%s,content:%s,uid:%s}>"%(self.id,self.title,self.content,self.uid)

Base.metadata.drop_all()
Base.metadata.create_all()

user1 = User(username='刘亦菲')
user2 = User(username='杨幂')
session.add_all([user1,user2])
session.commit()

article1 = Article(title='文章1',content='内容1',uid=1)
article2 = Article(title='文章2',content='内容2',uid=2)
article3 = Article(title='文章3',content='内容3',uid=2)
session.add_all([article1,article2,article3])
session.commit()

# ORM层面给用户添加文章：
article4 = Article(title='文章4',content='内容4')
article5 = Article(title='文章5',content='内容5')
user = User(username='高圆圆')
print(type(user.articles)) # <class 'sqlalchemy.orm.collections.InstrumentedList'>
# 默认一对多，user.articles是列表类型
user.articles.append(article4)
user.articles.append(article5)
for i in user.articles:
    print(i)
    # < article{id: None, title: 文章4, content: 内容4, uid: None} >
    # < article{id: None, title: 文章5, content: 内容5, uid: None} >

# user.articles = article4 #报错 TypeError: Incompatible collection type: Article is not list-like
session.add(user)
session.commit()
#ORM层面给文章指定作者
article6 = Article(title='文章6',content='内容6')
user = User(username='李沁')
print(type(article6.author)) # <class 'NoneType'>
article6.author = user
session.add(article6)
session.commit()

#这里一对一是假设一个用户只能对应唯一的学校，或许手机号的例子更合适
uschool01 = Uschool(school="清华")
uschool02 = Uschool(school="北大")
user1 = User(username="余承东")
user2 = User(username="李彦宏")
user1.school = uschool01
user2.school = uschool02
session.add(uschool01)
session.add(uschool02)
session.commit(

ORM层面删除数据

user = session.query(User).first()
session.delete(user)
session.commit()

将user表的第一个用户刘亦菲删除了，但是article表的对应刘亦菲的uid变为NULL。

正常情况下载sql层面上是不能删除有外键约束的表数据的，但是在ORM层面上会无视约束，会先把uid置为NULL，然后再去删除主表数据。

此时要想数据不被ORM删除，只需将从表的uid字段置为nullable=False。非空之后ORM也删不了了。

当然，如果只删除从表那就没主表什么事了。但如果想删除从表的同时，将主表也一并删除，怎么实现？

在relationship（）中有个参数cascade，可以实现主从表一并删除。

relationship中的cascade

在SqlAlchemy中，只要将一个数据添加到sessioon中，和他相关联的数据都可以一起存入到数据库中了。这些是怎么设置的呢？其实是通过relationship的中的一个关键字cascade实现的。如：

1、save-update：默认选项。在添加一条数据的时候会将其他相关联的数据添加进去；

2、delete：删除某个模型中数据的时候，也会删除relationship中关联模型的数据；

3、delete_orphan：写在主表的relationship中，当副表的uid置空时，副表的数据会被删除。只能用在一对多。还需要在副表的relationship中添加single_parent=True参数。

4、merge：默认选项。当在使用session.merge，合并一个对象的时候，会将使用了relationship相关联的对象也进行merge操作。

5、expunge：移除操作的时候，会将相关联的对象也进行移除。这个操作只是从session中移除，并不会真正的从数据库中删除。

6、all：是对save-update, merge, refresh-expire, expunge, delete几种的缩写。

排序

对字段进行正序或倒序排序，有三种方式去实现：

#encoding: utf-8
from sqlalchemy import create_engine,Column,Integer,Float,Boolean,DECIMAL,Enum,Date,DateTime,Time,String,Text,func,and_,or_,ForeignKey
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker,relationship,backref
from datetime import datetime
HOSTNAME = '127.0.0.1'
PORT = '3306'
DATABASE = 'first_sqlalchemy'
USERNAME = 'root'
PASSWORD = '123456'

# dialect+driver://username:password@host:port/database
DB_URI = "mysql+pymysql://{username}:{password}@{host}:{port}/{db}?charset=utf8mb4".format(username=USERNAME,password=PASSWORD,host=HOSTNAME,port=PORT,db=DATABASE)

engine = create_engine(DB_URI)
Base = declarative_base(engine)
session = sessionmaker(engine)()

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",order_by=create_time.desc()))

    # __mapper_args__ = {
    #     "order_by": create_time
    #     # "order_by": create_time.desc()
    # }

    def __repr__(self):
        return "<article{id:%s,title:%s,create_time:%s}>"%(self.id,self.title,self.create_time)
# Base.metadata.drop_all()
# Base.metadata.create_all()
# article1 = Article(title="文章1")
# article2 = Article(title="文章2")
# article3 = Article(title="文章3")
# session.add_all([article3,])
# session.commit()

# 1、方法一
# 正序
# article = session.query(Article).order_by('create_time').all()
article = session.query(Article).order_by(Article.create_time).all()
# 倒序
article = session.query(Article).order_by(Article.create_time.desc()).all()

# 方法二：直接在模型中通过__mapper_args__指定某个字段的排序方式
# 方法三：直接在relationship()中指定排序方式。
print(article)

Limit、offset和slice切片

#encoding: utf-8
from sqlalchemy import create_engine,Column,Integer,Float,Boolean,DECIMAL,Enum,Date,DateTime,Time,String,Text,func,and_,or_,ForeignKey
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker,relationship,backref
from datetime import datetime
HOSTNAME = '127.0.0.1'
PORT = '3306'
DATABASE = 'first_sqlalchemy'
USERNAME = 'root'
PASSWORD = '123456'

# dialect+driver://username:password@host:port/database
DB_URI = "mysql+pymysql://{username}:{password}@{host}:{port}/{db}?charset=utf8mb4".format(username=USERNAME,password=PASSWORD,host=HOSTNAME,port=PORT,db=DATABASE)

engine = create_engine(DB_URI)
Base = declarative_base(engine)
session = sessionmaker(engine)()


class Article1(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)


    def __repr__(self):
        return "<article{id:%s,title:%s,create_time:%s}>"%(self.id,self.title,self.create_time)
# Base.metadata.drop_all()
# Base.metadata.create_all()

def add_data():
    import time
    for i in range(1,11):
        article = Article1(title = "文章%s"%i)
        session.add(article)
        time.sleep(1)
        session.commit()
# add_data()
# 倒序取第7，第6两篇文章
articles1 = session.query(Article1).order_by(Article1.create_time.desc()).offset(3).limit(2).all()
# 切片取第3到第5篇文章,注意从0开始
articles2 = session.query(Article1).slice(2,5).all()
# 与上面等价
articles3 = session.query(Article1)[2:5]

# print(articles1)
# [<article{id:7,title:文章7,create_time:2020-04-14 01:28:22}>, <article{id:6,title:文章6,create_time:2020-04-14 01:28:21}>]

懒加载

在一对多，或者多对多的时候，如果想要获取多的这一部分的数据的时候，往往能通过一个属性就可以全部获取了。比如有一个作者，想要或者这个作者的所有文章，那么可以通过user.articles就可以获取所有的。但有时候我们不想获取所有的数据，比如只想获取这个作者今天发表的文章，那么这时候我们可以给relationship传递一个lazy='dynamic'，以后通过user.articles获取到的就不是一个列表，而是一个AppenderQuery对象了。这样就可以对这个对象再进行一层过滤和排序等操作。
通过`lazy='dynamic'，获取出来的多的那一部分的数据，就是一个’AppenderQuery’对象了。这种对象既可以添加新数据，也可以跟'Query'一样，可以再进行一层过滤。
总而言之：如果你在获取数据的时候，想要对多的那一边的数据再进行一层过滤，那么这时候就可以考虑使用 lazy='dynamic'。
lazy可用的选项：
1. 'select'：这个是默认选项。还是拿'user.articles'的例子来讲。如果你没有访问'user.articles'这个属性，那么sqlalchemy就不会从数据库中查找文章。一旦你访问了这个属性，那么sqlalchemy就会立马从数据库中查找所有的文章，并把查找出来的数据组装成一个列表返回。这也是懒加载。
2. 'dynamic'：就是在访问'user.articles'的时候返回回来的不是一个列表，而是'AppenderQuery'对象。

 注意：lazy要写在一对多的情况中"多"的那个relationship()里。

#encoding: utf-8
from sqlalchemy import create_engine,Column,Integer,Float,Boolean,DECIMAL,Enum,Date,DateTime,Time,String,Text,func,and_,or_,ForeignKey,Table
from sqlalchemy.dialects.mysql import LONGTEXT
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker,relationship,backref
from datetime import datetime
import time
import random
HOSTNAME = '127.0.0.1'
PORT = '3306'
DATABASE = 'first_sqlalchemy'
USERNAME = 'root'
PASSWORD = '123456'
# dialect+driver://username:password@host:port/database
DB_URI = "mysql+pymysql://{username}:{password}@{host}:{port}/{db}?charset=utf8mb4".format(username=USERNAME,password=PASSWORD,host=HOSTNAME,port=PORT,db=DATABASE)
engine = create_engine(DB_URI)
Base = declarative_base(engine)
session = sessionmaker(engine)()


class User(Base):
    __tablename__ = 'user1'
    id = Column(Integer, primary_key=True, autoincrement=True)
    username = Column(String(50),nullable=False)


class Article(Base):
    __tablename__ = 'article1'
    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("user1.id"))

    author = relationship("User",backref=backref("articles",lazy="dynamic"))

    def __repr__(self):
        return "<Article(title:%s)>" % self.title



def add_data():
    Base.metadata.drop_all()
    Base.metadata.create_all()
    user = User(username='wangyi')
    for i in range(1,21):
        article = Article(title="文章%s" %i)
        article.author = user
        session.add(article)
        time.sleep(1)
        session.commit()
# add_data()

user = session.query(User).first()
# user.articles是一个Query对象。
print(user.articles.filter(Article.id>10).order_by(Article.create_time.desc()).limit(2).all())
# 可以继续追加数据进去
article =Article(title='文章21')
user.articles.append(article)
session.commit()

article1表：

查询扩展

group_by,having

#encoding: utf-8
from sqlalchemy import create_engine,Column,Integer,Float,Boolean,DECIMAL,Enum,Date,DateTime,Time,String,Text,func,and_,or_,ForeignKey,Table
from sqlalchemy.dialects.mysql import LONGTEXT
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker,relationship,backref
# 在Python3中才有这个enum模块，在python2中没有
import enum
from datetime import datetime
import random
HOSTNAME = '127.0.0.1'
PORT = '3306'
DATABASE = 'first_sqlalchemy'
USERNAME = 'root'
PASSWORD = '123456'
# dialect+driver://username:password@host:port/database
DB_URI = "mysql+pymysql://{username}:{password}@{host}:{port}/{db}?charset=utf8mb4".format(username=USERNAME,password=PASSWORD,host=HOSTNAME,port=PORT,db=DATABASE)
engine = create_engine(DB_URI)
Base = declarative_base(engine)
session = sessionmaker(engine)()

class User(Base):
    __tablename__ = 'user2'
    id = Column(Integer,primary_key=True,autoincrement=True)
    username = Column(String(50),nullable=False)
    age = Column(Integer,default=0)
    gender = Column(Enum("male","female","secret"),default="male")

def add_data():
    Base.metadata.drop_all()
    Base.metadata.create_all()

    user1 = User(username='刘德华',age=18,gender='female')
    user2 = User(username='洪金宝',age=17,gender='female')
    user3 = User(username="成龙",age=19,gender='female')
    user4 = User(username="周润发",age=22,gender='female')
    user5 = User(username="甄子丹",age=15,gender='female')
    user6 = User(username="张曼玉",age=16,gender='male')
    user7 = User(username="王祖贤",age=17,gender='male')

    session.add_all([user1,user2,user3,user4,user5,user6,user7])
    session.commit()

# add_data()

# 每个年龄的人数
result = session.query(User.age,func.count(User.id)).group_by(User.age).having(User.age<18).all()
print(result)

join

假如有两张表：

 查询文章数最多的前两个用户的姓名、文章标题和具体文章数：

#encoding: utf-8
from sqlalchemy import create_engine,Column,Integer,Float,Boolean,DECIMAL,Enum,Date,DateTime,Time,String,Text,func,and_,or_,ForeignKey
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker,relationship,backref
from datetime import datetime
HOSTNAME = '127.0.0.1'
PORT = '3306'
DATABASE = 'first_sqlalchemy'
USERNAME = 'root'
PASSWORD = '123456'

# dialect+driver://username:password@host:port/database
DB_URI = "mysql+pymysql://{username}:{password}@{host}:{port}/{db}?charset=utf8mb4".format(username=USERNAME,password=PASSWORD,host=HOSTNAME,port=PORT,db=DATABASE)

engine = create_engine(DB_URI)
Base = declarative_base(engine)
session = sessionmaker(engine)()

class User(Base):
    __tablename__ = 'user3'
    id = Column(Integer,primary_key=True,autoincrement=True)
    username = Column(String(50),nullable=False)

class Article(Base):
    __tablename__ = 'article3'
    id = Column(Integer,primary_key=True,autoincrement=True)
    title = Column(String(50),nullable=False)
    uid = Column(Integer,ForeignKey('user3.id'))
    author = relationship("User",backref = "articles")

    def __repr__(self):
        return "<article{id:%s,title:%s}>"%(self.id,self.title)
# Base.metadata.drop_all()
# Base.metadata.create_all()
# user1 = User(username='wangyi')
# user2 = User(username='wenwen')
# user3 = User(username='yanyan')
# user4 = User(username='xian')
# article1 = Article(title="文章1")
# article2 = Article(title="文章2")
# article3 = Article(title="文章3")
# article4 = Article(title="文章4")
# article5 = Article(title="文章5")
# article6 = Article(title="文章6")
# user1.articles.append(article1)
# user1.articles.append(article2)
# user2.articles.append(article3)
# user2.articles.append(article4)
# user2.articles.append(article5)
# user3.articles.append(article6)
#
#
# session.add(user1)
# session.add(user2)
# session.add(user3)
# session.add(user4)
# session.commit()

# 查询文章数最多的前两个用户的姓名和文章标题：
result = session.query(User.username,func.group_concat(Article.title),func.count(Article.title)).outerjoin(Article,User.id==Article.uid).group_by(User.username).order_by(func.count(Article.title).desc()).limit(2).all()
print(result)

"""
sql语句：
SELECT user3.username AS user3_username, group_concat(article3.title) AS group_concat_1, count(article3.title) AS count_1 
FROM user3 LEFT OUTER JOIN article3 ON user3.id = article3.uid GROUP BY user3.username ORDER BY count(article3.title) DESC 
 LIMIT %(param_1)s
"""

子查询subquery

子查询可以让多个查询变成一个查询，只要查找一次数据库，性能相对来讲更加高效一点。不用写多个sql语句就可以实现一些复杂的查询。那么在sqlalchemy中，要实现一个子查询，应该使用以下几个步骤：
1. 将子查询按照传统的方式写好查询代码，然后在`query`对象后面执行`subquery`方法，将这个查询变成一个子查询。
2. 在子查询中，将以后需要用到的字段通过`label`方法，取个别名。
3. 在父查询中，如果想要使用子查询的字段，那么可以通过子查询的返回值上的`c`属性拿到。

#encoding: utf-8
from sqlalchemy import create_engine,Column,Integer,Float,Boolean,DECIMAL,Enum,Date,DateTime,Time,String,Text,func,and_,or_,ForeignKey,Table
from sqlalchemy.dialects.mysql import LONGTEXT
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker,relationship,backref
# 在Python3中才有这个enum模块，在python2中没有
import enum
from datetime import datetime
import random
HOSTNAME = '127.0.0.1'
PORT = '3306'
DATABASE = 'first_sqlalchemy'
USERNAME = 'root'
PASSWORD = '123456'
# dialect+driver://username:password@host:port/database
DB_URI = "mysql+pymysql://{username}:{password}@{host}:{port}/{db}?charset=utf8mb4".format(username=USERNAME,password=PASSWORD,host=HOSTNAME,port=PORT,db=DATABASE)

engine = create_engine(DB_URI)
Base = declarative_base(engine)
session = sessionmaker(engine)()

class User(Base):
    __tablename__ = 'user4'
    id = Column(Integer,primary_key=True,autoincrement=True)
    username = Column(String(50),nullable=False)
    city = Column(String(50),nullable=False)
    age =  Column(Integer,default=0)

    def __repr__(self):
        return "<User(username: %s)>" % self.username


Base.metadata.drop_all()
Base.metadata.create_all()

user1 = User(username='李A',city="长沙",age=18)
user2 = User(username='王B',city="长沙",age=18)
user3 = User(username='赵C',city="北京",age=18)
user4 = User(username='张D',city="长沙",age=20)

session.add_all([user1,user2,user3,user4])
session.commit()

# 婚恋
# 寻找和李A这个人在同一个城市，并且是同年龄的人
# user = session.query(User).filter(User.username=='李A').first()
# users = session.query(User).filter(User.city==user.city,User.age==user.age).all()
# print(users)

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()
print(result)

flask_sqlalchemy

flask_sqlalchemy是对SqlAlchemy的封装，使得其更适合于flask框架的应用。

from flask import Flask
from flask_sqlalchemy import SQLAlchemy
app = Flask(__name__)
HOSTNAME = '127.0.0.1'
PORT = '3306'
DATABASE = 'flask_sqlalchemy_demo'
USERNAME = 'root'
PASSWORD = '123456'
# dialect+driver://username:password@host:port/database
DB_URI = "mysql+pymysql://{username}:{password}@{host}:{port}/{db}?charset=utf8mb4".format(username=USERNAME,password=PASSWORD,host=HOSTNAME,port=PORT,db=DATABASE)
app.config['SQLALCHEMY_DATABASE_URI'] = DB_URI
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
db = SQLAlchemy(app)

class User(db.Model):
    __tablename__ = 'user'
    # 这个表名不写则默认使用模型类的小写名作为表名，驼峰则用_分开，如 UserModel——> user_model
    id = db.Column(db.Integer,primary_key=True,autoincrement=True)
    username = db.Column(db.String(50),nullable=False)
    def __repr__(self):
        return "<user(username:%s)>"%self.username

class Article(db.Model):
    __tablename__ = 'article'
    id = db.Column(db.Integer,primary_key=True,autoincrement=True)
    title = db.Column(db.String(50),nullable=False)
    uid = db.Column(db.Integer,db.ForeignKey('user.id'))
    author = db.relationship("User",backref = "articles")

# db.drop_all()
# db.create_all()
def add_data():

    user1 = User(username="wangyi")
    user2 = User(username="wenwen")
    article1 = Article(title="文章1")
    article2 = Article(title="文章2")
    article1.author = user1
    article2.author = user2
    db.session.add(article1)
    db.session.add(article2)
    db.session.commit()
# add_data()

# 单表查询
# users = User.query.order_by(User.id.desc()).all()
# print(users)

# 改
# user = User.query.filter(User.username=='wenwen').first()
# user.username = "yanyan"
# db.session.commit()

# 删
# user = User.query.filter(User.username=='wenwen').first()
# db.session.delete(user)
# db.session.commit()

@app.route('/')
def hello_world():
    return 'Hello World!'


if __name__ == '__main__':
    app.run()