正文
python2.0_s12_day11_SqlAlchemy使用介绍
提示：扫一扫查出行【扫一扫了解最新限行尾号】
复制提示
SqlAlchemy ORM
ORM的解释;
简单点:对象关系映射.
需求:我们写一个主机管理,把主机信息存在数据库,一开始我们编程不熟练的时候,执行命令时候要调用数据库,会把相应的SQL语句写到代码中,这种叫做hard coding(硬生生的代码),那么随着程序越来越复杂我们要写的sql语句也越来越多,那么代码中就会出现很多原生的sql语句通过调用数据API(如pymysql,mysql-python)来操作数据库.
并且好多原生的语句是不能重用的,你会发现你在程序的好多地方调用了重复的sql语句.当然,聪明的我们会想到,把这些重复的sql语句,写成函数.但是问题在于你在机在开始开发程序的时候,你没有办法完全预料到所有的操作场景,也就是说没办法预料到要用到什么样的sql语句.所以你还会在实际编程中写很多原生的SQL语句(写死了),并且不能重用.
另外开发人员写出来的sql语句肯定有一些低效率的语句,必定不是专业的DBA.并且如果涉及到多个表查询和做分类的聚合,sql语句如果不优化效率就非常低,所以一般的情况下,DBA会把复杂的sql语句封装成存储过程,让程序员调用.
但是还是有问题,假如现在把存储过程写到代码里,你们公司说我们要把mysql换成oracle,程序员傻逼了,程序里面好多原生的sql和存储过程调用,mysql和oracle语法有很多不一样的地方,那么怎么搞,只能全部重写掉sql语句.
你可能说,我写代码的时候会要求自己写成封装,但是一个项目好多人参与,其他人你能要求,但是万一他在快离职的时候就写一些原生的sql语句,你能怎样,不可控.而且对于个人来说,你封装的sql语句也仅限于当前使用的数据库类型,如果像上面提到的mysql切换成oracle,你就要该封装程序了.
总之,这种方式不可控,而且复杂,完了,这个问题按照自己写代码解决的思路不能解决了.当然我们花上1~3个月来写一个sql的封装的程序,那么我告诉你,可以,你写的就是类似ORM框架的东西,而且90%的可能性,你写的没有SqlAlchemy好.
所以我们最明智的做法是了解SqlAlchemy框架,并且熟练使用他. 下面我们来了解SqlAlchemy是怎么真正的帮我们实现的.
SQLAlcchemy是Python编程语言下的一款ORM框架,该框架建立在数据库API之上,使用关系对象映射进行数据库操作,简而言之:将对象转化成SQL,然后使用数据API执行SQL并获取执行结果
之前我们学过数据库的API如mysqldb-python直接写sql原生语句,sqlalchemy是建立在数据库API之上,对原生sql语句进行了封装,也就是说你用了sqlalchemy之后,你就不用写sql语句了,你不用写了,这就隔离了.你看看单独这一点就把前面我们遇到的在代码中写原生sql语句的问题解决了,因为你不用写sql语句了嘛.
那你会说代码中原生sql代码的问题解决了,那如何解决从mysql切换到oracle呢?接下来的dialect会根据你配置的不同的数据库类型来调用sqlalchemy内部定义的对于不同数据库类型的api接口.至于你担心的我之前调用的是mysql,现在是oracle的问题,sqlalchemy内部在实例化engine时,根据你连接的数据库类型来选择封装成什么类型的sql原生语句.
紧接着你会问支持多少种数据类型.往下看
(我个人理解的思路是我们知道mysql也好oracle也好,使用的语法会有些不同,那sqlalchemy就像一个中间件,源头是mysql或者oracle又或者是其他的数据库,经过sqlalchemy那么一封装,变成了对于python来说统一的调用模式.就那么简单)
对上图的具体解释:
SQLALchemy ORM: 就是它的ORM,是对象封装的过程,它把sql语句封装成对象了,他这个对象是怎么封装的?不是说一连上sqlalchemy,就把数据库里所有的东西都封装了,而是你自己要声明,我要把这个表封装成什么对象,把那个表封装成什么对象.整个过程 1.先把原生的表映射成类.2.然后才能通过对象的形势调用它.
schema/Types: 你怎么进行对象关系映射?定义了一种映射格式,就是说你要把这个表映射成这个类,就通过这个框架格式
SQL Expression Language:增删改查的SQL封装语句.
Engine: 封装后你需要通过一个引擎操作它
connection pooling:连接池
Dialect:根据你的配置文件,连接不同的数据库
DBAPI:具体的API,mysql api或者oracle api
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
案例一：
使用 Engine/ConnectionPooling/Dialect 进行数据库操作，Engine使用ConnectionPooling连接数据库，然后再通过Dialect执行SQL语句。
#!/usr/bin/env python
# -*- coding:utf- -*- from sqlalchemy import create_engine engine = create_engine("mysql+mysqldb://root:123@127.0.0.1:3306/s11", max_overflow=) engine.execute(
"INSERT INTO ts_test (a, b) VALUES ('2', 'v1')"
) engine.execute(
"INSERT INTO ts_test (a, b) VALUES (%s, %s)",
((, "v1"),(, "v1"),)
)
engine.execute(
"INSERT INTO ts_test (a, b) VALUES (%(id)s, %(name)s)",
id=, name="v1"
) result = engine.execute('select * from ts_test')
result.fetchall()
总结：使用sqlalchemy可以像使用数据库api一样直接调用原生代码。这种方式没有什么意义，我们只需要知道可以这么做即可。
步骤二sqlalchemy使用的中间状态： 使用 Schema Type/SQL Expression Language/Engine/ConnectionPooling/Dialect 进行数据库操作。
Engine使用Schema Type创建一个特定的结构对象，之后通过SQL Expression Language将该对象转换成SQL语句，然后通过 ConnectionPooling 连接数据库，再然后通过 Dialect 执行SQL，并获取结果。
#!/usr/bin/env python3.
#__author__:'ted.zhou'
'''
sqlalchemy 的用法案例
使用 Schema Type/SQL Expression Language/Engine/ConnectionPooling/Dialect 进行数据库操作
'''
#!/usr/bin/env python
# -*- coding:utf- -*- from sqlalchemy import create_engine, Table, Column, Integer, String, MetaData, ForeignKey
# 老师:MetaData需要理解下,就是在创建类时,sqlalchemy在MetaData里封装了好多的关于这个类的一些属性.包括怎么把Column,Integer,String,Table等等,转成相应的语句.
# 网络上资料解释: MetaData是元数据,元数据就是描述数据的数据,比如小明 身高:175cm,身高就是元数据,175cm就是实际数据.而在sqlalchemy里的MetaData实例化一个对象,就是一个元数据对象,里面具体的元数据有表名Table,列名Column,以及怎么把Column,Integer,String,Table等等,转成相应的语句方法名称.
# 总之,元数据必须有
metadata = MetaData() # 实例化一个属性对象
user = Table('user', metadata, # 实例化一个Table,并和metadata进行绑定.这些表的信息都属于metadata里的.
Column('id', Integer, primary_key=True),
Column('name', String()),
) color = Table('color', metadata,
Column('id', Integer, primary_key=True),
Column('name', String()),
)
# engine = create_engine("mysql+mysqldb://root:123.com@localhost:3306/test", max_overflow=) engine = create_engine("mysql+pymysql://root:123456@localhost:3307/test",max_overflow=,echo=True) # 创建一个连接引擎
# create_engine("数据库类型+数据库驱动://数据库用户名:数据库密码@IP地址:端口/数据库"，其他参数)
# 上文当中echo=True是开启调试，这样当我们执行文件的时候会提示相应的文字。 metadata.create_all(engine)
#
# 这一步的具体执行内容就是下面说的.
# Engine使用Schema Type创建一个特定的结构对象，之后通过SQL Expression Language将该对象转换成SQL语句，然后通过 ConnectionPooling 连接数据库，再然后通过 Dialect 执行SQL，并获取结果。
步骤二sqlalchemy使用的中间状态的增删改查语法：
（建议只参考下，不需要记住，因为我们最终不会使用这种状态）
#!/usr/bin/env python
# -*- coding:utf- -*- from sqlalchemy import create_engine, Table, Column, Integer, String, MetaData, ForeignKey metadata = MetaData() # 实例化元数据对象
# 创建表结构,我个人的理解是这里的创建相当于在python的sqlalchemy中虚拟一个表结构,如果数据库中有相应的表,那么不会在数据库中创建,如果实际数据库中没有,那么需要通过metadata.create_all(engine)来创建,可参见案例一
# 所以可知,创建表结构有两个功能:.不紧可以声明元数据 .而且可以用来在数据库中创建表.
user = Table('user', metadata, Column('id', Integer, primary_key=True),
Column('name', String()),
) color = Table('color', metadata,
Column('id', Integer, primary_key=True),
Column('name', String()),
) # 实例化引擎,只是把连接信息作为参数传入,并未真的连接,要真的连接需要调用connect方法
engine = create_engine("mysql+pymysql://root:123456@127.0.0.1:3307/test",echo=True) conn = engine.connect() # 引擎执行connect()方法,连接到数据库,获取到光标(游标) # 创建SQL语句，INSERT INTO "user" (id, name) VALUES (:id, :name)
conn.execute(user.insert(),{'id':,'name':'seven'}) # 这里我们之所以可以使用user.insert()进行数据插入,而不用写原生sql,是因为我们前面做了将user变量加入到了元数据实例metadata中,这样metadata才知道怎样将user.insert这段代码转化成对应的存储引擎的sql语句
# 所以说metadata必须加
conn.close() # 插入
# sql = user.insert().values(id=, name='wu') # user表
# conn.execute(sql)
# conn.close() # 删除
# sql = user.delete().where(user.c.id > ) # user.c.id # 改
# sql = user.update().values(fullname=user.c.name)
# sql = user.update().where(user.c.name == 'jack').values(name='ed') # 查询,查询和上面的插入,删除,改不一样,他使用单独的select方法,不需要像user.select,原因是查询的时候有时候会进行外连接,不是只针对一个表进行的.所以从实际出发sqlalchemy模块中有一个单独的select方法
# sql = select([user, ]) # 查询所有
# sql = select([user.c.id, ]) # 查字段
# sql = select([user.c.name, color.c.name]).where(user.c.id==color.c.id) # 查字段,设置where条件
# sql = select([user.c.name]).order_by(user.c.name) # 查名称,排序
# sql = select([user]).group_by(user.c.name) # 分组统计 # 执行查询
# result = conn.execute(sql)
# print result.fetchall() #
# conn.close()
接下来，我们就看看实际编程中我们使用sqlalchemy的终极状态案例：
SqlAlchemy完整的例子(简单)_用法的终极状态.py
#!/usr/bin/env python3.
#__author__:ted.zhou
import pymysql
from sqlalchemy import create_engine # 导入引擎类
from sqlalchemy.ext.declarative import declarative_base # 导入sqlalchemy的一个扩展模块declarative_base,此模块调用返回一个封装好的 metadata元数据和表名以及表字段 的类.注意返回的是个类,不是实例.
from sqlalchemy import Column,Integer,String # 导入和创建表结构相关的模块
from sqlalchemy.orm import sessionmaker # 导入sessionmaker模块,它自己是一个类,实例化它返回的还是一个类(是一个包含了数据库API信息和连接地址端口以及用户名和密码信息的类)不是一个实例
# 这句话的意思,拿到数据库API(传入的bind=engine参数作中记录了数据库的API和连接信息),创建一个连接的类.这个类里有连接信息,和数据库API信息,接下来要创建一个连接session就要实例化这个类 '''
使用sqlalchemy ORM完成对数据库的操作整个代码实现过程,可以理解成如下:
.如果想用sqlalchemy来操作数据库中的表,就需要把数据库的表结构映射成SqlORM类,这里请注意,一个SqlORM类实际上操作数据库的单位不是库,而是表,因为连接的时候直接选择到库.
.把表结构映射出去后,sqlalchemy内部需要一个内部映射的规则比如表名怎么映射,字段怎么映射,String类型怎么映射,Integer怎么映射,删除怎么搞等等,也就是前面说的元数据metadata ,元数据和映射后的表结构绑定后,就可以操作这张表(增删改查).
这里是使用declarative_base模块将前两步需要做的事情封装到一个类中.然后下面要创建的SqlORM子类就要继承这个基类了. 封装了映射方法和元数据方法的模块就是declarative_base
.上面两部完成后是只是说可以对映射的数据表进行操作了,但是操作是在本地的,你需要通过连接把SqlORM中的操作最终翻译成对应数据库类型的原生SQL语句,在调用数据库API进行操作. 那么这个引擎的实现模块就是create_engine
那么这个连接信息我们称之为引擎.
.引擎相当于一个连接工具,那么谁来使用这个引擎来对数据进行操作呢? 那就是session,session通过引擎调用一系列映射后的表的操作方法,然后翻译成原生SQL后调用数据库API.最终完成对数据库的操作.这个实现session的模块即是sessionmaker
''' Base = declarative_base() #生成一个SqlORM基类,接下来所有要创建的SqlORM的子类(理解成如果想用sqlalchemy来操作数据库中的表,就需要把数据库的表结构映射成SqlORM类) # 实例化引擎,只是把连接信息作为参数传入,并未真的连接.
engine = create_engine("mysql+pymysql://root:123456@127.0.0.1:3307/test",echo=True) # echo=True可以显示转化后的原生SQL语句执行过程 class Host(Base): # 定义一个SqlORM类,继承Base类这样他就默认绑定了matedata和数据结构
__tablename__ = 'hosts' # 声明表名
id = Column(Integer,primary_key=True,autoincrement=True,nullable=False) # 声明字段id,类型为int,为主键,自增长属性为真
hostname = Column(String(),unique=True,nullable=False) # 声明字段hostname,类型为String,是否唯一限制为True,是否可为空False
ip_addr = Column(String(),unique=True,nullable=False)
port = Column(Integer,default=) # 创建表结构方法
Base.metadata.create_all(engine) # 通过引擎engine,SqlORM基类 调用metadata中的create_all方法,这样远程数据库中如果存在子类中的表则不做动作,如果不存在则添加.如果存表名但是字段不一样也不做操作. if __name__ == '__main__':
SessionCls = sessionmaker(bind=engine) #创建与数据库的会话session class ,注意,这里返回给session的是个class,不是实例,也就意味着一切连接都就绪了,就查你点连接了
session = SessionCls() # 实例化一个连接huihua
'''
# 增加纪录
h1 = Host(hostname='localhost',ip_addr='127.0.0.1') # 使用前面定义好SqlORM类Host,实例化一个对象,此对象包含了转换原生sql语句的规范.
h2 = Host(hostname='ubuntu',ip_addr='10.0.0.1',port=)
h3 = Host(hostname='ubuntu2',ip_addr='192.168.2.244',port=)
session.add(h3) # 可以一条一条添加
session.add_all([h1,h2]) # 也可以一次添加多条
#h2.hostname = 'ubuntu_test' # 只要没提交,此时修改也没问题
#session.rollback() # 撤销
session.commit() # 最后要提交.
''' '''
# 更改纪录 (更改纪录首先要查询到这条纪录,然后在进行更改)
res = session.query(Host).filter(Host.id == ).first() # 调用session.query(查哪个sqlORM类).fitler(查询条件).first(取几行),res为返回的是一条纪录
# res = session.query(Host).filter(Host.hostname == 'ubuntu' ).first() # 调用session.query(查哪个sqlORM类).fitler(查询条件).all()取所有
# res = session.query(Host.hostname,Host.id).filter(Host.hostname == 'ubuntu' ).first() # 查询指定字段
print("++>",res,res.hostname)
res.hostname = 'test server' # 直接更改,
session.commit() # 然后提交
''' # 删除操作(删除纪录,先获取对象,然后在删除)
res = session.query(Host).filter(Host.hostname.like('%ubuntu%')).all() # 调用session.query获取纪录对象结果集
print("------------>",res[].hostname,res[].hostname) session.delete(res[])
# print("------------>22",res[].hostname,res[].hostname)
# session.commit()
sqlalchemy简单例子
SqlAlchemy完整的例子(一对多外键联接1)_用法终极状态
1.首先1对多外联，必须创建外键
#!/usr/bin/env python3.
#__author__:ted.zhou
import pymysql
from sqlalchemy import create_engine
from sqlalchemy.ext.declarative import declarative_base # 注意返回的是个类,不是实例.
from sqlalchemy import Column,Integer,String,ForeignKey
from sqlalchemy.orm import sessionmaker # 导入sessionmaker模块,它自己是一个类,实例化它返回的还是一个类(是一个包含了数据库API信息和连接地址端口以及用户名和密码信息的类)不是一个实例
from sqlalchemy.orm import relationship Base = declarative_base() #生成一个SqlORM基类,接下来所有要创建的SqlORM的子类(理解成如果想用sqlalchemy来操作数据库中的表,就需要把数据库的表结构映射成SqlORM类) # 实例化引擎,只是把连接信息作为参数传入,并未真的连接.
engine = create_engine("mysql+pymysql://root:123456@127.0.0.1:3307/test",echo=True) # echo=True可以显示转化后的原生SQL语句执行过程 class Host(Base): # 定义一个SqlORM类,继承Base类这样他就默认绑定了matedata和数据结构
__tablename__ = 'hosts' # 声明表名
id = Column(Integer,primary_key=True,autoincrement=True,nullable=False) # 声明字段id,类型为int,为主键,自增长属性为真
hostname = Column(String(),unique=True,nullable=False) # 声明字段hostname,类型为String,是否唯一限制为True,是否可为空False
ip_addr = Column(String(),unique=True,nullable=False)
port = Column(Integer,default=)
groupid = Column(Integer,ForeignKey('group.id')) # 添加一个字段,并设置此字段类型为外键.
# 使用ForeignKey设置外键时注意亮点:
# 1. ForeignKey需要从SqlAlchemy中导入 from sqlalchemy import ForeignKey
# 2. ForeignKey(参数),参数是实实在在的表名,而不是封装了的SqlAlchemy 的ORM类名
'''
执行时原生语句的内容如下:
CREATE TABLE hosts (
id INTEGER NOT NULL AUTO_INCREMENT,
hostname VARCHAR() NOT NULL,
ip_addr VARCHAR() NOT NULL,
port INTEGER,
groupid INTEGER,
PRIMARY KEY (id),
UNIQUE (hostname),
UNIQUE (ip_addr),
FOREIGN KEY(groupid) REFERENCES `group` (id) # 这里就是设置外键的语句,可以参考记住
)
'''
class Group(Base):
__tablename__ = 'group' # 定义表名
id = Column(Integer,primary_key=True,autoincrement=True,nullable=False)
groupname = Column(String(),unique=True,nullable=False) Base.metadata.create_all(engine) # 通过引擎engine,SqlORM基类 调用metadata中的create_all方法,这样远程数据库中如果存在子类中的表则不做动作,如果不存在则添加.如果存表名但是字段不一样也不做操作. if __name__ == '__main__':
SessionCls = sessionmaker(bind=engine) #创建与数据库的会话session class ,注意,这里返回给session的是个class,不是实例,也就意味着一切连接都就绪了,就查你点连接了
session = SessionCls() # 实例化一个连接huihua
'''
# 先创建一个组
g1 = Group(groupname='g1')
g2 = Group(groupname='g2')
g3 = Group(groupname='g3')
session.add_all([g1,g2,g3])
# 创建
h1 = Host(hostname='linux1',ip_addr='10.0.0.1',port='',groupid=g1.id)
h2 = Host(hostname='ubuntu1',ip_addr='10.0.0.2',port='')
session.add_all([h1,h2])
session.commit() 我们在这一连串的代码中实现了,添加组,然后创建主机,设置h1的groupid = g1.id
但是结果是 h1的groupid最终加到数据库中的值为NULL,为什么?
原因是 你虽然在映射后的sqlalchemy的orm类实例化了g1,但是在数据库表中没有,并且你在实例化g1时,没有直接指定g1.id值,所以接下来h1实例化的时候取不到g1.id的值
那么问题来了,如果我在实例化g1的时候指定了id的值能不能成功呢.当然实际应用中自增长字段是 不会自己指定值的,但这里测试.我猜测是可以的.下面我们做这个测试. ''' '''
# 测试
g4 = Group(id=,groupname='g4')
h3 = Host(hostname='ubuntu2',ip_addr='10.0.0.3',port=)
h4 = Host(hostname='linux2',ip_addr='10.0.0.4',port=,groupid=g4.id)
session.add_all([g4,h3,h4])
session.commit()
# 执行结果:
# mysql> select * from hosts;
# +----+----------+----------+------+---------+
# | id | hostname | ip_addr | port | groupid |
# +----+----------+----------+------+---------+
# | | linux1 | 10.0.0.1 | | NULL |
# | | ubuntu1 | 10.0.0.2 | | NULL |
# | | ubuntu2 | 10.0.0.3 | | NULL |
# | | linux2 | 10.0.0.4 | | |
# +----+----------+----------+------+---------+
# rows in set (0.00 sec)
# 所以上面上面的判断是正确的
'''
上面的例子就是在Host中添加了一个groupid外键到Group.id。
'''
接下来,我想知道id=4的host所属组的组名,怎么获取?
h = session.query(Host).filter(Host.id == ).first()
print('+++++++++++++++>',h.groupname) # 打印h.groupname
# 结果: AttributeError: 'Host' object has no attribute 'groupname'
说明直接调用是不行的,那么怎样才能获得groupname呢?
答案:要用到关联查询了,要导入relationship不是relationships,也就是说你希望在Host类里,通过什么字段就可以掉用到groupname,
于是在class Host类中加入: group = relationship('Group')这里的参数是类,而不是表名.说明通过反射的方法,把Group实例嵌到Host实例中的group字段中.这个时候就可以使用group.groupname获得名称了.
代码改成如下：
SqlAlchemy完整的例子(一对多外键联接)2_用法终极状态：
#!/usr/bin/env python3.
#__author__:ted.zhou
import pymysql
from sqlalchemy import create_engine # 导入引擎类
from sqlalchemy.ext.declarative import declarative_base # 导入sqlalchemy的一个扩展模块declarative_base,此模块调用返回一个封装好的 metadata元数据和表名以及表字段 的类.注意返回的是个类,不是实例.
from sqlalchemy import Column,Integer,String,ForeignKey # 导入和创建表结构相关的模块
from sqlalchemy.orm import sessionmaker # 导入sessionmaker模块,它自己是一个类,实例化它返回的还是一个类(是一个包含了数据库API信息和连接地址端口以及用户名和密码信息的类)不是一个实例
# 这句话的意思,拿到数据库API(传入的bind=engine参数作中记录了数据库的API和连接信息),创建一个连接的类.这个类里有连接信息,和数据库API信息,接下来要创建一个连接session就要实例化这个类
from sqlalchemy.orm import relationship # 导入ralationship模块 Base = declarative_base() #生成一个SqlORM基类,接下来所有要创建的SqlORM的子类(理解成如果想用sqlalchemy来操作数据库中的表,就需要把数据库的表结构映射成SqlORM类) # 实例化引擎,只是把连接信息作为参数传入,并未真的连接.
engine = create_engine("mysql+pymysql://root:123456@127.0.0.1:3307/test",echo=True) # echo=True可以显示转化后的原生SQL语句执行过程 class Host(Base): # 定义一个SqlORM类,继承Base类这样他就默认绑定了matedata和数据结构
__tablename__ = 'hosts' # 声明表名
id = Column(Integer,primary_key=True,autoincrement=True,nullable=False) # 声明字段id,类型为int,为主键,自增长属性为真
hostname = Column(String(),unique=True,nullable=False) # 声明字段hostname,类型为String,是否唯一限制为True,是否可为空False
ip_addr = Column(String(),unique=True,nullable=False)
port = Column(Integer,default=)
groupid = Column(Integer,ForeignKey('group.id')) # 添加一个字段,并设置此字段类型为外键.
group = relationship('Group') # 建立关联关系 class Group(Base):
__tablename__ = 'group' # 定义表名
id = Column(Integer,primary_key=True,autoincrement=True,nullable=False)
groupname = Column(String(),unique=True,nullable=False) # 创建表结构方法
Base.metadata.create_all(engine) # 通过引擎engine,SqlORM基类 调用metadata中的create_all方法,这样远程数据库中如果存在子类中的表则不做动作,如果不存在则添加.如果存表名但是字段不一样也不做操作. if __name__ == '__main__':
SessionCls = sessionmaker(bind=engine) #创建与数据库的会话session class ,注意,这里返回给session的是个class,不是实例,也就意味着一切连接都就绪了,就查你点连接了
session = SessionCls() # 实例化一个连接huihua
'''
再次测试!!!
'''
h = session.query(Host).filter(Host.id == ).first()
print('+++++++++++++++>',h.group.groupname) # 打印h.group.groupname
# 执行结果: +++++++++++++++> g4
总结:要用到关联查询,两部:1.导入sqlalchemy.orm模块中的relationship 2.使用relationship建立关联关系. 刚刚我们实现了一对多,一个主机对应一个组,并且通过ralationship()建立关系后,使用host.group.groupname获得组名。 那么问题来了,我们如何实现通过组,获得组中包含多少个主机呢？
答案：前面我们只是在Host 类中声明了relationship()，所以通过host.group.groupname能过获得groupname的信息，
所以如果我们想通过group.hosts获得主机的话，就需要在relationship()中声明和Host的关系。
于是代码改成如下：
SqlAlchemy例子(一对多外键联接3)_通过组获取主机_双方声明关系
#!/usr/bin/env python3.
#__author__:ted.zhou
import pymysql
from sqlalchemy import create_engine # 导入引擎类
from sqlalchemy.ext.declarative import declarative_base # 导入sqlalchemy的一个扩展模块declarative_base,此模块调用返回一个封装好的 metadata元数据和表名以及表字段 的类.注意返回的是个类,不是实例.
from sqlalchemy import Column,Integer,String,ForeignKey # 导入和创建表结构相关的模块
from sqlalchemy.orm import sessionmaker # 导入sessionmaker模块,它自己是一个类,实例化它返回的还是一个类(是一个包含了数据库API信息和连接地址端口以及用户名和密码信息的类)不是一个实例
# 这句话的意思,拿到数据库API(传入的bind=engine参数作中记录了数据库的API和连接信息),创建一个连接的类.这个类里有连接信息,和数据库API信息,接下来要创建一个连接session就要实例化这个类
from sqlalchemy.orm import relationship # 导入ralationship模块 Base = declarative_base() #生成一个SqlORM基类,接下来所有要创建的SqlORM的子类(理解成如果想用sqlalchemy来操作数据库中的表,就需要把数据库的表结构映射成SqlORM类) # 实例化引擎,只是把连接信息作为参数传入,并未真的连接.
engine = create_engine("mysql+pymysql://root:123456@127.0.0.1:3307/test",echo=True) # echo=True可以显示转化后的原生SQL语句执行过程 class Host(Base): # 定义一个SqlORM类,继承Base类这样他就默认绑定了matedata和数据结构
__tablename__ = 'hosts' # 声明表名
id = Column(Integer,primary_key=True,autoincrement=True,nullable=False) # 声明字段id,类型为int,为主键,自增长属性为真
hostname = Column(String(),unique=True,nullable=False) # 声明字段hostname,类型为String,是否唯一限制为True,是否可为空False
ip_addr = Column(String(),unique=True,nullable=False)
port = Column(Integer,default=)
groupid = Column(Integer,ForeignKey('group.id')) # 添加一个字段,并设置此字段类型为外键.
group = relationship('Group') # 建立关联关系 class Group(Base):
__tablename__ = 'group' # 定义表名
id = Column(Integer,primary_key=True,autoincrement=True,nullable=False)
groupname = Column(String(),unique=True,nullable=False)
hosts = relationship('Host') ＃ 在组类中声明和Host类的关联 # 创建表结构方法
Base.metadata.create_all(engine) # 通过引擎engine,SqlORM基类 调用metadata中的create_all方法,这样远程数据库中如果存在子类中的表则不做动作,如果不存在则添加.如果存表名但是字段不一样也不做操作. if __name__ == '__main__':
SessionCls = sessionmaker(bind=engine) #创建与数据库的会话session class ,注意,这里返回给session的是个class,不是实例,也就意味着一切连接都就绪了,就查你点连接了
session = SessionCls() # 实例化一个连接huihua
'''
# 我们先测试
g4 = session.query(Group).filter(Group.id == ).all()
print("+++++++++>",g4.host)
#结果不行,因为Group中没有host字段
# 是不是应该在Group类中同样要通过relationship('Host') 绑定关系,在Group类中添加语句如下: hosts = relationship('Host')
''' '''
# 接着测试:
g4 = session.query(Group).filter(Group.id == ).first() # 这里要用first(),不能用all()否则得到的是一个列表
print("+++++++++>",g4.hosts)
# 结果:+++++++++> [<__main__.Host object at 0x103843048>] ,如果有多个,那么得到的是两个obj对象 '''
反向就查出来了,是不是很方便,能够这么使用的原因:1.Host中的groupid和Group中的id外键关联,如果没有关联关系肯定不行
2. Group类中也要调用relationship('Host')进行关联
那么问题来了,一个父亲,要和多个儿子做ralationship()方法的关联,这代码看上去是不是很麻烦.
sqlalchemy语法也考虑到了,只需要在儿子类中把relationship()语法写成: hosts = relationship('Host',backref='hosts')
于是代码改成如下：
SqlAlchemy例子(一对多外键联接4)_通过组获取主机_一方声明双方起作用
#!/usr/bin/env python3.
#__author__:ted.zhou
import pymysql
from sqlalchemy import create_engine # 导入引擎类
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import Column,Integer,String,ForeignKey # 导入和创建表结构相关的模块
from sqlalchemy.orm import sessionmaker # 导入sessionmaker模块,它自己是一个类,实例化它返回的还是一个类 from sqlalchemy.orm import relationship # 导入ralationship模块 Base = declarative_base() # 实例化引擎,只是把连接信息作为参数传入,并未真的连接.
engine = create_engine("mysql+pymysql://root:123456@127.0.0.1:3307/test",echo=True) # echo=True可以显示转化后的原生SQL语句执行过程 class Host(Base): # 定义一个SqlORM类,继承Base类这样他就默认绑定了matedata和数据结构
__tablename__ = 'hosts' # 声明表名
id = Column(Integer,primary_key=True,autoincrement=True,nullable=False) # 声明字段id,类型为int,为主键,自增长属性为真
hostname = Column(String(),unique=True,nullable=False) # 声明字段hostname,类型为String,是否唯一限制为True,是否可为空False
ip_addr = Column(String(),unique=True,nullable=False)
port = Column(Integer,default=)
groupid = Column(Integer,ForeignKey('group.id')) # 添加一个字段,并设置此字段类型为外键.
group = relationship('Group',backref='hosts') # 建立关联关系，这一句很关键，一句代码就实现了双向关系的声明 class Group(Base):
__tablename__ = 'group' # 定义表名
id = Column(Integer,primary_key=True,autoincrement=True,nullable=False)
groupname = Column(String(),unique=True,nullable=False)
# hosts = relationship('Host') # 这里就不需要用了 # 创建表结构方法
Base.metadata.create_all(engine) # 通过引擎engine,SqlORM基类 调用metadata中的create_all方法,这样远程数据库中如果存在子类中的表则不做动作,如果不存在则添加.如果存表名但是字段不一样也不做操作. if __name__ == '__main__':
SessionCls = sessionmaker(bind=engine) #创建与数据库的会话session class ,注意,这里返回给session的是个class,不是实例,也就意味着一切连接都就绪了,就查你点连接了
session = SessionCls() # 实例化一个连接huihua # 接着测试:
g4 = session.query(Group).filter(Group.id == ).first() # 这里要用first(),不能用all()否则得到的是一个列表
print("+++++++++>",g4.hosts)
# 结果:+++++++++> [<__main__.Host object at 0x103843048>] ,如果有多个,那么得到的是两个obj对象
总结:用group = relationship('Group',backref='hosts') # 可以建立双向关系
同时还有一个很类似backref 的用法,就是relationship('Group',back_populates='hosts')
那么我们会问为什会有一个累死backref的功能呢,它用在什么时候.一点区别没有吗.
区别是: 用法上不一样relationship('Group',back_populates='hosts')必须是成对出现的,
也就是说在儿子处group = relationship('Group',back_populates='hosts'),在父亲处就必须有 hosts = relationship('Host',back_populates='group')
那么我们猜想应用场景也就是做统一管理接口的时候,就是在父亲处统一管理,让儿子可不可以外链它.增加了安全性。
前面一对多外联的基本用法演示完成，我们知道实际开发中有很多使用join的方法进行外联查询
SqlAlchemy例子(一对多外键联接5)_innerjoin_leftjoin_rightjoin
#!/usr/bin/env python3.
#__author__:ted.zhou
import pymysql
from sqlalchemy import create_engine # 导入引擎类
from sqlalchemy.ext.declarative import declarative_base # 导入sqlalchemy的一个扩展模块declarative_base,此模块调用返回一个封装好的 metadata元数据和表名以及表字段 的类.注意返回的是个类,不是实例.
from sqlalchemy import Column,Integer,String,ForeignKey,func # 导入和创建表结构相关的模块
from sqlalchemy.orm import sessionmaker # 导入sessionmaker模块,它自己是一个类,实例化它返回的还是一个类(是一个包含了数据库API信息和连接地址端口以及用户名和密码信息的类)不是一个实例
# 这句话的意思,拿到数据库API(传入的bind=engine参数作中记录了数据库的API和连接信息),创建一个连接的类.这个类里有连接信息,和数据库API信息,接下来要创建一个连接session就要实例化这个类
from sqlalchemy.orm import relationship # 导入ralationship模块 Base = declarative_base() #生成一个SqlORM基类,接下来所有要创建的SqlORM的子类(理解成如果想用sqlalchemy来操作数据库中的表,就需要把数据库的表结构映射成SqlORM类) # 实例化引擎,只是把连接信息作为参数传入,并未真的连接.
engine = create_engine("mysql+pymysql://root:123456@127.0.0.1:3307/test",echo=True) # echo=True可以显示转化后的原生SQL语句执行过程 class Host(Base): # 定义一个SqlORM类,继承Base类这样他就默认绑定了matedata和数据结构
__tablename__ = 'hosts' # 声明表名
id = Column(Integer,primary_key=True,autoincrement=True,nullable=False) # 声明字段id,类型为int,为主键,自增长属性为真
hostname = Column(String(),unique=True,nullable=False) # 声明字段hostname,类型为String,是否唯一限制为True,是否可为空False
ip_addr = Column(String(),unique=True,nullable=False)
port = Column(Integer,default=)
groupid = Column(Integer,ForeignKey('group.id')) # 添加一个字段,并设置此字段类型为外键.
group = relationship('Group',backref='hosts') # 建立关联关系 class Group(Base):
__tablename__ = 'group' # 定义表名
id = Column(Integer,primary_key=True,autoincrement=True,nullable=False)
groupname = Column(String(),unique=True,nullable=False)
# hosts = relationship('Host') # 这里就不需要用了 class test_table(Base):
__tablename__ = 'test_table'
id = Column(Integer,primary_key=True,autoincrement=True,nullable=False)
name2 = Column(String(),unique=True,nullable=False) # 创建表结构方法
Base.metadata.create_all(engine) # 通过引擎engine,SqlORM基类 调用metadata中的create_all方法,这样远程数据库中如果存在子类中的表则不做动作,如果不存在则添加.如果存表名但是字段不一样也不做操作. if __name__ == '__main__':
SessionCls = sessionmaker(bind=engine) #创建与数据库的会话session class ,注意,这里返回给session的是个class,不是实例,也就意味着一切连接都就绪了,就查你点连接了
session = SessionCls() # 实例化一个连接huihua
'''
# inner join
obj = session.query(Host).join(Host.group).filter().all()
print('+++++++++>',obj)
# 执行时,调用的原生SQL语句是:SELECT hosts.id AS hosts_id, hosts.hostname AS hosts_hostname, hosts.ip_addr AS hosts_ip_addr, hosts.port AS hosts_port, hosts.groupid AS hosts_groupid FROM hosts INNER JOIN `group` ON `group`.id = hosts.groupid
# 分析原生sql,得出结论:join(Host.group)这段代码,首先说明1. Host 中有group字段,并且group字段是通过relationship()做关联的,那通过什么关联的呢 继而得出条件2.Host 和Group有外键 # 上面得到的也只有一张表的数据,那如果想得到两张表的数据呢
obj2 = session.query(Host,Group).join(Host.group).filter().all()
print("obj2:",obj2)
# 解析成原生sql为:
# SELECT hosts.id AS hosts_id, hosts.hostname AS hosts_hostname, hosts.ip_addr AS hosts_ip_addr, hosts.port AS hosts_port, hosts.groupid AS hosts_groupid, `group`.id AS group_id, `group`.groupname AS group_groupname FROM hosts INNER JOIN `group` ON `group`.id = hosts.groupid
'''
'''
# 上面两个都是有建立过外键的情况下进行查询,假如没有创建过字段为外键的情况下能查询呢
obj3 = session.query(Host,Group).join(Host.groupid==Group.id).filter().all()
print("obj3:",obj3)
# 经测试,行不通,难道说join查询在sqlalchemy中只支持带外键的查询吗.未知???这将对我了解数据库有很大帮助
''' # 使用group_by 对查询结果进行分类聚合
obj4 = session.query(func.count(Host,Group)).join(Group).filter().group_by(Group.groupname).first()
print('obj4:',obj4)
'''
# 下面我们测试下当没有外键关系的表,外链查询的结果
obj5 = session.query(Host,test_table).join(test_table).filter().all()
print('obj5:',obj5)
# 结果报错:sqlalchemy.exc.NoForeignKeysError: Can't find any foreign key relationships between 'hosts' and 'test_table'.
# 说明要执行join查询需要有外键关系.
# 但是原生的sql是可以查询没有外键关系的两种表的
# SELECT hosts.id AS hosts_id, hosts.hostname AS hosts_hostname, hosts.ip_addr AS hosts_ip_addr, hosts.port AS hosts_port, hosts.groupid AS hosts_groupid FROM hosts INNER JOIN `test_table` ON `test_table`.id = hosts.groupid;
# 结果:Empty set (0.00 sec)
# 那么接下来又一个问题要解决,就是在sqlalchemy中如何实现没有外键关系进行 join查询???
'''
1对多外联查询演示
前面SqlAlchemy完整的例子(一对多外键联接1-5) 这些都是一对多的外链,从基础到高级用法.
但实际开发中,经常有多对多的场景,比如一个主机属于多个组.前面1-5个例子都无法实现,因为每一个主机一条纪录,主机名是唯一的,你没有办法为同一个主机名创建2条纪录,而只是主机组id不一样.
即使可以,也不符合我们作为技术的宗旨,同一样的纪录最好只需要录入一遍.所以如果想实现一个主机属于多个组,就应该单独创建一张主机——组的关系表.表中只纪录主机id和组id.并且不论你用不用orm所有数据库表结构的many to many的关系,也都是通过关系表实现
在原生sql中,拿mysql来说,看起来是没有什么难度的.
假设我们现在创建了一个表:
表名:HostToGroup
id host_id group_id
1 1 1
2 1 2
3 2 1
那么我们想通过关系表查找 主机名,组名,是不是每次查都需要各种来回的join查询.
而orm的存在简化这种操作.实现了不用调用中间表,通过
Host.groups()就可以查出这个主机所属的组的列表
group.hosts() 就可以查出这个组中包含的所有主机的列表.
具体内部代码如何实现的,我们不需要知道,只要知道如何使用sqlalchemy代码实现就可以了.
代码范例:
SqlAlchemy例子(对对多外键联接1)_对原生sql优化的内容
#!/usr/bin/env python3.
#__author__:ted.zhou
import pymysql
from sqlalchemy import create_engine
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import Column,Integer,String,ForeignKey,func # 导入和创建表结构相关的模块
from sqlalchemy.orm import sessionmaker from sqlalchemy.orm import relationship # 导入ralationship模块
from sqlalchemy import Table # 要先导入Table,接下来我们使用Table来创建关系表,而不是使用类的形势创建关系表 Base = declarative_base() #生成一个SqlORM基类 Host2Group = Table('host_2_group',Base.metadata, # 这里为什么用Table方式创建表,而不使用class方式,首先我们要知道Table方式创建的表返回的是一个实例,我们可以通过实例.insert()插入数据.而class插入数据的时候却要先实例化.所以我们这里是要用到它返回实例可以操作的特性,用到Table,而不用class
Column('host_id',ForeignKey('hosts.id'),primary_key=True), # 这里我们看这个表中有两个主键,为什么呢
Column('group_id',ForeignKey('group.id'),primary_key=True), # 因为确保 (主机id-组id) 唯一,且他们两个都不能为空
)
'''
20 这里表创建好了,并且使用的是Table,
21 我们说了sqlalchemy优化了这种many to many的关系实现方式.目前知道能简化的方式:
22 1.不用通过join调用,直接通过Host.groups()获得某个主机所属的组,直接通过group.hosts()获得某个组中的主机
23 那我现在告诉你第二个优化的点
24 2.在新建一个主机 并且关联到某一个组时,自动的往关系表中添加一条host_id和group_id的纪录.(是不是很高级~自动添加,不用像原生SQL一样,要多写一条sql语句)
25 这也是前面使用Table创建这个关系表的原因
26 紧接着你会问怎么实现呢? 別着急,很简单,还记得我们使用relationship()方法,来指定hosts表和group表的关联关系吗?
27 我们只需要在原有relationship()方法中,加secondary=Host2Group,并且把之前创建的外键字段删除
28 最终应该是
29 groups = relationship('Group',secondary=Host2Group,backref='hosts')
''' # 实例化引擎,只是把连接信息作为参数传入,并未真的连接.
engine = create_engine("mysql+pymysql://root:123456@127.0.0.1:3307/test",echo=True) # echo=True可以显示转化后的原生SQL语句执行过程 class Host(Base): # 定义一个SqlORM类,继承Base类这样他就默认绑定了matedata和数据结构
__tablename__ = 'hosts' # 声明表名
id = Column(Integer,primary_key=True,autoincrement=True,nullable=False) # 声明字段id,类型为int,为主键,自增长属性为真
hostname = Column(String(),unique=True,nullable=False) # 声明字段hostname,类型为String,是否唯一限制为True,是否可为空False
ip_addr = Column(String(),unique=True,nullable=False)
port = Column(Integer,default=)
# groupid = Column(Integer,ForeignKey('group.id')) # 此时要删除这个外键了
# group = relationship('Group',backref='hosts') # 这个关系也要改了
groups = relationship('Group',
secondary=Host2Group, # 指定中间表的实例
backref='hosts') # 最终改成这个样子了 '''
# 因为关系表两个外键一个host_id,外键的是hosts.id
# 另外一个外溅group_id,外键的是group.id
# 就是根据这两个外键,并且通过relationship()方法才做了优化 many to many关系的操作语法.
''' class Group(Base):
__tablename__ = 'group' # 定义表名
id = Column(Integer,primary_key=True,autoincrement=True,nullable=False)
groupname = Column(String(),unique=True,nullable=False)
# hosts = relationship('Host') # 这里就不需要用了 # 创建表结构方法
Base.metadata.create_all(engine) if __name__ == '__main__':
SessionCls = sessionmaker(bind=engine) #创建与数据库的会话session class ,注意,这里返回给session的是个class,不是实例,也就意味着一切连接都就绪了,就查你点连接了
session = SessionCls() # 实例化一个连接huihua '''
一 首先我们先创建主机和组
# 创建3个组
# g1 = Group(groupname='g1',id=)
# g2 = Group(groupname='g2',id=)
# g3 = Group(groupname='g3') # 创建一个主机
# h1 = Host(hostname='linux1',ip_addr='10.0.0.1',port=) #
# session.add_all([g1,g2,g3,h1])
# session.commit()
'''
'''
二. 然后我们将 主机和组关联起来
groups = session.query(Group).filter().all() # 查出所有组
h = session.query(Host).filter(Host.hostname == 'linux1').first() # 查出一个主机
h.groups = groups # 将这个主机的groups 直接赋值 上面所查到的groups
session.commit() # 提交后,就会在关系表中host_2_group 自动创建3条纪录,前提就是1.relationship()的设置,和2.关系表外键的设置
''' '''
# 三 .接下来我们来试试查询
# 查看主机所属的所有组
h = session.query(Host).filter(Host.hostname=='linux1').first()
print('++++++++++++>>>>>',h.groups)
# 执行结果:
# ++++++++++++>>>>> [<__main__.Group object at 0x103717748>, <__main__.Group object at 0x1037177b8>, <__main__.Group object at 0x103717828>]
# 我们看到有3个组的对象
# 查看组里所有的主机
g = session.query(Group).filter(Group.groupname == 'g2').first()
print('----------->>>>>>',g.hosts)
# 执行结果:
# ----------->>>>>> [<__main__.Host object at 0x10383d320>]
# 我们看到有一个主机对象.
总结:sqlalchemy是多么的神奇.好的很
前面查询的host.groups 和 group.hosts的结果都是对象类型,那么我们最终要打印的肯定不是对象,而是字符串.
问题：怎样将结果打印成字符串呢. sqlalchemy语法本身是没有方法的,我们看我们是通过class创建的orm类,那么我们可以定义__repr__()方法,来随意指定返回的内容
因此 我们在创建 Host和Group类中定义 def __repr__(self):
于是代码改成如下：
SqlAlchemy例子(对对多外键联接2)_将返回的结果转换成字符串
#!/usr/bin/env python3.
#__author__:ted.zhou
import pymysql
from sqlalchemy import create_engine # 导入引擎类
from sqlalchemy.ext.declarative import declarative_base # 导入sqlalchemy的一个扩展模块declarative_base,此模块调用返回一个封装好的 metadata元数据和表名以及表字段 的类.注意返回的是个类,不是实例.
from sqlalchemy import Column,Integer,String,ForeignKey,func # 导入和创建表结构相关的模块
from sqlalchemy.orm import sessionmaker # 导入sessionmaker模块,它自己是一个类,实例化它返回的还是一个类(是一个包含了数据库API信息和连接地址端口以及用户名和密码信息的类)不是一个实例
# 这句话的意思,拿到数据库API(传入的bind=engine参数作中记录了数据库的API和连接信息),创建一个连接的类.这个类里有连接信息,和数据库API信息,接下来要创建一个连接session就要实例化这个类
from sqlalchemy.orm import relationship # 导入ralationship模块 from sqlalchemy import Table # 要先导入Table,接下来我们使用Table来创建关系表,而不是使用类的形势创建关系表 Base = declarative_base() #生成一个SqlORM基类,接下来所有要创建的SqlORM的子类(理解成如果想用sqlalchemy来操作数据库中的表,就需要把数据库的表结构映射成SqlORM类) Host2Group = Table('host_2_group',Base.metadata, # 这里为什么用Table方式创建表,而不使用class方式,首先我们要知道Table方式创建的表返回的是一个实例,我们可以通过实例.insert()插入数据.而class插入数据的时候却要先实例化.所以我们这里是要用到它返回实例可以操作的特性,用到Table,而不用class
Column('host_id',ForeignKey('hosts.id'),primary_key=True), # 这里我们看这个表中有两个主键,为什么呢
Column('group_id',ForeignKey('group.id'),primary_key=True), # 因为确保 (主机id-组id) 唯一,且他们两个都不能为空
) # 实例化引擎,只是把连接信息作为参数传入,并未真的连接.
engine = create_engine("mysql+pymysql://root:123456@127.0.0.1:3307/test",echo=True) # echo=True可以显示转化后的原生SQL语句执行过程 class Host(Base): # 定义一个SqlORM类,继承Base类这样他就默认绑定了matedata和数据结构
__tablename__ = 'hosts' # 声明表名
id = Column(Integer,primary_key=True,autoincrement=True,nullable=False) # 声明字段id,类型为int,为主键,自增长属性为真
hostname = Column(String(),unique=True,nullable=False) # 声明字段hostname,类型为String,是否唯一限制为True,是否可为空False
ip_addr = Column(String(),unique=True,nullable=False)
port = Column(Integer,default=)
groups = relationship('Group',secondary=Host2Group,backref='hosts') # 最终改成这个样子了 def __repr__(self): # 定义__repr__方法,默认返回字符串
return "<id=%s,hostname=%s,ip_addr=%s>"%(self.id,
self.hostname,
self.ip_addr) class Group(Base):
__tablename__ = 'group' # 定义表名
id = Column(Integer,primary_key=True,autoincrement=True,nullable=False)
groupname = Column(String(),unique=True,nullable=False) def __repr__(self): # 定义__repr__方法,默认返回字符串
return "<id=%s,name=%s>"%(self.id,self.groupname)
# 创建表结构方法
Base.metadata.create_all(engine) # 通过引擎engine,SqlORM基类 调用metadata中的create_all方法,这样远程数据库中如果存在子类中的表则不做动作,如果不存在则添加.如果存表名但是字段不一样也不做操作. if __name__ == '__main__':
SessionCls = sessionmaker(bind=engine) #创建与数据库的会话session class ,注意,这里返回给session的是个class,不是实例,也就意味着一切连接都就绪了,就查你点连接了
session = SessionCls() # 实例化一个连接huihua # 查看主机所属的所有组
h = session.query(Host).filter(Host.hostname=='linux1').first()
print('++++++++++++>>>>>',h.groups) # 打印结果:
# ++++++++++++>>>>> [<id=,name=g1>, <id=,name=g2>, <id=,name=g3>] g = session.query(Group).filter(Group.groupname == 'g2').first()
print('----------->>>>>>',g.hosts)
# 打印结果
# ----------->>>>>> [<id=,hostname=linux1,ip_addr=10.0.0.1>]
请仔细查看上面两个范例代码，保证能看到你想看到的东西
至此，sqlalchemy的一些简单用法，外键用法，join用法，以及多对多关系的用法这节课就讲完了。基本上能够满足70％了，其他的实际需求要自己查。
