一、我们接着上期的博客继续对ORM框架进行补充，顺便把paramiko模块也给大家讲解一下：
1、ORM框架：
在连接操作数据库的第一个博客中也已经说了，sqlalchemy是一个ORM框架，总结就是：将对象转换成SQL，然后使用数据API执行SQL并获取执行结果。先来看下使用sqlalchemy来链接数据库的基本代码：
1 from sqlalchemy.ext.declarative import declarative_base 2 from sqlalchemy import Column, Integer, String, ForeignKey, UniqueConstraint, Index 3 from sqlalchemy.orm import sessionmaker, relationship 4 from sqlalchemy import create_engine 5 6 engine = create_engine("mysql+pymysql://mysql_test:123456@192.168.163.131:3306/pymysql", max_overflow=5) 7 8 Base = declarative_base()
首先，前四行是导入的有关模块，我们对这些模块进行简单的介绍，然后列举例子，你就能明白了；
第二行中导入的是Column（字段）、（Integer, String）字段类型、ForeignKey外键、create_engine创建数据库；使用declarative_base模块创建一个Base对象，这个在下面创建表的类中需要继承，在上面的代码中已经事先创建好了pymysql数据库，所以下面我们直接创建表以及插入数据：
1 class Host(Base): 2 __tablename__ = 'host' 3 h_id = Column(Integer,primary_key=True,autoincrement=True) 4 host_ip = Column(String(32)) 5 host_port = Column(Integer) 6 class HostUser(Base): 7 __tablename__ = 'hostuser' 8 u_id = Column(Integer,primary_key=True,autoincrement=True) 9 username = Column(String(32)) 10 password = Column(String(20)) 11 12 Base.metadata.create_all(engine)
解释说明：
这两个类是用来创建表使用的，每个类对应一个表，在类里面可以定义多个字段，在字段里面的参数可以设置多个（比如：主键、自增等）；最后一行才是把类创建成表并存到数据库，当你执行完代码之后，表已经创建了，那么下一步就是添加数据，看下面添加数据的代码：
1 Session = sessionmaker(bind=engine) 2 session = Session() 3 4 session.add(Host(host_ip = '1.1.1.4',host_port = 5555)) 5 6 session.add_all([ 7 Host(host_ip = '1.1.1.1',host_port = 22), 8 Host(host_ip = '1.1.1.2',host_port = 22), 9 Host(host_ip = '1.1.1.3',host_port = 22), 10 HostUser(username = 'ma',password = '123'), 11 HostUser(username = 'da',password = '123'), 12 ]) 13 session.commit()
插入数据有两种方式，一种是一次插入一条数据，使用的方法是add ; 第二种是一次插入多条数据，使用的方法是add_all;你需要注意的是最后要执行commit方法，不然，你上面做的一切都是白费的，提交不到数据库。
下面看一条查询的语句：
1 ret1 = session.query(Host.host_ip,Host.host_port).filter(Host.host_ip == '1.1.1.2').all() 2 print(ret1) 3 4 ret2 = session.query(Host.host_ip,Host.host_port).all() 5 print(ret2) 6 7 #输出结果 8 [('1.1.1.2', 22)] 9 [('1.1.1.1', 22), ('1.1.1.2', 22), ('1.1.1.3', 22), ('1.1.1.4', 5555)]
带filter的是查询一条条件语句，不带条件语句的就查询全部的数据，输出的格式是列表中嵌套元祖。
2、上面说了那么多，其实只是sqlalchemy操作数据库的简单的用法，下面我们说下稍微复杂一点的，连表操作：
一对多：
1 class HostUser(Base): 2 __tablename__ = 'hostuser' 3 u_id = Column(Integer,primary_key=True,autoincrement=True) 4 username = Column(String(32)) 5 password = Column(String(20)) 6 host_id = Column(Integer,ForeignKey('host.h_id')) 7 #创建虚拟关系relationship,跟foreignkey配合使用 8 host = relationship('Host',backref='hh') 9 10 session.add_all([ 11 HostUser(username = 'ma',password = '123',host_id = 1), 12 HostUser(username = 'da',password = '123',host_id = 2), 13 ]) 14 session.commit()
还有个Host类跟上面是一样的，其实创建这个表的字段也是一样的，只不过在里面增加了一个外键和关系，分别是第六行和第八行，外键的作用就是可以根据特定的字段去查询其它表中的字段，关系的作用下面列举一个例子，你就会明白， 我们先来说下通常我们所做的查询时正向的，什么是正向的呢！就像这个HostUser中有关系，从这个表去其它表中查询数据就是正向的，从其它表中查询数据，但是是通过这个关系去查询的，这样就叫做反向查询，下面我们看个例子：
1 #正向查询，有虚拟关系 2 ret = session.query(HostUser).all() 3 for obj in ret: 4 print(obj.username,obj.host.host_ip,obj.host.host_port) 5 6 输出结果： 7 ma 1.1.1.1 22 8 da 1.1.1.2 22
这个例子说的是有虚拟关系，但是使用的是正向查询，就是利用关系去查询用户所对应的IP地址和端口，下面再说反向查询的原始方式以及有关系的反向查询：
1 #反向查询的原始方式 2 ret1 = session.query(HostUser.u_id,HostUser.username).join(Host,isouter=True).filter(Host.host_ip == '1.1.1.2').all() 3 print(ret1) 4 5 #反向查询的虚拟关系查询,需要遍历 6 obj = session.query(Host).filter(Host.host_ip == '1.1.1.2').first() 7 print(obj.hh) 8 for ret in obj.hh: 9 print(ret.u_id,ret.username)
解释说明：
上面两个例子，第一个是反向查询的原始方式，查询的内容是属于1.1.1.2这台机器的所有用户和对应的用户id；其实使用虚拟关系进行查询就是去掉了join，使用生成的HostUser对象进行调用backref的值hh,就可以查出用户了，两种不同的方式输出的结果的如下：
1 [(4, 'da')] 2 [<__main__.HostUser object at 0x0000000003BBB080>] 3 4 da
多对多：
多对多的一个关键点是需要第三张表去做关系,下面列举一个例子，来阐述一下，在多对多的查询中使用关系与不使用关系的sql执行：
1 engine = create_engine("mysql+pymysql://mysql_test:123456@192.168.163.131:3306/orm_test") 2 Base = declarative_base() 3 4 class HostToHostUser(Base): 5 __tablename__ = 'host_to_host_user' 6 nid = Column(Integer, primary_key=True,autoincrement=True) 7 8 host_id = Column(Integer,ForeignKey('host.nid')) 9 host_user_id = Column(Integer,ForeignKey('host_user.nid')) 10 #多对多操作 11 host = relationship('Host',backref='h') 12 host_user = relationship('HostUser',backref='u') 13 14 15 class Host(Base): 16 __tablename__ = 'host' 17 nid = Column(Integer, primary_key=True,autoincrement=True) 18 hostname = Column(String(32)) 19 port = Column(String(32)) 20 ip = Column(String(32)) 21 ####最简单的方式,添加此行就行: 22 host_user=relationship('HostUser',secondary=HostToHostUser.__table__,backref='h') 23 24 class HostUser(Base): 25 __tablename__ = 'host_user' 26 nid = Column(Integer, primary_key=True,autoincrement=True) 27 username = Column(String(32)) 28 29 Base.metadata.create_all(engine) 30 Session = sessionmaker(bind=engine) 31 session = Session() 32 ''' 33 session.add_all([ 34 Host(hostname='c1',port='22',ip='1.1.1.1'), 35 Host(hostname='c2',port='22',ip='1.1.1.2'), 36 Host(hostname='c3',port='22',ip='1.1.1.3'), 37 Host(hostname='c4',port='22',ip='1.1.1.4'), 38 Host(hostname='c5',port='22',ip='1.1.1.5'), 39 ]) 40 session.commit() 41 42 43 session.add_all([ 44 HostUser(username='root'), 45 HostUser(username='db'), 46 HostUser(username='nb'), 47 HostUser(username='sb'), 48 ]) 49 session.commit() 50 51 session.add_all([ 52 HostToHostUser(host_id=1,host_user_id=1), 53 HostToHostUser(host_id=1,host_user_id=2), 54 HostToHostUser(host_id=1,host_user_id=3), 55 HostToHostUser(host_id=2,host_user_id=2), 56 HostToHostUser(host_id=2,host_user_id=4), 57 HostToHostUser(host_id=2,host_user_id=3), 58 ]) 59 session.commit() 60 '''
先使用类去创建三个表，那个HostToHostUser就是第三张表，用户存放其它两个表的外键和关系的；现在如果要查询c1主机对应的管理员账号，我们如果不用关系的话，应该是这样的：
1 #没有关系的原始方式 2 #1.先在host表中查询c1的nid 3 host_obj = session.query(Host).filter(Host.hostname=='c1').first() 4 #2.查询hosttohostuer表中的所有host_id等于c1的nid的对应的host_user_id 5 host_2_host_user = session.query(HostToHostUser.host_user_id).filter(HostToHostUser.host_id==host_obj.nid).all() 6 # print(host_2_host_user) 7 r=zip(*host_2_host_user) 8 # print(list(list(r)[0])) 9 #通过查到的host_user_id查询hostuser表中的对应的管理员用户名 10 users = session.query(HostUser.username).filter(HostUser.nid.in_(list(list(r)[0]))).all() 11 print(users) 12 13 #输出结果 14 [('root',), ('db',), ('nb',)]
里面说的很详细了，我就不再过多的阐述了，下面再看下有关系的查询：
1 # 1.反向查找,查询host表中c1的信息,会得到一个对象,对象中存在一个已经设置好的虚拟关系:h 2 host_obj = session.query(Host).filter(Host.hostname == 'c1').first() 3 #2.正向查找,遍历对象属性 4 for item in host_obj.h: 5 print(item.host_user.username) 6 7 #输出结果 8 root 9 db 10 nb
怎么样？这个方法是不是简单多了，其实我们在创建表的时候，也创建了一种更简单的方式，那就是把关系放在Host类中，，其实都差不多，都是遍历对象属性得到想要的结果。