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 val

scoped_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)

 

posted @ 2022-10-12 16:56  不会钓鱼的猫  阅读(304)  评论(0编辑  收藏  举报