ORM解决的问题
当你的应用程序需要跟数据库大量交互时，如果你直接把sql语句写到代码中，
1.会出现大量的重复代码。（可以把重复的sql语句写成一个函数)
2.当你的后端数据库改变后，你的代码需要重写。
测试:
MySQL数据库
pymysql模块
创建一个test库
一、单表操作
1.创建表
#!/usr/bin/env python
#-*- coding:utf-8 -*-
from sqlalchemy import create_engine,func
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import Column, Integer, String,ForeignKey
from sqlalchemy.orm import sessionmaker,relationship
Base = declarative_base() #生成一个SqlORM 基类
engine = create_engine("mysql+pymysql://root:123.com@localhost:3306/test",echo=True) #echo = True 会打印执行过程
class Host(Base): #创建一个类,继承base
__tablename__ = 'hosts'
id = Column(Integer,primary_key=True,autoincrement=True) #主键primary_key默认就是True,自增id
hostname = Column(String(64),unique=True,nullable=False)
ip_addr = Column(String(128),unique=True,nullable=False)
port = Column(Integer,default=22) #默认是22
Base.metadata.create_all(engine)
打印出的sql语句
CREATE TABLE hosts (
id INTEGER NOT NULL AUTO_INCREMENT,
hostname VARCHAR(64) NOT NULL,
ip_addr VARCHAR(128) NOT NULL,
port INTEGER,
PRIMARY KEY (id),
UNIQUE (hostname),
UNIQUE (ip_addr)
)
2.增加数据
#!/usr/bin/env python
#-*- coding:utf-8 -*-
from sqlalchemy import create_engine,func
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import Column, Integer, String,ForeignKey
from sqlalchemy.orm import sessionmaker,relationship
Base = declarative_base() #生成一个SqlORM 基类
engine = create_engine("mysql+pymysql://root:123.com@localhost:3306/test",echo=True) #echo = True 会打印执行过程
class Host(Base): #创建一个类,继承base
__tablename__ = 'hosts'
id = Column(Integer,primary_key=True,autoincrement=True) #主键primary_key默认就是True,自增id
hostname = Column(String(64),unique=True,nullable=False)
ip_addr = Column(String(128),unique=True,nullable=False)
port = Column(Integer,default=22) #默认是22
# Base.metadata.create_all(engine)
if __name__ == '__main__':
#创建与数据库的会话session class ,注意,这里返回给session的是个class,不是实例
#sessionmaker自己是一个类，返回的是一个类.(__call__方法返回)
SessionCls = sessionmaker(bind=engine)
#所以你想生成你的session还需要session = SessionCls()
session = SessionCls()
#写数据信息
h1 = Host(hostname='localhost',ip_addr='127.0.0.1')
h2 = Host(hostname='ubuntu',ip_addr='192.168.2.243',port=20000)
h3 = Host(hostname='ubuntu2',ip_addr='192.168.2.244',port=20000)
#添加数据
#第一种方法
# session.add(h1)
# session.add(h2)
# session.add(h3)
#第二种方法
session.add_all([h1,h2,h3])
#只要没提交,此时修改也没问题
# h2.hostname = 'ubuntu_test'
# session.rollback()
session.commit() #提交
INSERT INTO hosts (hostname, ip_addr, port) VALUES (%(hostname)s, %(ip_addr)s, %(port)s)
{'ip_addr': '127.0.0.1', 'hostname': 'localhost', 'port': 22}
3.查询数据
res = session.query(Host).filter(Host.hostname.in_(['ubuntu2','localhost'])).all()
for i in res:
print(i.hostname,i.ip_addr)
二、一对多
******
一对多
******
一个组可以包含多个主机,一个主机只能属于一个组
A ------ G1,admin,permission
B ------ G1,admin,permission
C ------ G2,admin,permission
C ------ G1,admin,permission
缺点：
有大部分重复字段，浪费空间
在修改时，可能会出现错误
主机表一个字段连接组表的一个字段
主机表 组表
A 1 ----- 1 G1 admin permssion
B 1 ----- 2 G1 admin permssion
C 2 ----- 3 G2 admin permssion
C 1 ----- 4 G1 admin permssion
查询
通过表一可以查询表二,通过表二可以查询表一
当数据库表中添加新的字段,sqlalchemy无法操作。所以当你添加字段有两个方法.
1.把表删了，重新创建
2.原生语句添加
3.sqlalchemy有个开源工具可以实现
这么添加host表中的group_id是空值，没有关联上
g1 = Group(name='g1')
g2 = Group(name='g2')
g3 = Group(name='g3')
session.add_all([g1,g2,g3])
h1 = Host(hostname='localhost',ip_addr='127.0.0.1',group_id = g3.id)
session.add(h1)
session.commit()
#update 参数是一个字典
h1 = session.query(Host).filter(Host.hostname == 'localhost').update({'group_id':g4.id})
查询：
通过host表获取组的名字,或者通过group表获取host主机.都需要用到 relationship
group = relationship("Group") #相当于反射，把Group类反射到Host.group字段
2.查看组里多少台主机
g3 = session.query(Group).filter(Group.name=='g3').first()
obj = g3.host_list
#1
print(obj[0].hostname)
#2
for i in obj:
print(i.hostname)
join 查询
1.查询两个表的交集
select * from hosts join test.group on hosts.group_id = test.group.id;
2.right outer join 右边全列出来，左边如果没有就是null
3.left join 左边全列出来，右边没有就是null
4.full outer join 全显示出来
分组聚合:查看每个组里有几台机器
原生sql版本
select Count(*),test.group.name from hosts inner join test.group on hosts.group_id = test.group.id group by test.group.name;
orm版本
需要func模块，包含count方法
#查询host组,以组名为条件,查询每个组名下的主机个数
obj = session.query(Host,func.count(Group.name)).join(Host.group).group_by(Group.name).all()
一、创建组表
二、创建主机表
三、创建关联
#!/usr/bin/env python
#-*- coding:utf-8 -*-
from sqlalchemy import create_engine,func
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import Column, Integer, String,ForeignKey
from sqlalchemy.orm import sessionmaker,relationship
Base = declarative_base() #生成一个SqlORM 基类
engine = create_engine("mysql+pymysql://root:123.com@localhost:3306/test",echo=True) #echo = True 会打印执行过程
class Host(Base): #创建一个类,继承base
__tablename__ = 'hosts'
id = Column(Integer,primary_key=True,autoincrement=True) #主键primary_key默认就是True,自增id
hostname = Column(String(64),unique=True,nullable=False)
ip_addr = Column(String(128),unique=True,nullable=False)
port = Column(Integer,default=22) #默认是22
group_id = Column(Integer,ForeignKey('group.id')) # 第一种
group = relationship("Group",backref='host_list') #backref是group查询host的字段
class Group(Base):
__tablename__ = 'group'
id = Column(Integer,primary_key=True,autoincrement=True)
name = Column(String(64),unique=True,nullable=False)
# Base.metadata.create_all(engine)
if __name__ == '__main__':
SessionCls = sessionmaker(bind=engine)
session = SessionCls()
#添加组信息
# g1 = Group(name='g1')
# g2 = Group(name='g2')
# g3 = Group(name='g3')
# session.add_all([g1,g2,g3])
#查询组名
# g2 = session.query(Group).filter(Group.name == 'g2').first()
# g3 = session.query(Group).filter(Group.name == 'g3').first()
# print(g2.id)
#添加主机信息
# h1 = Host(hostname='localhost',ip_addr='127.0.0.1',group_id = g3.id)
# h2 = Host(hostname='ubuntu',ip_addr='192.168.2.243',port=20000,group_id = g3.id)
# h3 = Host(hostname='ubuntu2',ip_addr='192.168.2.244',port=20000,group_id = g2.id)
#查询主机信息
# h1 = session.query(Host).filter(Host.hostname == 'localhost').update({'group_id':g2.id})
# session.add_all([h1,h2,h3])
# ret = session.query(Host).filter(Host.hostname == 'ubuntu2').delete()
# session.commit()
#查询一个组里面有多少个主机
# g3 = session.query(Group).filter(Group.name == 'g2').first()
# obj = g3.host_list
# for i in obj:
# print(i.hostname +'-----' + i.ip_addr)
obj = session.query(Host,func.count(Group.name)).join(Host.group).group_by(Group.name).all()
print(obj)
#删除一条数据
# ret = session.query(Host).filter(Host.hostname == 'ubuntu2').delete()
#更新一个字段
#h1 = session.query(Host).filter(Host.hostname == 'localhost').update({'group_id':g2.id})
三、多对多
多对多
一个主机可以属于多个组，一个组里可以包含多个主机
------------
h1 g1 ip port #当我改这条数据组的信息时，如果不改第二条，那么h1的数据就是有问题的，这样不能做到多对多。
h1 g2 ip port
h2 g1 ip port
建一个第三张表
host hosttogroup group
=====================================================
id 主机 id host_id group_id id 组名
=====================================================
1 h1 1 1 1 1 g1
2 h2 2 1 2 2 g2
3 2 1
两种方式创建表
1.通过类创建,需要实例化
Host2Group = Table('host_2_group',Base.metadata,
Column('host_id',ForeignKey('host.id'),primary_key=True),
Column('group_id',ForeignKey('group.id'),primary_key=True),
)
2.table方式(中间状态),返回的是一个对象，不需要实例化
class Group(Base):
__tablename__ = 'group'
id = Column(Integer,primary_key=True,autoincrement=True)
name = Column(String(64),unique=True,nullable=False)
关联参数
class Host(Base):
__tablename__ = 'host'
id = Column(Integer,primary_key=True,autoincrement=True)
hostname = Column(String(64),unique=True,nullable=False)
ip_addr = Column(String(128),unique=True,nullable=False)
port = Column(Integer,default=22)
# group_id = Column(Integer,ForeignKey('group.id'))
group = relationship("Group",
secondary=Host2Group, #secondary=第三章表名
backref='host_list') #反向关联，实现相互查询
table表要设置两个主键，因为两个列成为一个主键，非空且唯一。
id host_id group_id
1 null 1
2 1 1
3 1 1
关联:
groups = session.query(Group).all()
h1 = session.query(Host).filter(Host.hostname == 'h1').first()
h1.groups = groups
一、建一个中间表,关联其它两张表
二、指定中间表的实例 #secondary=Host2Group
三、先创建三张表
四、创建组数据
五、创建主机数据
#!/usr/bin/env python
#-*- coding:utf-8 -*-
from sqlalchemy import create_engine,func,Table
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import Column, Integer, String,ForeignKey
from sqlalchemy.orm import sessionmaker,relationship
Base = declarative_base()
#返回的直接是表的对象
#中间表,关联其它两个表id，并设置为主键.
Host2Group = Table('host_2_group',Base.metadata,
Column('host_id',ForeignKey('host.id'),primary_key=True),
Column('group_id',ForeignKey('group.id'),primary_key=True),
)
engine = create_engine("mysql+pymysql://root:123.com@localhost:3306/tests",echo=True)
class Host(Base):
__tablename__ = 'host'
id = Column(Integer,primary_key=True,autoincrement=True)
hostname = Column(String(64),unique=True,nullable=False)
ip_addr = Column(String(128),unique=True,nullable=False)
port = Column(Integer,default=22)
# group_id = Column(Integer,ForeignKey('group.id'))
group = relationship("Group",
secondary=Host2Group,
backref='host_list') #反向关联，实现相互查询
#返回字符串
def __repr__(self):
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)
name = Column(String(64),unique=True,nullable=False)
def __repr__(self):
return "<id=%s,name=%s>" % (self.id,
self.name,)
# Base.metadata.create_all(engine) #创建所有表结构
if __name__ == '__main__':
SessionCls = sessionmaker(bind=engine) #创建与数据库的会话session class ,注意,这里返回给session的是个class,不是实例
session = SessionCls()
#创建组数据
# g1 = Group(name='g1')
# g2 = Group(name = 'g2')
# g3 = Group(name = 'g3')
# session.add_all([g1,g2,g3])
#创建主机数据
groups = session.query(Group).all()
# h1 = Host(hostname='h1',ip_addr='192.168.0.1')
# h1.group = groups
h3 = Host(hostname='ubuntu3',ip_addr='192.168.2.222',port=20000)
# h2 = session.query(Host).filter(Host.hostname == 'h2').first()
h3.group = groups[0:2]
# h3 = Host(hostname='ubuntu2',ip_addr='192.168.2.244',port=20000)
# session.add_all([h1,h2])
session.commit()