SQLAlchemy
1 介绍
SQLAlchemy是一个基于Python实现的ORM框架。该框架建立在 DB API之上，使用对象关系映射进行数据库操作，简言之便是：将类和对象转换成SQL，然后使用数据API执行SQL并获取执行结果。django ORM只能django中使用，SQLAlchemy可以单独使用，我们可以把它集成到Flask框架中。
安装 pip3 install sqlalchemy
组成部分：
- Engine，框架的引擎
- Connection Pooling ，数据库连接池
- Dialect，选择连接数据库的DB API种类（MySQL, oracle...）
- Schema/Types，架构和类型
- SQL Exprression Language，SQL表达式语言
SQLAlchemy本身无法操作数据库，其必须依赖pymsql等第三方插件，Dialect用于和数据API进行交流，根据配置文件的不同调用不同的数据库API，从而实现对数据库的操作，如：
MySQL-Python
mysql+mysqldb://<user>:<password>@<host>[:<port>]/<dbname>
pymysql
mysql+pymysql://<username>:<password>@<host>/<dbname>[?<options>]
MySQL-Connector
mysql+mysqlconnector://<user>:<password>@<host>[:<port>]/<dbname>
cx_Oracle
oracle+cx_oracle://user:pass@host:port/dbname[?key=value&key=value...]
更多：http://docs.sqlalchemy.org/en/latest/dialects/index.html补充：django中如何反向生成models
python manage.py inspectdb > app/models.py
2 简单使用
SQLAlchemy能创建表、删除表，不能修改表(不支持修改字段)。django ORM直接在model中修改/添加字段，执行数据库迁移命令。
SQLAlchemy如何修改表？先在数据库添加字段(不推荐这样操作)，再去model中对应的修改/添加字段。
2.1 执行原生SQL语句
跟pymysql使用基本一致，但SQLAlchemy自动维护了数据库连接池，不需要利用DButils模块自己维护数据库连接池。
import time
import threading
import sqlalchemy
from sqlalchemy import create_engine
from sqlalchemy.engine.base import Engine
# 第一步 生成一个engine对象
engine = create_engine(
"mysql+pymysql://root:123@127.0.0.1:3306/t1?charset=utf8", #连接的库是t1，这里的utf8是MySQL自己设计的编码方式，跟字符编码utf-8不是一个东西
max_overflow=0, # 超过连接池大小外最多创建的连接
pool_size=5, # 连接池大小
pool_timeout=30, # 池中没有线程，最多等待的时间，否则报错
pool_recycle=-1 # 多久之后对线程池中的线程进行一次连接的回收，-1表示不回收（重置），为了防止内存溢出，可以设置回收
)
def task(arg):
# 创建连接(raw_connection原生连接，表示执行原生sql)
conn = engine.raw_connection()
# 拿到游标对象
cursor = conn.cursor()
# 具体操作
cursor.execute(
"select * from users"
)
result = cursor.fetchall()
cursor.close()
conn.close()
for i in range(20):
t = threading.Thread(target=task, args=(i,))
t.start()2.2 ORM使用
models.py 单表的创建与删除
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 #字段和字段属性，字段统一用Column类，在Column类中再指定字段属性(类型)
Base = declarative_base() #造了一个类，用这个类作为所有模型类的基类，相当于django ORM的models.Model类
class Users(Base):
__tablename__ = 'users' #数据库表名，如果不写，默认以类名小写作为表名，django ORM是在Meta中给表取名
id = Column(Integer, primary_key=True) #id 主键, mysql中主键自动建索引(聚簇索引)，其他键建的索引叫辅助索引
name = Column(String(32), index=True, nullable=False) #name 字符类型maxlenth=32, 索引，不能为空
email = Column(String(32), unique=True) #email 唯一则不能为空
ctime = Column(DateTime, default=datetime.datetime.now) #ctime default默认值
extra = Column(Text, nullable=True)
#类似于django ORM的class Meta
__table_args__ = (
UniqueConstraint('id', 'name', name='uix_id_name'), #id和name字段，联合唯一
Index('uix_id_name', 'name', 'email'), #再给id和name字段建索引
)
def init_db():
"""
根据类创建数据库表
:return:
"""
# 创建engine对象
engine = create_engine(
"mysql+pymysql://root:123@127.0.0.1:3306/test?charset=utf8",
max_overflow=0, # 超过连接池大小外最多创建的连接
pool_size=5, # 连接池大小
pool_timeout=30, # 池中没有线程最多等待的时间，否则报错
pool_recycle=-1 # 多久之后对线程池中的线程进行一次连接的回收（重置）
)
# 通过engine对象创建表，创建出被Base管理的所有表
Base.metadata.create_all(engine)
def drop_db():
"""
根据类删除数据库表
:return:
"""
# 创建engine对象
engine = create_engine(
"mysql+pymysql://root:123@127.0.0.1:3306/s6?charset=utf8",
max_overflow=0, # 超过连接池大小外最多创建的连接
pool_size=5, # 连接池大小
pool_timeout=30, # 池中没有线程最多等待的时间，否则报错
pool_recycle=-1 # 多久之后对线程池中的线程进行一次连接的回收（重置）
)
# 通过engine对象删除表，删除被Base管理的所有表
Base.metadata.drop_all(engine)
if __name__ == '__main__':
drop_db()
init_db()models.py 多表的创建与删除
1 #!/usr/bin/env python
2 # -*- coding:utf-8 -*-
3 import datetime
4 from sqlalchemy import create_engine
5 from sqlalchemy.ext.declarative import declarative_base
6 from sqlalchemy import Column, Integer, String, Text, ForeignKey, DateTime, UniqueConstraint, Index
7 from sqlalchemy.orm import relationship
8
9 Base = declarative_base()
10
11
12 # ##################### 单表示例 #########################
13 class Users(Base):
14 __tablename__ = 'users'
15
16 id = Column(Integer, primary_key=True)
17 name = Column(String(32), index=True)
18 age = Column(Integer, default=18)
19 email = Column(String(32), unique=True)
20 ctime = Column(DateTime, default=datetime.datetime.now)
21 extra = Column(Text, nullable=True)
22
23 __table_args__ = (
24 # UniqueConstraint('id', 'name', name='uix_id_name'),
25 # Index('ix_id_name', 'name', 'extra'),
26 )
27
28
29 class Hosts(Base):
30 __tablename__ = 'hosts'
31
32 id = Column(Integer, primary_key=True)
33 name = Column(String(32), index=True)
34 ctime = Column(DateTime, default=datetime.datetime.now)
35
36
37 # ##################### 一对多示例 #########################
# 一个Hobby对应多个Person， 一个Person只能有一个Hobby
38 class Hobby(Base):
39 __tablename__ = 'hobby'
40 id = Column(Integer, primary_key=True)
41 caption = Column(String(50), default='篮球')
42
43
44 class Person(Base):
45 __tablename__ = 'person'
46 nid = Column(Integer, primary_key=True)
47 name = Column(String(32), index=True, nullable=True)
# 一对多，外键字段在多的一方，hobby指的是__tablename__，不是类名
48 hobby_id = Column(Integer, ForeignKey("hobby.id"))
49
50 # 与生成表结构无关，不会新增字段，仅用于查询方便(快速连表操作)
# 正向查 person.hobby 反向查 hobby.pers (pers是多的一方，查出放列表)
51 hobby = relationship("Hobby", backref='pers')
52
53
54 # ##################### 多对多示例 #########################
55 # 跟django ORM多对多自动创建虚拟的第三张表不同，SQLAlchemy是实实在在的第三张关系表，必须手动创建关联
56 class Server2Group(Base):
57 __tablename__ = 'server2group'
58 id = Column(Integer, primary_key=True, autoincrement=True) # autoincrement字段默认为True，自增
59 server_id = Column(Integer, ForeignKey('server.id'))
60 group_id = Column(Integer, ForeignKey('group.id'))
61
62
63 class Group(Base):
64 __tablename__ = 'group'
65 id = Column(Integer, primary_key=True)
66 name = Column(String(64), unique=True, nullable=False)
67
68 # 与生成表结构无关，仅用于查询方便，放在哪个表中都可以
# secondary表示通过哪个表建关联，相当于django ORM中through的用法
69 servers = relationship('Server', secondary='server2group', backref='groups')
70
71
72 class Server(Base):
73 __tablename__ = 'server'
74
75 id = Column(Integer, primary_key=True, autoincrement=True)
76 hostname = Column(String(64), unique=True, nullable=False)
77
78
79 def init_db():
80 """
81 根据类创建数据库表
82 :return:
83 """
84 engine = create_engine(
85 "mysql+pymysql://root:123@127.0.0.1:3306/test?charset=utf8",
86 max_overflow=0, # 超过连接池大小外最多创建的连接
87 pool_size=5, # 连接池大小
88 pool_timeout=30, # 池中没有线程最多等待的时间，否则报错
89 pool_recycle=-1 # 多久之后对线程池中的线程进行一次连接的回收（重置）
90 )
91
92 Base.metadata.create_all(engine)
93
94
95 def drop_db():
96 """
97 根据类删除数据库表
98 :return:
99 """
100 engine = create_engine(
101 "mysql+pymysql://root:123@127.0.0.1:3306/test?charset=utf8",
102 max_overflow=0, # 超过连接池大小外最多创建的连接
103 pool_size=5, # 连接池大小
104 pool_timeout=30, # 池中没有线程最多等待的时间，否则报错
105 pool_recycle=-1 # 多久之后对线程池中的线程进行一次连接的回收（重置）
106 )
107
108 Base.metadata.drop_all(engine)
109
110
111 if __name__ == '__main__':
112 drop_db()
113 init_db()app.py 操作数据库表
from sqlalchemy.orm import sessionmaker
from sqlalchemy import create_engine
from models import Users
# 创建engine对象
engine = create_engine("mysql+pymysql://root:123@127.0.0.1:3306/test", max_overflow=0, pool_size=5)
# 创建一个Session类(会话)
Session = sessionmaker(bind=engine)
# 每次执行数据库操作时，都需要实例化得到一个session对象
session = Session()
# 执行ORM操作
obj1 = Users(name="alex1") # 创建一个对象
session.add(obj1) # 把对象保存到数据库
session.commit() # 提交事务
session.close() # 关闭session，将连接放回连接池SQLAlchemy操作数据库集成到flask框架中，有两种使用方式：
1、把session对象做成单例（放到一个文件中，其他文件通过导入使用），flask所有请求(每个请求都是一个线程)共用一个session对象，性能低；
2、每次实例化得到一个session对象进行数据库操作，来100万个请求，就要生成100万个session对象；
SQLAlchemy内部通过scoped_session帮你实现线程安全
from sqlalchemy.orm import sessionmaker
from sqlalchemy import create_engine
from models import Users
from sqlalchemy.orm import scoped_session
engine = create_engine("mysql+pymysql://root:123@127.0.0.1:3306/test", max_overflow=0, pool_size=5)
Session = sessionmaker(bind=engine)
session = scoped_session(Session) # 得到一个线程安全的session对象，以后再用的session就是全局变量
#session = Session()
# 执行ORM操作
obj1 = Users(name="alex1") # 创建一个对象
session.add(obj1) # 把对象保存到数据库
session.commit() # 提交事务
session.close() # 关闭session，将连接放回连接池实现线程安全的几种方式：1、加锁； 2、Queue对象传递数据；3、threading_local对象
scoped_session类实现线程安全就是利用的threading_local对象，我们简单看一下scoped_session类的源码：
class scoped_session(ScopedSessionMixin):
_support_async = False
session_factory = None
def __init__(self, session_factory, scopefunc=None): # 实例化时传入了Session类，即session_factory参数
self.session_factory = session_factory
if scopefunc:
self.registry = ScopedRegistry(session_factory, scopefunc)
else:
self.registry = ThreadLocalRegistry(session_factory) # ThreadLocalRegistry类实例化，得到一个对象class ThreadLocalRegistry(ScopedRegistry):
def __init__(self, createfunc):
self.createfunc = createfunc # createfunc就是，我们传入的Session类
self.registry = threading.local() # 生成一个local对象
def __call__(self):
try:
return self.registry.value
except AttributeError:
val = self.registry.value = self.createfunc() # 调用Session类，得到原始的session对象，放到local中，每次调用时，都从自己的线程中拿到session
return valscoped_session是一个类，它没有继承Session类的绑定方法，而是通过反射把这些方法放进去，因此实例化得到的对象可以使用session对象的方法
orm 基本增删查改
from sqlalchemy.orm import sessionmaker, relationship
from sqlalchemy.orm import scoped_session
from sqlalchemy import create_engine
from sqlalchemy.sql import text
from db import Users, Hosts, Person
engine = create_engine("mysql+pymysql://root:123@127.0.0.1:3306/s6", max_overflow=0, pool_size=5)
Session = sessionmaker(bind=engine)
session = scoped_session(Session)
# ################ 添加 ################
obj1 = Users(name="lqz") # 插入单条数据
session.add(obj1)
session.add_all([ # 批量插入数据，同一个对象插入多条数据，或不同对象同时插入数据
Users(name="wupeiqi"),
Users(name="alex"),
Hosts(name="c1.com"), # Hosts类，ctime字段有默认值，可以只传name字段
Person(name="egon") # Person类，有一个hobby_id外键字段，默认可以为空，不传该字段不会报错，跟django ORM外键字段有区别
])
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: : "099"})
# 类似于django ORM的F查询，在原字段上修改
session.query(Users).filter(Users.id > 0).update({Users.name: Users.name + "099"}, synchronize_session=False) # 把Users.name转成字符串相加
session.query(Users).filter(Users.id > 0).update({"age": Users.age + 1}, synchronize_session="evaluate") # 把Users.age转成数字相加
session.commit()
# ################ 查询 ################
# query(Users)查出的是对象，相当于select *， query(Users.id, Users.name)可以查具体的字段
r1 = session.query(Users).all() # 查所有，即使一个对象也放在列表中
r2 = session.query(Users).first() # 查一个,从列表中取第一个对象
r3 = session.query(Users.name.label('xx'), Users.age).all() # 只取age列，把name字段重命名为'xx'
# filter传的是表达式，filter_by传的是参数
r4 = session.query(Users).filter(Users.name == "alex").all()
r5 = session.query(Users).filter(Users.id >= 1).first()
r6 = session.query(Users).filter_by(Users.name='alex').all()
r7 = session.query(Users).filter_by(Users.id=2).first()
# value和name相当于占位符，用params传参
r8 = session.query(Users).filter(text("id<:value and name=:name")).params(value=224, name='fred').order_by(Users.id).all()
# 自定制SQL语句，原生SQL直接转成对象
r9 = session.query(Users).from_statement(text("SELECT * FROM users where name=:name")).params(name='fred').all()
session.close()
3 高级使用
orm 高级查询
# 条件
ret = session.query(Users).filter_by(name='alex').all()
# 表达式，and连接条件
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()
# in是关键字，所以用in_
ret = session.query(Users).filter(Users.id.in_([1,3,4])).all()
# ~取反
ret = session.query(Users).filter(~Users.id.in_([1,3,4])).all()
# 二次筛选，相当于原生sql的子查询
ret = session.query(Users).filter(Users.id.in_(session.query(Users.id).filter_by(name='eric'))).all()
# or_包裹的是or条件(相当于django ORM的Q查询)， and_包裹的是and条件(and条件也可以直接逗号隔开写)
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()
"""
select * from users where id<2 or (name='egon' and id>3) or extra!='';
"""
# 通配符，模糊匹配
ret = session.query(Users).filter(Users.name.like('e%')).all() #以‘e’开头
ret = session.query(Users).filter(~Users.name.like('e%')).all() #取反
# 限制，用于分页，前闭后开区间(顾头不顾尾)
ret = session.query(Users)[1:3]
"""
select * from users limit 1,2;
"""
# 排序
ret = session.query(Users).order_by(Users.name.desc()).all() # 根据name降序排序
ret = session.query(Users).order_by(Users.name.asc()).all() # 根据name升序排序
ret = session.query(Users).order_by(Users.name.desc(), Users.id.asc()).all() # 按name降序排序，name重复的再按id升序排序
# 分组
from sqlalchemy.sql import func
ret = session.query(Users).group_by(Users.extra).all() # 按extra字段分组
# 分组之后，要查询的字段只能是分组字段(Users.name)和聚合函数聚合出来的字段,最大id，最小id，id总和
ret = session.query(
func.max(Users.id),
func.sum(Users.id),
func.min(Users.id),
Users.name).group_by(Users.name).all()
"""
select max(id),sum(id),min(id) from users group_by name;
"""
# 分组后再筛选，having
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()
"""
原生sql
select max(id),sum(id),min(id) from users group_by name having min(id) >2;
"""
# 基于连表的跨表查询
# 默认情况根据外键字段连表
# isouter=True 左外连接，表示person left join hobby, Person与Hobby反转就是右连接
# 把person和hobby连表，查出来列表套元组，元组里面一个Person对象，一个Hobby对象
ret = session.query(Person, Hobby).join(Hobby, isouter=True).all()
"""
select * from person left join hobby on person.hobby_id=hobby.id;
"""
ret = session.query(Person, Hobby).filter(Person.hobby_id == Hobby.id).all() # 跟上例等价，并且可以指定连表的关联字段
"""
select * from person,hobby where person.hobby_id=hobby.id;
"""
# isouter默认False 内连接
ret = session.query(Person).join(Hobby).all()
"""
select * from person inner join hobby on person.hobby_id=hobby.id;
"""
# 组合,取结果的并集
# union: 对两个结果集进行并集操作, 不包括重复行,相当于distinct, 同时进行默认规则的排序
# union: 对两个结果集进行并集操作, 不包括重复行,相当于distinct, 同时进行默认规则的排序
q1 = session.query(Users.name).filter(Users.id > 2)
q2 = session.query(Hobby.caption).filter(Hobby.id < 3)
ret1 = q1.union(q2).all()
ret2 = q1.union_all(q2).all()基于relationship操作ForeignKey
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, Hobby, Person
engine = create_engine("mysql+pymysql://root:123@127.0.0.1:3306/s6?charset=utf8", max_overflow=0, pool_size=5)
Session = sessionmaker(bind=engine)
session = Session()
# 一对多添加数据
# 方式1:
# 单条插入
obj1 = Hobby(caption='足球')
session.add(obj1)
obj2 = Person(name='张三', hobby_id=2)
session.add(obj2)
# 批量插入
session.add_all([
Hobby(caption='乒乓球'),
Hobby(caption='羽毛球'),
Person(name='张三', hobby_id=3),
Person(name='李四', hobby_id=4),
])
# 方式2：默认情况下，直接传对象有问题
# 但是，如果Person类中，建了以下字段就没问题
# hobby = relationship("Hobby", backref='pers')
person = Person(name='李四', hobby=Hobby(caption='美女')) ===》等价于 person = Person(name='李四')
session.add(person) person.hobby = Hobby(caption='美女'))
session.add(person)
# 方式3：通过反向操作，前提同样是Person类中有 hobby = relationship("Hobby", backref='pers')字段
hb = Hobby(caption='人妖')
hb.pers = [Person(name='文飞'), Person(name='博雅')]
session.add(hb)
session.commit()
# 使用relationship正向查询(基于对象的跨表查询)
p = session.query(Person).filter_by(name='张三').first()
print(p) # 查出person对象
print(p.hobby.caption) # 跨表查出hobby对象
# 使用relationship反向查询
hb = session.query(Hobby).filter_by(cpation='美女').first()
print(hb) # 查出hobby对象
print(hb.pers) # 跨表查出person对象
session.close()基于relationship操作m2m(多对多关系)
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, Hobby, Person, Group, Server, Server2Group
engine = create_engine("mysql+pymysql://root:123@127.0.0.1:3306/s6?charset=utf8", max_overflow=0, pool_size=5)
Session = sessionmaker(bind=engine)
session = Session()
# 添加
# 方式1
session.add_all([
Server(hostname='c1.com'),
Server(hostname='c2.com'),
Group(name='A组'),
Group(name='B组'),
])
session.commit()
session.add_all([
Server2Group(server_id=1, group_id=1),
Server2Group(server_id=2, group_id=1),
])
session.commit()
# 方式2 使用relationship
gp = Group(name='C组') # 添加group对象
gp.servers = [Server(hostname='c3.com'),Server(hostname='c4.com')] # 正向查询servers字段，添加多个server对象
session.add(gp)
session.commit()
ser = Server(hostname='c6.com') # 添加
ser.groups = [Group(name='F组'),Group(name='G组')] # 反向查询groups字段，添加多个group对象
session.add(ser)
session.commit()
# 基于对象的跨表查询
# 使用relationship正向查询
gp = session.query(Group).filter_by(id=3).first()
print(gp.servers)
# 使用relationship反向查询
ser = session.query(Server).filter_by(id=3).first()
print(ser.groups)
# 基于连表的跨表查询
# 查询hostname='c3.com'的所有group的名字
# 方式1
ret = session.query(Group.name).filter(Server.id==Server2Group.server_id, Group.id==Server2Group.group_id, Server.hostname=='c3.com').all()
"""
select group.name from group,server,server2group where server.id=server2group.server_id and group.id=server2group.group_id and server.hostname=='c3.com';
"""
# 方式2
ret = session.query(Group.name).join(server2group).join(server).filter(Server.hostname=='c3.com').all()
"""
select group.name from group inner join server2group on group.id=server2group.group_id inner join server on server.id=server2group.server_id where server.hostname=='c3.com';
"""
"""
session.close()执行原生sql语句
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()
# 添加：注意value传值时多了一个冒号
cursor = session.execute('insert into users(name) values(:value)',params={"value":'egon'})
session.commit()
print(cursor.lastrowid) # 打印最后一个id
session.close()SQLAlchemy-Utils
由于sqlalchemy中没有提供choice方法，所以借助SQLAlchemy-Utils组件提供的choice方法
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
from sqlalchemy_utils import ChoiceType
Base = declarative_base()
class Xuan(Base):
__tablename__ = 'xuan'
types_choices = (
(1,'欧美'),
(2,'日韩'),
(3,'老男孩'),
)
id = Column(Integer,primary_key=True,autoincrement=True)
name = Column(String(64))
types = Column(ChoiceType(types_choices,Integer()))
__table_args__ = {
'mysql_engine':'Innodb',
'mysql_charset':'utf8',
}
engine = create_engine(
"mysql+pymysql://root:123@127.0.0.1:3306/test2?charset=utf8",
max_overflow=0, # 超过连接池大小外最多创建的连接
pool_size=5, # 连接池大小
pool_timeout=30, # 池中没有线程最多等待的时间，否则报错
pool_recycle=-1 # 多久之后对线程池中的线程进行一次连接的回收（重置）
)
Base.metadata.create_all(engine)
查询：
result_list = session.query(Xuan).all()
for item in result_list:
print(item.types.code, item.types.value)
