55-sqlalchemy
一. 介绍
SQLAlchemy是一个基于Python实现的ORM框架。该框架建立在 DB API之上，使用关系对象映射进行数据库操作，简言之便是：将类和对象转换成SQL，然后使用数据API执行SQL并获取执行结果。
pip3 install sqlalchemy
组成部分：
- Engine，框架的引擎
- Connection Pooling ，数据库连接池
- Dialect，选择连接数据库的DB API种类
- 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
二. 使用
1. 执行原生SQL语句
import time
import threading
import sqlalchemy
from sqlalchemy import create_engine
from sqlalchemy.engine.base import Engine
engine = create_engine(
"mysql+pymysql://root:123@127.0.0.1:3306/t1?charset=utf8",
max_overflow=0, # 超过连接池大小外最多创建的连接
pool_size=5, # 连接池大小
pool_timeout=30, # 池中没有线程最多等待的时间，否则报错
pool_recycle=-1 # 多久之后对线程池中的线程进行一次连接的回收（重置）
)
def task(arg):
conn = engine.raw_connection()
cursor = conn.cursor()
cursor.execute(
"select * from t1"
)
result = cursor.fetchall()
cursor.close()
conn.close()
for i in range(20):
t = threading.Thread(target=task, args=(i,))
t.start()
#!/usr/bin/env python # -*- coding:utf-8 -*- import time import threading import sqlalchemy from sqlalchemy import create_engine from sqlalchemy.engine.base import Engine engine = create_engine("mysql+pymysql://root:123@127.0.0.1:3306/t1", max_overflow=0, pool_size=5) def task(arg): conn = engine.contextual_connect() with conn: cur = conn.execute( "select * from t1" ) result = cur.fetchall() print(result) for i in range(20): t = threading.Thread(target=task, args=(i,)) t.start()
#!/usr/bin/env python # -*- coding:utf-8 -*- import time import threading import sqlalchemy from sqlalchemy import create_engine from sqlalchemy.engine.base import Engine from sqlalchemy.engine.result import ResultProxy engine = create_engine("mysql+pymysql://root:123@127.0.0.1:3306/t1", max_overflow=0, pool_size=5) def task(arg): cur = engine.execute("select * from t1") result = cur.fetchall() cur.close() print(result) for i in range(20): t = threading.Thread(target=task, args=(i,)) t.start()
注意: 查看连接 show status like 'Threads%';
2. ORM
a. 创建数据库表
创建单表
#!/usr/bin/env python # -*- coding:utf-8 -*- 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 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) __table_args__ = ( # UniqueConstraint('id', 'name', name='uix_id_name'), # Index('ix_id_name', 'name', 'email'), ) def init_db(): """ 根据类创建数据库表 :return: """ 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 # 多久之后对线程池中的线程进行一次连接的回收（重置） ) Base.metadata.create_all(engine) def drop_db(): """ 根据类删除数据库表 :return: """ 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 # 多久之后对线程池中的线程进行一次连接的回收（重置） ) Base.metadata.drop_all(engine) if __name__ == '__main__': drop_db() init_db()
创建多个表并包含Fk、M2M关系
#!/usr/bin/env python # -*- coding:utf-8 -*- 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 Base = declarative_base() # ##################### 单表示例 ######################### class Users(Base): __tablename__ = 'users' id = Column(Integer, primary_key=True) name = Column(String(32), index=True) age = Column(Integer, default=18) email = Column(String(32), unique=True) ctime = Column(DateTime, default=datetime.datetime.now) extra = Column(Text, nullable=True) __table_args__ = ( # UniqueConstraint('id', 'name', name='uix_id_name'), # Index('ix_id_name', 'name', 'extra'), ) class Hosts(Base): __tablename__ = 'hosts' id = Column(Integer, primary_key=True) name = Column(String(32), index=True) ctime = Column(DateTime, default=datetime.datetime.now) # ##################### 一对多示例 ######################### class Hobby(Base): __tablename__ = 'hobby' id = Column(Integer, primary_key=True) caption = Column(String(50), default='篮球') class Person(Base): __tablename__ = 'person' nid = Column(Integer, primary_key=True) name = Column(String(32), index=True, nullable=True) hobby_id = Column(Integer, ForeignKey("hobby.id")) # 与生成表结构无关，仅用于查询方便 hobby = relationship("Hobby", backref='pers') # ##################### 多对多示例 ######################### class Server2Group(Base): __tablename__ = 'server2group' id = Column(Integer, primary_key=True, autoincrement=True) server_id = Column(Integer, ForeignKey('server.id')) group_id = Column(Integer, ForeignKey('group.id')) class Group(Base): __tablename__ = 'group' id = Column(Integer, primary_key=True) name = Column(String(64), unique=True, nullable=False) # 与生成表结构无关，仅用于查询方便 servers = relationship('Server', secondary='server2group', backref='groups') class Server(Base): __tablename__ = 'server' id = Column(Integer, primary_key=True, autoincrement=True) hostname = Column(String(64), unique=True, nullable=False) def init_db(): """ 根据类创建数据库表 :return: """ 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 # 多久之后对线程池中的线程进行一次连接的回收（重置） ) Base.metadata.create_all(engine) def drop_db(): """ 根据类删除数据库表 :return: """ 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 # 多久之后对线程池中的线程进行一次连接的回收（重置） ) Base.metadata.drop_all(engine) if __name__ == '__main__': drop_db() init_db()
指定关联列：hobby = relationship("Hobby", backref='pers',foreign_keys="Person.hobby_id")
b. 操作数据库表
#!/usr/bin/env python
# -*- coding:utf-8 -*-
from sqlalchemy.orm import sessionmaker
from sqlalchemy import create_engine
from models import Users
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 = Session()
# ############# 执行ORM操作 #############
obj1 = Users(name="alex1")
session.add(obj1)
# 提交事务
session.commit()
# 关闭session
session.close()
基于scoped_session实现线程安全
#!/usr/bin/env python # -*- coding:utf-8 -*- from sqlalchemy.orm import sessionmaker from sqlalchemy import create_engine from sqlalchemy.orm import scoped_session from models import Users 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中的一下方法： public_methods = ( '__contains__', '__iter__', 'add', 'add_all', 'begin', 'begin_nested', 'close', 'commit', 'connection', 'delete', 'execute', 'expire', 'expire_all', 'expunge', 'expunge_all', 'flush', 'get_bind', 'is_modified', 'bulk_save_objects', 'bulk_insert_mappings', 'bulk_update_mappings', 'merge', 'query', 'refresh', 'rollback', 'scalar' ) """ session = scoped_session(Session) # ############# 执行ORM操作 ############# obj1 = Users(name="alex1") session.add(obj1) # 提交事务 session.commit() # 关闭session session.close()
多线程执行示例
#!/usr/bin/env python
# -*- coding:utf-8 -*-
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 db import Users
engine = create_engine("mysql+pymysql://root:123@127.0.0.1:3306/s6", max_overflow=0, pool_size=5)
Session = sessionmaker(bind=engine)
def task(arg):
session = Session()
obj1 = Users(name="alex1")
session.add(obj1)
session.commit()
for i in range(10):
t = threading.Thread(target=task, args=(i,))
t.start()
基本增删改查示例
#!/usr/bin/env python
# -*- coding:utf-8 -*-
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 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()
# ################ 添加 ################
"""
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()
"""
# ################ 查询 ################
"""
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()
"""
session.close()
常用操作
# 条件
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()
ret = session.query(Person).join(Favor, isouter=True).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语句
#!/usr/bin/env python
# -*- coding:utf-8 -*-
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()
基于relationship操作ForeignKey
#!/usr/bin/env python
# -*- coding:utf-8 -*-
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, 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()
# 添加
"""
session.add_all([
Hobby(caption='乒乓球'),
Hobby(caption='羽毛球'),
Person(name='张三', hobby_id=3),
Person(name='李四', hobby_id=4),
])
person = Person(name='张九', hobby=Hobby(caption='姑娘'))
session.add(person)
hb = Hobby(caption='人妖')
hb.pers = [Person(name='文飞'), Person(name='博雅')]
session.add(hb)
session.commit()
"""
# 使用relationship正向查询
"""
v = session.query(Person).first()
print(v.name)
print(v.hobby.caption)
"""
# 使用relationship反向查询
"""
v = session.query(Hobby).first()
print(v.caption)
print(v.pers)
"""
session.close()
基于relationship操作m2m
#!/usr/bin/env python
# -*- coding:utf-8 -*-
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, 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()
# 添加
"""
session.add_all([
Server(hostname='c1.com'),
Server(hostname='c2.com'),
Group(name='A组'),
Group(name='B组'),
])
session.commit()
s2g = Server2Group(server_id=1, group_id=1)
session.add(s2g)
session.commit()
gp = Group(name='C组')
gp.servers = [Server(hostname='c3.com'),Server(hostname='c4.com')]
session.add(gp)
session.commit()
ser = Server(hostname='c6.com')
ser.groups = [Group(name='F组'),Group(name='G组')]
session.add(ser)
session.commit()
"""
# 使用relationship正向查询
"""
v = session.query(Group).first()
print(v.name)
print(v.servers)
"""
# 使用relationship反向查询
"""
v = session.query(Server).first()
print(v.hostname)
print(v.groups)
"""
session.close()
其他
#!/usr/bin/env python
# -*- coding:utf-8 -*-
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, func
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()
# 关联子查询
subqry = session.query(func.count(Server.id).label("sid")).filter(Server.id == Group.id).correlate(Group).as_scalar()
result = session.query(Group.name, subqry)
"""
SELECT `group`.name AS group_name, (SELECT count(server.id) AS sid
FROM server
WHERE server.id = `group`.id) AS anon_1
FROM `group`
"""
# 原生SQL
"""
# 查询
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()
课堂笔记
面试：原生SQL和ORM比较？
执行速度：
- 原生SQL速度快 -> 直接数据库执行
- ORM -> 转换成SQL -> 数据库执行
开发速度：
- ORM
5. SQLAlchemy
安装：
pip3 install SQLAlchemy
依赖：
pymysql
使用SQLAlchemy:
- 部分功能：
- 使用它的数据库连接池的功能
- 全部功能：
- 表操作
- 创建单表
- 数据行操作
- 基本操作：
from sqlalchemy.orm import sessionmaker
from sqlalchemy import create_engine
from s2 import Users
engine = create_engine("mysql+pymysql://root:apNXgF6RDitFtDQx@192.168.11.38:3306/m2day03db?charset=utf8", max_overflow=0, pool_size=5)
SessionClass = sessionmaker(bind=engine)
# 每次执行数据库操作时，都需要创建一个session
session = SessionClass()
# ############# 添加 #############
# obj = Users(name="alex")
# session.add(obj)
# 提交事务
# session.commit()
# ############# 查询 #############
# result = session.query(Users).all()
# for row in result:
# print(row.id,row.name)
# result = session.query(Users).filter(Users.id > 1)
# for row in result:
# print(row.id,row.name)
# ############# 删除 #############
# session.query(Users).filter(Users.id > 1).delete()
# session.commit()
# ############# 修改 #############
# session.query(Users).filter(Users.id > 0).update({'name':'型谱'})
# session.commit()
# 关闭session
session.close()
6. flask-sqlalchemy组件
总结：
1. WebSocket(*)
- 握手
- 加密
2. Flask中实现WebSocket功能
- gevent-websocket
3. pymysql操作数据
4. 数据库连接池 ：DBUtils (*)
- 每个线程创建一个连接
- 连接池
PS: sql_helper.py 保留
5. SQLAlchemy,ORM框架。(*)
6. Flask-SQLAlchemy (*)
使用SQLAlchemy的数据库连接池的功能 & 游标操作示例
import time import threading import sqlalchemy from sqlalchemy import create_engine from sqlalchemy.engine.base import Engine engine = create_engine( "mysql+pymysql://root:apNXgF6RDitFtDQx@192.168.11.38:3306/m2day03db?charset=utf8", max_overflow=5, # 超过连接池大小外最多创建的连接 pool_size=1, # 连接池大小 pool_timeout=30, # 池中没有线程最多等待的时间，否则报错 pool_recycle=-1 # 多久之后对线程池中的线程进行一次连接的回收（重置） ) def task(arg): conn = engine.raw_connection() cursor = conn.cursor() # cursor.execute("select * from user",[]) cursor.execute("select sleep(3)") result = cursor.fetchall() cursor.close() conn.close() print(result) for i in range(20): t = threading.Thread(target=task, args=(i,)) t.start()
基于Session执行原生SQL
import time import threading import sqlalchemy from sqlalchemy import create_engine from sqlalchemy.orm import sessionmaker from sqlalchemy.engine.base import Engine engine = create_engine( "mysql+pymysql://root:apNXgF6RDitFtDQx@192.168.11.38:3306/m2day03db?charset=utf8", max_overflow=5, # 超过连接池大小外最多创建的连接 pool_size=1, # 连接池大小 pool_timeout=30, # 池中没有线程最多等待的时间，否则报错 pool_recycle=-1 # 多久之后对线程池中的线程进行一次连接的回收（重置） ) # 基于Session执行原生SQL （*******） 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()
表操作-创建单表示例
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 Base = declarative_base() class Users(Base): __tablename__ = 'users' id = Column(Integer, primary_key=True) name = Column(String(32), index=True, nullable=False) if __name__ == '__main__': engine = create_engine( "mysql+pymysql://root:apNXgF6RDitFtDQx@192.168.11.38:3306/m2day03db?charset=utf8", max_overflow=0, # 超过连接池大小外最多创建的连接 pool_size=5, # 连接池大小 pool_timeout=30, # 池中没有线程最多等待的时间，否则报错 pool_recycle=-1 # 多久之后对线程池中的线程进行一次连接的回收（重置） ) # Base.metadata.create_all(engine) # Base.metadata.drop_all(engine)
SQLAlchemy数据行基本操作
from sqlalchemy.orm import sessionmaker from sqlalchemy import create_engine from s2 import Users engine = create_engine("mysql+pymysql://root:apNXgF6RDitFtDQx@192.168.11.38:3306/m2day03db?charset=utf8", max_overflow=0, pool_size=5) SessionClass = sessionmaker(bind=engine) # 每次执行数据库操作时，都需要创建一个session session = SessionClass() # ############# 添加 ############# # obj = Users(name="alex") # session.add(obj) # 提交事务 # session.commit() # ############# 查询 ############# # result = session.query(Users).all() # for row in result: # print(row.id,row.name) # result = session.query(Users).filter(Users.id > 1) # for row in result: # print(row.id,row.name) # ############# 删除 ############# # session.query(Users).filter(Users.id > 1).delete() # session.commit() # ############# 修改 ############# # session.query(Users).filter(Users.id > 0).update({'name':'型谱'}) # session.commit() # 关闭session session.close()
单表和一对多示例
#!/usr/bin/env python # -*- coding:utf-8 -*- 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 Base = declarative_base() # ##################### 单表示例 ######################### class Users(Base): __tablename__ = 'users' id = Column(Integer, primary_key=True) name = Column(String(32), index=True) age = Column(Integer, default=18) email = Column(String(32), unique=True) ctime = Column(DateTime, default=datetime.datetime.now) ##这里不能加括号，如果加括号则执行一次，如果不加括号是可执行的，会在创建的时候自动执行 extra = Column(Text, nullable=True) __table_args__ = ( # 联合唯一索引 # UniqueConstraint('name', 'email', name='uix_id_name'), # 联合索引 # Index('ix_id_name', 'name', 'email'), ) class Hosts(Base): __tablename__ = 'hosts' id = Column(Integer, primary_key=True) name = Column(String(32), index=True) ctime = Column(DateTime, default=datetime.datetime.now) # ##################### 一对多示例 ######################### class PersonType(Base): __tablename__ = 'persontype' id = Column(Integer, primary_key=True) caption = Column(String(50), default='普通用户') class Person(Base): __tablename__ = 'person' nid = Column(Integer, primary_key=True) name = Column(String(32), index=True, nullable=True) type_id = Column(Integer, ForeignKey("persontype.id")) #persontype.id 这里是表名 # 与生成表结构无关，仅用于查询方便 ptype = relationship("PersonType", backref='pers') def init_db(): """ 根据类创建数据库表 :return: """ engine = create_engine( "mysql+pymysql://root:apNXgF6RDitFtDQx@192.168.11.38:3306/m2day03db?charset=utf8", max_overflow=0, # 超过连接池大小外最多创建的连接 pool_size=5, # 连接池大小 pool_timeout=30, # 池中没有线程最多等待的时间，否则报错 pool_recycle=-1 # 多久之后对线程池中的线程进行一次连接的回收（重置） ) Base.metadata.create_all(engine) def drop_db(): """ 根据类删除数据库表 :return: """ engine = create_engine( "mysql+pymysql://root:apNXgF6RDitFtDQx@192.168.11.38:3306/m2day03db?charset=utf8", max_overflow=0, # 超过连接池大小外最多创建的连接 pool_size=5, # 连接池大小 pool_timeout=30, # 池中没有线程最多等待的时间，否则报错 pool_recycle=-1 # 多久之后对线程池中的线程进行一次连接的回收（重置） ) Base.metadata.drop_all(engine) if __name__ == '__main__': drop_db() init_db()
一对多查询条件操作示例
from sqlalchemy.orm import sessionmaker from sqlalchemy import create_engine from s4 import Person,PersonType engine = create_engine("mysql+pymysql://root:apNXgF6RDitFtDQx@192.168.11.38:3306/m2day03db?charset=utf8", max_overflow=0, pool_size=5) SessionClass = sessionmaker(bind=engine) # 每次执行数据库操作时，都需要创建一个session session = SessionClass() # ############# 添加 ############# """ session.add_all([ PersonType(caption="普通用户"), PersonType(caption="超级用户"), PersonType(caption="SVIP用户"), ]) """ """ session.add_all([ Person(name="李杰",type_id=1), Person(name="征集文",type_id=1), Person(name="兴普",type_id=2), ]) """ """ obj = session.query(PersonType).filter(PersonType.id==2).first() session.add_all([ Person(name="李杰1",ptype=obj), Person(name="征集文1",ptype=obj), Person(name="兴普1",ptype=obj), ]) """ """ obj = Person(name='宏伟',ptype=PersonType(caption="VVIP")) session.add(obj) """ # session.commit() # ############# 查询 ############# # 查询所有用户，并打印姓名 # obj_list = session.query(Person).all() # for obj in obj_list: # print(obj.name) # 查询所有用户，并打印姓名+用户类型名称 # obj_list = session.query(Person).all() # for obj in obj_list: # print(obj.name,obj.type_id,obj.ptype.caption) # 查询所有用户，并打印姓名+用户类型名称 # result = session.query(Person.nid,Person.name.label('nnn'),PersonType.caption).join(PersonType,Person.type_id==PersonType.id,isouter=True).all() # for row in result: # print(row.nnn,row.caption) # 找到属于某个用户类型的所有人。 # obj = session.query(PersonType).filter(PersonType.id == 2).first() # print(obj.id) # print(obj.caption) # print(obj.pers) # result = session.query(Person).filter(Person.type_id == 2).all() # print(result) # 关闭session session.close()
多对多建表示例
#!/usr/bin/env python # -*- coding:utf-8 -*- 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 Base = declarative_base() # ##################### 多对多示例 ######################### class Server2Depart(Base): __tablename__ = 'server2depart' id = Column(Integer, primary_key=True, autoincrement=True) server_id = Column(Integer, ForeignKey('server.id')) depart_id = Column(Integer, ForeignKey('depart.id')) __table_args__ = ( # 联合唯一索引 UniqueConstraint('server_id', 'depart_id', name='uix_depart_server'), ) class Depart(Base): __tablename__ = 'depart' id = Column(Integer, primary_key=True) name = Column(String(64), unique=True, nullable=False) # 与生成表结构无关，仅用于查询方便 servers = relationship('Server', secondary='server2depart', backref='departs') class Server(Base): __tablename__ = 'server' id = Column(Integer, primary_key=True, autoincrement=True) hostname = Column(String(64), unique=True, nullable=False) if __name__ == '__main__': engine = create_engine( "mysql+pymysql://root:apNXgF6RDitFtDQx@192.168.11.38:3306/m2day03db?charset=utf8", max_overflow=0, # 超过连接池大小外最多创建的连接 pool_size=5, # 连接池大小 pool_timeout=30, # 池中没有线程最多等待的时间，否则报错 pool_recycle=-1 # 多久之后对线程池中的线程进行一次连接的回收（重置） ) Base.metadata.create_all(engine)
多对多添加查询示例
from sqlalchemy.orm import sessionmaker from sqlalchemy import create_engine from s6 import Depart, Server, Server2Depart engine = create_engine("mysql+pymysql://root:apNXgF6RDitFtDQx@192.168.11.38:3306/m2day03db?charset=utf8", max_overflow=0, pool_size=5) SessionClass = sessionmaker(bind=engine) # 每次执行数据库操作时，都需要创建一个session session = SessionClass() # ############# 添加 ############# # session.add_all([ # Depart(name='IT'), # Depart(name='测试'), # Depart(name='运维'), # Server(hostname='c1.com'), # Server(hostname='c2.com'), # Server(hostname='c3.com'), # Server(hostname='c4.com'), # Server(hostname='c5.com'), # # ]) # session.add_all([ # Server2Depart(server_id=1,depart_id=1), # Server2Depart(server_id=1,depart_id=2), # Server2Depart(server_id=1,depart_id=3), # Server2Depart(server_id=2,depart_id=1), # Server2Depart(server_id=2,depart_id=2), # ]) # 问题：创建一个部门，为补充新增3个主机 # d1 = Depart(name='运营') # d1.servers = [Server(hostname='c6.com'),Server(hostname='c7.com'),Server(hostname='c8.com'),] # session.add(d1) # # session.commit() # ############# 查询 ############# # 运营部都有哪些机器？ # result = session.query(Server2Depart.id, Depart.name, Server.hostname).join(Depart, Server2Depart.depart_id == Depart.id, # isouter=True).join(Server, # Server2Depart.server_id == Server.id, # isouter=True).filter(Depart.name=='运营').all() # for item in result: # print(item) # obj = session.query(Depart).filter(Depart.name=='运营').first() # for s in obj.servers: # print(s.id,s.hostname) # c1.com 都给哪些部门使用了？ # obj = session.query(Server).filter(Server.hostname=='c1.com').first() # for d in obj.departs: # print(d.id,d.name) # 关闭session session.close()
数据库连接相关
""" 连接相关 """ import threading from sqlalchemy.orm import sessionmaker from sqlalchemy import create_engine engine = create_engine("mysql+pymysql://root:apNXgF6RDitFtDQx@192.168.11.38:3306/m2day03db?charset=utf8", max_overflow=0, pool_size=5) SessionClass = sessionmaker(bind=engine) # 每次执行数据库操作时，都需要创建一个session def task(): # 从数据库连接池获取一个连接。 session = SessionClass() # 查询 cursor = session.execute('select sleep(3)') result = cursor.fetchall() session.close() print(result) for i in range(20): t = threading.Thread(target=task) t.start()
使用scoped_session
""" 连接相关 """ import threading from sqlalchemy.orm import sessionmaker from sqlalchemy import create_engine from sqlalchemy.orm import scoped_session engine = create_engine("mysql+pymysql://root:apNXgF6RDitFtDQx@192.168.11.38:3306/m2day03db?charset=utf8", max_overflow=0, pool_size=5) SessionClass = sessionmaker(bind=engine) # 创建的scoped_session Session对象 # 当线程去调用 # session.query() # session.add # session.add_all # scoped_session内部会为每个线程创建一个新的Session对象，让他来使用。 session = scoped_session(SessionClass) def task(): # 查询 cursor = session.execute('select sleep(3)') result = cursor.fetchall() session.remove() print(result) for i in range(20): t = threading.Thread(target=task) t.start()
笔记
sqlaclmy 不能连接数据库和执行语句，需借助DBAPI 比如pymysql、mysqldb sqlaclmy 内部实现了连接池 dialect 决定了用哪个DBAPI sqlaclemy 本身不能修改表比如增加列，如果要做的话：插件或者修改数据库并修改modles中的列 线程池：dbutils 或者sqlalchemy 创建一对多的多的时候要用type.id ,如果用对象呢？创建relationship字段 需求：创建用户同时新增用户类型 join默认会根据foreign添加条件 .label 是给列取别名 默认是inner join isouter =True 是left join，right join颠倒表的位置即可 没有加.all() .first()显示的就是sql语句 s6 many-to-many 第三张表需手工创建 开启了s6中的secondry 问题：创建一个部门.... 这样的效果，自动在第三张表中创建了关系 直接修改 字符串拼接 数字运算 filter(表达式) == 可以加多个表达式 逗号表示and filter_by(参数) = id<:value 冒号是占位符，加个text表示是个sql语句，后面的param是占位符的实际内容 r7不常用，r1-r6的本质就是r7类似 ~ 表示取反 in_(可以是子查询) and_ 默认就是and关系 or_ 可嵌套 %任意个字符 _ 一个字符 union 表上下连接，不保留重复的 unionall 表上下连接保留重复的 多线程的时候，为每个线程创建一个session（相当于是每个线程使用一个数据库连接） 或者使用scoped——session，这样不用每个线程创建session了，最后session.remove，（内部机制为每个线程创建一个session） db.session 就类似scoped_session
在flask中使用sql-a lchemy示例
account.py
from flask import Blueprint from cmdb import db from cmdb import models ac = Blueprint('ac',__name__) @ac.route('/login') def login(): result = db.session.query(models.UserInfo).all() print(result) db.session.remove() return "login" @ac.route('/logout') def logout(): return "logout"
home.py
from flask import Blueprint hm = Blueprint('hm',__name__) @hm.route('/index') def index(): return "index"
__init__.py
from flask import Flask from flask_sqlalchemy import SQLAlchemy # 1. 创建flask_sqlalchemy对象 db = SQLAlchemy() from .models import * from .views import account from .views import home def create_app(): app = Flask(__name__) app.config.from_object('settings.Dev') app.register_blueprint(account.ac) app.register_blueprint(home.hm) # 2. 初始化 db.init_app(app) return app
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 from cmdb import db class UserInfo(db.Model): __tablename__ = 'userinfo' id = Column(Integer, primary_key=True) name = Column(String(32), index=True, nullable=False)
create_table.py
from cmdb import db from manage import app with app.app_context(): db.create_all() # db.drop_all()
manage.py
from cmdb import create_app app = create_app() if __name__ == '__main__': app.run()
settings.py
class Base(object): SECRET_KEY = "asdfasdf" SQLALCHEMY_DATABASE_URI = "mysql+pymysql://root:apNXgF6RDitFtDQx@192.168.11.38:3306/m2day03db?charset=utf8" SQLALCHEMY_POOL_SIZE = 5 # 追踪对象的修改并且发送信号 SQLALCHEMY_TRACK_MODIFICATIONS = False class Dev(Base): pass
以上示例见如下附件
https://files.cnblogs.com/files/robinunix/cmdb.tar.gz
参考
SqlAlcmy http://www.cnblogs.com/wupeiqi/articles/8259356.html
做有积累的事~~
浙公网安备 33010602011771号