前言: 这篇博客主要介绍下SQLAlchemy及基本操作,写完后有空做个堡垒机小项目。有兴趣可看下python之数据库(mysql)操作。下篇博客整理写篇关于Web框架和django基础~~

一、ORM介绍

orm英文全称object relational mapping,就是对象映射关系程序,简单来说我们类似python这种面向对象的程序来说一切皆对象,但是我们使用的数据库却都是关系型的,为了保证一致的使用习惯,通过orm将编程语言的对象模型和数据库的关系模型建立映射关系,这样我们在使用编程语言对数据库进行操作的时候可以直接使用编程语言的对象模型进行操作就可以了,而不用直接使用sql语言。

orm的优点:

  • 隐藏了数据访问细节,“封闭”的通用数据库交互,ORM的核心。他使得我们的通用数据库交互变得简单易行,并且完全不用考虑该死的SQL语句。快速开发,由此而来。
  • ORM使我们构造固化数据结构变得简单易行。

缺点:

  • 无可避免的,自动化意味着映射和关联管理,代价是牺牲性能(早期,这是所有不喜欢ORM人的共同点)。现在的各种ORM框架都在尝试使用各种方法来减轻这块(LazyLoad,Cache),效果还是很显著的。

二、SQLAlchemy框架与数据库API

在Python中,最有名的ORM框架是SQLAlchemy。用户包括openstack\Dropbox等知名公司或应用,主要用户列表http://www.sqlalchemy.org/organizations.html#openstack

需要自己把数据库中的表映射成类,然后才能通过对象的方式去调用。SQLAlchemy不止可以支持MYSQL,还可以支持Oracle等。

Dialect用于和数据API进行交流,根据配置文件的不同调用不同的数据库API,从而实现对数据库的操作:

  1. MySQL-Python
  2.     mysql+mysqldb://<user>:<password>@<host>[:<port>]/<dbname>
  3.   
  4. pymysql
  5.     mysql+pymysql://<username>:<password>@<host>/<dbname>[?<options>]
  6.   
  7. MySQL-Connector
  8.     mysql+mysqlconnector://<user>:<password>@<host>[:<port>]/<dbname>
  9.   
  10. cx_Oracle
  11.     oracle+cx_oracle://user:pass@host:port/dbname[?key=value&key=value...]
  12.   
  13. 更多详见:http://docs.sqlalchemy.org/en/latest/dialects/index.html

安装SQLAlchemy:

  1. pip install SQLAlchemy

三、连接数据库并查询

  1. from sqlalchemy import create_engine
  2.  
  3. #连接数据库,生成engine对象;最大连接数为5个
  4. engine = create_engine("mysql+pymysql://root:root@127.0.0.1:3306/zcl", max_overflow=5)
  5. print(engine) #Engine(mysql+pymysql://root:***@127.0.0.1:3306/zcl)
  6. result = engine.execute('select * from students') #不用commit(),会自动commit
  7. print(result.fetchall())

输出:

  1. Engine(mysql+pymysql://root:***@127.0.0.1:3306/zcl)
  2. [(, 'zcl', 'man', , '', None), (, 'alex', 'man', , '', None), (, 'Jack', 'man', , '', 'CN'), (, 'Mary', 'female', , '', 'USA'), (, 'Jack', 'man', , '', 'CN'), (, 'Jack2', 'man', , '', 'CN'), (, 'Mary', 'female', , '', 'USA'), (, 'cjy', 'man', , '', 'USA'), (, 'cjy2', 'man', , '', 'USA'), (, 'cjy3', 'man', , '', 'USA'), (, 'cjy4', 'man', , '', 'USA'), (, 'cjy5', 'man', , '', 'USA')]

四、创建表

创建user与color表: 创建表时需要与MetaData的实例绑定。

  1. from sqlalchemy import create_engine, \
  2. Table, Column, Integer, String, MetaData, ForeignKey
  3.  
  4. metadata = MetaData() #相当于实例一个父类
  5.  
  6. user = Table('user', metadata, #相当于让Table继承metadata类
  7. Column('id', Integer, primary_key=True),
  8. Column('name', String(20)),
  9. )
  10.  
  11. color = Table('color', metadata, #表名color
  12. Column('id', Integer, primary_key=True),
  13. Column('name', String(20)),
  14. )
  15. engine = create_engine("mysql+pymysql://root:root@localhost:3306/zcl", max_overflow=5)
  16.  
  17. metadata.create_all(engine) #table已经与metadate绑定

查看创建的表:

五、增删改查

1. 先来了解下原生sql语句的增删改查:

  1. from sqlalchemy import create_engine, Table, Column, Integer, String, MetaData, ForeignKey,select
  2.  
  3. metadata = MetaData()
  4.  
  5. user = Table('user', metadata,
  6. Column('id', Integer, primary_key=True),
  7. Column('name', String(20)),
  8. )
  9.  
  10. color = Table('color', metadata,
  11. Column('id', Integer, primary_key=True),
  12. Column('name', String(20)),
  13. )
  14. engine = create_engine("mysql+pymysql://root:root@127.0.0.1:3306/zcl", max_overflow=5)
  15.  
  16. conn = engine.connect() #创建游标,当前实例所处状态
  17.  
  18. # 创建SQL语句,INSERT INTO "user" (id, name) VALUES (:id, :name)
  19. #id号可省略,默认是自增的
  20. # conn.execute(user.insert(), {'id': 1, 'name': 'zcl'})
  21. # conn.close()
  22.  
  23. # sql = user.insert().values(name='wu') #插入
  24. # conn.execute(sql)
  25. # conn.close()
  26.  
  27. #删除id号大于1的行,也可以where(user.c.name=="zcl")
  28. # sql = user.delete().where(user.c.id > 1)
  29. # conn.execute(sql)
  30. # conn.close()
  31.  
  32. # 将name=="wuu"更改为"name=="ed"
  33. # sql = user.update().where(user.c.name == 'wuu').values(name='ed')
  34. # conn.execute(sql)
  35. # conn.close()
  36.  
  37. #查询  下面不能写 sql = user.select... 会曝错
  38. #sql = select([user, ]) #[(1, 'zcl'), (9, 'ed'), (10, 'ed')]
  39. # sql = select([user.c.id, ]) #[(1,), (9,), (10,)]
  40. sql = select([user.c.name, color.c.name]).where(user.c.id==color.c.id)
  41. # sql = select([user.c.name]).order_by(user.c.name)
  42. # sql = user.select([user]).group_by(user.c.name)
  43.  
  44. result = conn.execute(sql)
  45. print(result.fetchall())
  46. conn.close()

2. 通过SQLAlchemy的增删改查(重要):

  1. from sqlalchemy import create_engine
  2. from sqlalchemy.ext.declarative import declarative_base
  3. from sqlalchemy import Column,Integer,String
  4. from sqlalchemy.orm import sessionmaker
  5.  
  6. Base = declarative_base()    #生成一个SqlORM基类(已经封装metadata)
  7. #echo=True可以查看创建表的过程
  8. engine = create_engine("mysql+pymysql://root:root@localhost:3306/zcl", echo=True)
  9.  
  10. class Host(Base):
  11. __tablename__ = 'hosts'   #表名为host
  12. id = Column(Integer, primary_key=True, autoincrement=True)
  13. hostname = Column(String(64), unique=True, nullable=False)
  14. ip_addr = Column(String(128), unique=True, nullable=False)
  15. port = Column(Integer, default=22)
  16.  
  17. Base.metadata.create_all(engine)   #创建所有表结构
  18.  
  19. if __name__ == '__main__':
  20. #创建与数据库的会话sessionclass,注意,这里返回给session的是个class类,不是实例
  21. SessionCls=sessionmaker(bind=engine)
  22. session=SessionCls()  #连接的实例
  23. #准备插入数据
  24. h1 = Host(hostname='localhost', ip_addr='127.0.0.1')   #实例化(未创建)
  25. h2 = Host(hostname='ubuntu', ip_addr='192.168.2.243', port=20000)
  26.  
  27. #session.add(h1)   #也可以用下面的批量处理
  28. #session.add_all([h1,h2])
  29. #h2.hostname='ubuntu_test'  #只要没提交,此时修改也没问题
  30.  
  31. #查询数据,返回一个对象
  32. obj = session.query(Host).filter(Host.hostname=="localhost").first()
  33. print("-->",obj)
  34. #[<__main__.Hostobjectat0x00000000048DC0B8>]如果上面为.all()
  35. #<__main__.Hostobjectat0x000000000493C208>如果上面为.first()
  36.  
  37. #如果用.all(),会曝错AttributeError:'list'objecthasnoattribute'hostname'
  38. #obj.hostname = "localhost_1"   #将主机名修改为localhost_1
  39.  
  40. session.delete(obj) #删除行
  41.  
  42. session.commit()#提交

操作结果截图:

六、外键关联

1. 创建主机表hosts与分组表group,并建立关联,即一个组可对应多个主机:

  1. from sqlalchemy import create_engine
  2. from sqlalchemy.ext.declarative import declarative_base
  3. from sqlalchemy import Column, Integer, String,ForeignKey
  4. from sqlalchemy.orm import sessionmaker,relationship
  5.  
  6. Base = declarative_base() # 生成一个SqlORM 基类(已经封闭metadata)
  7. #echo=True可以查看创建表的过程
  8. engine = create_engine("mysql+pymysql://root:root@localhost:3306/zcl", echo=True)
  9.  
  10. class Host(Base):
  11. __tablename__ = 'hosts' #表名
  12. id = Column(Integer, primary_key=True, autoincrement=True) #默认自增
  13. hostname = Column(String(64), unique=True, nullable=False)
  14. ip_addr = Column(String(128), unique=True, nullable=False)
  15. port = Column(Integer, default=22)
  16. #外键关联,主机与组名关联,一个组对应多个主机
  17. group_id = Column(Integer, ForeignKey("group.id"))
  18.  
  19. class Group(Base):
  20. __tablename__ = "group"
  21. id = Column(Integer,primary_key=True)
  22. name = Column(String(64), unique=True, nullable=False)
  23.  
  24. Base.metadata.create_all(engine) # 创建所有表结构
  25.  
  26. if __name__ == '__main__':
  27. # 创建与数据库的会话session class ,注意,这里返回给session的是个class,不是实例
  28. SessionCls = sessionmaker(bind=engine)
  29. session = SessionCls() #连接的实例
  30.  
  31. session.commit() #提交

查看结果:

问题: 查看新建的group表结构或从group表查询会发现desc group;select * from group都会曝错!!(为什么会产生这种错误可能是group与数据库有某些关联导致的,eg:group by... 我猜的)

解决方法: 用desc zcl.group; select * from zcl.group;  (zcl为数据库名)

2. 创建完表后就要在表中创建数据啦。接下来在hosts表与group表创建数据:

  1. from sqlalchemy import create_engine
  2. from sqlalchemy.ext.declarative import declarative_base
  3. from sqlalchemy import Column, Integer, String,ForeignKey
  4. from sqlalchemy.orm import sessionmaker
  5.  
  6. Base = declarative_base() # 生成一个SqlORM 基类(已经封闭metadata)
  7. #echo=True可以查看创建表的过程
  8. engine = create_engine("mysql+pymysql://root:root@localhost:3306/zcl", echo=True)
  9.  
  10. class Host(Base):
  11. __tablename__ = 'hosts' #表名
  12. id = Column(Integer, primary_key=True, autoincrement=True) #默认自增
  13. hostname = Column(String(64), unique=True, nullable=False)
  14. ip_addr = Column(String(128), unique=True, nullable=False)
  15. port = Column(Integer, default=22)
  16. #外键关联,主机与组名关联
  17. group_id = Column(Integer, ForeignKey("group.id"))
  18.  
  19. class Group(Base):
  20. __tablename__ = "group"
  21. id = Column(Integer,primary_key=True)
  22. name = Column(String(64), unique=True, nullable=False)
  23.  
  24. Base.metadata.create_all(engine) # 创建所有表结构
  25.  
  26. if __name__ == '__main__':
  27. # 创建与数据库的会话session class ,注意,这里返回给session的是个class,不是实例
  28. SessionCls = sessionmaker(bind=engine)
  29. session = SessionCls() #连接的实例
  30.  
  31. g1 = Group(name = "g1")
  32. g2 = Group(name = "g2")
  33. g3 = Group(name = "g3")
  34. g4 = Group(name = "g4")
  35. session.add_all([g1,g2,g3,g4])
  36.  
  37. #此时上面的g1,g2,g3三条记录还未存在,因为程序运行到这一行时还未commit(),故g1.id也未存在,但是下面一行代码是用到g1.id的!!经过测试: 运行时虽然不曝错,但关联不成功,如下图
  38. h1 = Host(hostname='localhost', ip_addr='127.0.0.1',group_id=g1.id)
  39. session.add(h1)
  40.  
  41. session.commit() #提交

经过测试: 运行时虽然不曝错,但关联不成功,如下图:

3. 现在问题又来了,hosts表中的group_id可是为空啊!! 这肯定不行的。现在如何在不删除hosts表数据的前提下,使group_id不为空(eg: 使group_id为4,与g4建立关联)??可用下面的代码:

  1. g4 = session.query(Group).filter(Group.name=="g4").first() #找到g4组的对象
  2. h = session.query(Host).filter(Host.hostname=="localhost").update({"group_id":g4.id}) #更新(修改)
  3. session.commit() #提交

4. 问题: 如何获取与主机关联的group_id??

  1. g4=session.query(Group).filter(Group.name=="g4").first()
  2. h=session.query(Host).filter(Host.hostname=="localhost").first()
  3. print("h1:",h.group_id)

好吧,我承认这个问题太简单了,通过上面的代码,找到主机的对象h, 则h.group_id就是答案。接下来的问题才是重点。

5. 此时可以获取已经关联的group_id,但如何获取已关联的组的组名??

  1. print(h.group.name) #AttributeError:'Host'object has no attribute 'group'

嗯,你是初学者,你当然会说通过过h.group.name就可以找到与主机关联的组名! BUT,这是不行的,会曝错,因为Host类根本就没有group属性!!

解决方法:

  • first:
  1. from sqlalchemy.orm import relationship #导入relationship
  • second:

在Host类中加入group = relationship("Group"):

  1. class Host(Base):
  2. __tablename__ = 'hosts' #表名
  3. id = Column(Integer, primary_key=True, autoincrement=True) #默认自增
  4. hostname = Column(String(64), unique=True, nullable=False)
  5. ip_addr = Column(String(128), unique=True, nullable=False)
  6. port = Column(Integer, default=22)
  7. #外键关联,主机与组名关联
  8. group_id = Column(Integer, ForeignKey("group.id"))
  9. group = relationship("Group")

此时再用print(h.group.name)就不会曝错啦!!

6. 哈哈,问题还没完呢。 前面已经实现:通过主机可查看对应组名,那么如何实现通过组名查看对应的主机??

经过前面5个点的历练,你已成为小小的老司机了,于是你很自信地说: 和第5个点一样,在Group类中加入hosts = relationship("Host");

  1. class Host(Base):
  2. __tablename__ = 'hosts' #表名
  3. id = Column(Integer,primary_key=True, autoincrement=True) #默认自增
  4. hostname = Column(String(64), unique=True, nullable=False)
  5. ip_addr = Column(String(128), unique=True, nullable=False)
  6. port = Column(Integer, default=22)
  7. #外键关联,主机与组名关联
  8. group_id = Column(Integer,ForeignKey("group.id"))
  9. group = relationship("Group")
  10.  
  11. class Group(Base):
  12. __tablename__ = "group"
  13. id = Column(Integer, primary_key=True)
  14. name = Column(String(64), unique=True, nullable=False)
  15. hosts = relationship("Host")
  16.  
  17. Base.metadata.create_all(engine) #创建所有表结构
  18.  
  19. g4 = session.query(Group).filter(Group.name=="g4").first()
  20. h = session.query(Host).filter(Host.hostname=="localhost").first()
  21. print("h1:",h.group_id) #h1: 4
  22. #此时可以获取已经关联的group_id,但如何获取已关联的组的组名
  23. print(h.group.name) #g4
  24. print("g4:",g4.hosts) #g4:[<__main__.Hostobjectat0x0000000004303860>]

7. 通过上面的两句代码可实现双向关联。但必须在两个表都加上一句代码才行,有没有办法只用一句代码就实现双向关联?? 当然有,老司机会这么做:

在Host类中加入下面这句代码,即可实现双向关联:

  1. group=relationship("Group",backref="host_list")

八、合并查询join

合并查询分为: inner join、left outer join、right outer join、full outer join

下面的例子可以让你完全理解join: http://stackoverflow.com/questions/38549/what-is-the-difference-between-inner-join-and-outer-join

关于join的原生sql操作:

在SQLAlchemy实现sql.join:

  1. obj = session.query(Host).join(Host.group).all() #相当于inner join
  2. print("-->obj:",obj)

九、分类聚合group by

group by是啥意思呢? 我说下我的理解吧,group即分组,by为通过;合起来即: 通过XX分组;

举个例子吧,现在有两张表,分别是主机表与分组表。两表已经通过group_id建立关联,分组表中有4个数据,分别为g1,g2,g3,g4; id分别为1,2,3,4; 而主机表有3个数据,group_id分别为4,3,4; id分别为1,2,4; 现在对hosts表执行group by命令,进行分类聚合。

具体请看下图:

对应SQLAlchemy语句:

  1. obj1 = session.query(Host).join(Host.group).group_by(Group.name).all() #分类聚合
  2. print("-->obj1:",obj1)

对应SQLAlchemy语句:

  1. obj2 = session.query(Host,func.count(Group.name)).join(Host.group).group_by(Group.name).all()
  2. print("-->obj2:",obj2)
  3.  
  4. 输出:
  5. -->obj2: [(<__main__.Host object at 0x0000000003C854A8>, 1), (<__main__.Host object at 0x0000000003C85518>, 2)]

十、多对多关联

多对多关联,即: 一个主机h1可对应在多个组(g1,g2),一个组(g1)可对应多个主机(h1,h2)

  1. 想实现如下的多对多关联,需要一张中间表。Eg:
  2. h1 g1
  3. h1 g2
  4. h2 g1
  5.  
  6. Host
  7. h1
  8. h2
  9. h3
  10. Group
  11. g1
  12. g2
  13. g3
  14.  
  15. HostToGroup中间表(实现多对多关联,sqlalchemy也是这样实现的)
  16. id host_id group_id
  17. 1 1 1
  18. 2 1 2
  19. 3 2 1

虽然有了中间表,但如果想查看一个组对应的所有主机名或者一个主机对应的所有组,还是需要Group/Host与中间表进行一系列的关联操作(join~), 但SqlAlchemy简化了关联操作!!

调用下面命令便会自动关联中间表:

  1. Host.groups()  #查看一个主机对应所有组
  2. Group.hosts()

SQLAlchemy是如何实现多对多关联的??

1. 建立中间表,关联其它两个表

  1. from sqlalchemy import create_engine,func,Table
  2. from sqlalchemy.ext.declarative import declarative_base
  3. from sqlalchemy import Column, Integer, String,ForeignKey
  4. from sqlalchemy.orm import sessionmaker,relationship
  5.  
  6. Base = declarative_base() # 生成一个SqlORM 基类(已经封闭metadata)
  7. #echo=True可以查看创建表的过程
  8. engine = create_engine("mysql+pymysql://root:root@localhost:3306/zcl", echo=True)
  9.  
  10. #直接创建表并返回表的实例 Host2Group主动关联Host与Group(被关联)
  11. Host2Group = Table('host_to_group',Base.metadata,
  12. Column('host_id',ForeignKey('host.id'),primary_key=True),
  13. Column('group_id',ForeignKey('group.id'),primary_key=True),
  14. #一个表为什么能创建两个主键(其实是两个列同时作为主键,非空且唯一)
  15. #PRIMARY KEY (host_id, group_id),
  16. )

2. 在Host表(或Group表)指定中间表的实例,加上backref就不用在Group表中指定

  1. #声明表的映射关系
  2. class Host(Base):
  3. __tablename__ = 'host' #表名
  4. id = Column(Integer, primary_key=True, autoincrement=True) #默认自增
  5. hostname = Column(String(64), unique=True, nullable=False)
  6. ip_addr = Column(String(128), unique=True, nullable=False)
  7. port = Column(Integer, default=22)
  8. #外键关联,主机与组名关联
  9. #group_id = Column(Integer, ForeignKey("group.id"))
  10. groups = relationship("Group", #关联Group表
  11. secondary = Host2Group, #关联第三方表
  12. backref = "host_list") #双向关联,不用在Group类中再加这句代码
  13.  
  14. def __repr__(self):
  15. return "<id=%s,hostname=%s,ip_addr=%s>" % (self.id,
  16. self.hostname,
  17. self.ip_addr)

3. 创建组与主机

  1. if __name__ == '__main__':
  2. SessionCls = sessionmaker(bind=engine)
  3. session = SessionCls()
  4. """
  5. g1 = Group(name = "g1")
  6. g2 = Group(name = "g2")
  7. g3 = Group(name = "g3")
  8. g4 = Group(name = "g4")
  9. session.add_all([g1,g2,g3,g4])
  10. """
  11. """
  12. h1 = Host(hostname="h1",ip_addr="10.1.1.1")
  13. h2 = Host(hostname="h2",ip_addr="10.1.1.2",port=10000)
  14. h3 = Host(hostname="h3",ip_addr="10.1.1.3",port=6666)
  15. session.add_all([h1,h2,h3])
  16. """

4. 建立关联与查询

  1. """
  2. groups = session.query(Group).all()
  3. h1 = session.query(Host).filter(Host.hostname=="h1").first()
  4. h1.groups = groups #将h1关联到所有的组
  5. print("-->:",h1.groups)
  6. h1.groups.pop() #删除一个关联
  7. """
  8. h2 = session.query(Host).filter(Host.hostname=="h2").first()
  9. #h2.groups = groups[1:-1] #将h2关联到组(2和3)
  10. print("=======>h2.groups:",h2.groups)
  11. #=======>h2.groups: [<__main__.Group object at 0x00000000044A3F98>,
  12. # <__main__.Group object at 0x00000000044A3FD0>]
  13. #加上__repr__()后,变为=======>h2.groups: [<id=2,name=g2>, <id=3,name=g3>]
  14.  
  15. g1 = session.query(Group).first()
  16. print("=======>g1:",g1.host_list)
  17. #=======>g1: [<id=1,hostname=h1,ip_addr=10.1.1.1>]
  18. session.commit()

测试截图:

查看表结构:

查看表内容:

查看第三方表:

完整例子:

  1. from sqlalchemy import create_engine,func,Table
  2. from sqlalchemy.ext.declarative import declarative_base
  3. from sqlalchemy import Column, Integer, String,ForeignKey
  4. from sqlalchemy.orm import sessionmaker,relationship
  5.  
  6. Base = declarative_base() # 生成一个SqlORM 基类(已经封闭metadata)
  7. #echo=True可以查看创建表的过程
  8. engine = create_engine("mysql+pymysql://root:root@localhost:3306/zcl", echo=True)
  9.  
  10. #直接创建表并返回表的实例 Host2Group主动关联Host与Group(被关联)
  11. Host2Group = Table('host_to_group',Base.metadata,
  12. Column('host_id',ForeignKey('host.id'),primary_key=True),
  13. Column('group_id',ForeignKey('group.id'),primary_key=True),
  14. #一个表为什么能创建两个主键(其实是两个列同时作为主键,非空且唯一)
  15. #PRIMARY KEY (host_id, group_id),
  16. )
  17.  
  18. #声明表的映射关系
  19. class Host(Base):
  20. __tablename__ = 'host' #表名
  21. id = Column(Integer, primary_key=True, autoincrement=True) #默认自增
  22. hostname = Column(String(64), unique=True, nullable=False)
  23. ip_addr = Column(String(128), unique=True, nullable=False)
  24. port = Column(Integer, default=22)
  25. #外键关联,主机与组名关联
  26. #group_id = Column(Integer, ForeignKey("group.id"))
  27. groups = relationship("Group", #关联Group表
  28. secondary = Host2Group, #关联第三方表
  29. backref = "host_list")#双向关联,不用在Group类中再加这句代码
  30.  
  31. def __repr__(self):
  32. return "<id=%s,hostname=%s,ip_addr=%s>" % (self.id,
  33. self.hostname,
  34. self.ip_addr)
  35.  
  36. class Group(Base):
  37. __tablename__ = "group"
  38. id = Column(Integer,primary_key=True)
  39. name = Column(String(64), unique=True, nullable=False)
  40.  
  41. def __repr__(self):
  42. return "<id=%s,name=%s>" % (self.id, self.name)
  43.  
  44. Base.metadata.create_all(engine) # 创建所有表结构
  45.  
  46. if __name__ == '__main__':
  47. SessionCls = sessionmaker(bind=engine)
  48. session = SessionCls()
  49. """
  50. g1 = Group(name = "g1")
  51. g2 = Group(name = "g2")
  52. g3 = Group(name = "g3")
  53. g4 = Group(name = "g4")
  54. session.add_all([g1,g2,g3,g4])
  55. """
  56. """
  57. h1 = Host(hostname="h1",ip_addr="10.1.1.1")
  58. h2 = Host(hostname="h2",ip_addr="10.1.1.2",port=10000)
  59. h3 = Host(hostname="h3",ip_addr="10.1.1.3",port=6666)
  60. session.add_all([h1,h2,h3])
  61. """
  62. """
  63. groups = session.query(Group).all()
  64. h1 = session.query(Host).filter(Host.hostname=="h1").first()
  65. h1.groups = groups #将h1关联到所有的组
  66. print("-->:",h1.groups)
  67. h1.groups.pop() #删除一个关联
  68. """
  69. h2 = session.query(Host).filter(Host.hostname=="h2").first()
  70. #h2.groups = groups[1:-1]
  71. print("=======>h2.groups:",h2.groups)
  72. #=======>h2.groups: [<__main__.Group object at 0x00000000044A3F98>,
  73. # <__main__.Group object at 0x00000000044A3FD0>]
  74. #加上__repr__()后,变为=======>h2.groups: [<id=2,name=g2>, <id=3,name=g3>]
  75.  
  76. g1 = session.query(Group).first()
  77. print("=======>g1:",g1.host_list)
  78. #=======>g1: [<id=1,hostname=h1,ip_addr=10.1.1.1>]
  79. session.commit()

转发注明出处: http://www.cnblogs.com/0zcl/p/6504696.html

python之SQLAlchemy ORM 上的更多相关文章

  1. python之SQLAlchemy ORM

    前言: 这篇博客主要介绍下SQLAlchemy及基本操作,写完后有空做个堡垒机小项目.有兴趣可看下python之数据库(mysql)操作.下篇博客整理写篇关于Web框架和django基础~~ 一.OR ...

  2. Python 9 sqlalchemy ORM

    一.ORM介绍: orm英文全称object relational mapping,就是对象映射关系程序,简单来说我们类似python这种面向对象的程序来说一切皆对象,但是我们使用的数据库却都是关系型 ...

  3. python 学习笔记十一 SQLALchemy ORM(进阶篇)

    SqlAlchemy ORM SQLAlchemy是Python编程语言下的一款ORM框架,该框架建立在数据库API之上,使用关系对象映射进行数据库操作,简言之便是:将对象转换成SQL,然后使用数据A ...

  4. python 之路,Day11 (下)- sqlalchemy ORM

    python 之路,Day11 - sqlalchemy ORM   本节内容 ORM介绍 sqlalchemy安装 sqlalchemy基本使用 多外键关联 多对多关系 表结构设计作业 1. ORM ...

  5. Python SQLAlchemy ORM示例

    SQLAlchemy的是Python的SQL工具包和对象关系映射,给应用程序开发者提供SQL的强大功能和灵活性. 安装 pip install mysql-python pip install sql ...

  6. python 之路,Day11(上) - python mysql and ORM

    python 之路,Day11 - python mysql and ORM   本节内容 数据库介绍 mysql 数据库安装使用 mysql管理 mysql 数据类型 常用mysql命令 创建数据库 ...

  7. Sqlalchemy python经典第三方orm

    Ⅰ. 安装 pip install sqlalchemy Ⅱ. 起步链接 import time import threading import sqlalchemy from sqlalchemy ...

  8. Python sqlalchemy orm 多对多外键关联

    多对多外键关联 注:使用三张表进行对应关联 实现代码: # 创建3个表 配置外键关联 # 调用Column创建字段 加类型 from sqlalchemy import Table, Column, ...

  9. SQLAlchemy(1) -- Python的SQLAlchemy和ORM

    Python的SQLAlchemy和ORM(object-relational mapping:对象关系映射) web编程中有一项常规任务就是创建一个有效的后台数据库.以前,程序员是通过写sql语句, ...

随机推荐

  1. AutoLayout没有相对比例布局

    怎么实现相对比例布局 比如我一个控件相对上边距的位置在整个屏幕的比例 可以用stack view来管理相对布局

  2. Android测试点

    记录下之前项目测试中涉及到的Android测试点: 1.APP基本功能 按照back log整理测试用例,测试中发现有需求变动.或未考虑完全,及时更新测试用例. 测试用例包括:全功能点用例+重点功能快 ...

  3. [ Android 五种数据存储方式之一 ] —— SharedPreferences存储数据

    SharedPreferences类,它是一个轻量级的存储类,特别适合用于保存软件配置参数. 主要是保存一些常用的配置比如窗口状态,一般在Activity中 重载窗口状态onSaveInstanceS ...

  4. 第一部分 记事本搞定第一个C#程序和编译过程剖析

    记事本搞定第一个C#程序 进行下面三个步骤:编码,编译和托管运行. 1.记事本进行编码: using System; class Program{ public static void Main() ...

  5. NodeJS异步I/O解析

    在现在的项目开发中,任何一个大型项目绝对不是简简单单的采用一个种语言和一种框架,因为每种语言和框架各有优势,与其死守一个,不与取各家之所长,依次得到一个高性能.搞扩展的产品. 对于一个.NET开发者, ...

  6. js运算符单竖杠“|”的作用

    在js整数操作的时候,相当于去除小数点,parseInt.在正数的时候相当于Math.floor(),负数的时候相当于Math.ceil() 注: 1. Math.ceil()用作向上取整. 2. M ...

  7. 照片提取GPS 转成百度地图坐标

    感谢: 小慧only http://www.cnblogs.com/zhaohuionly/p/3142623.html  GPS转化坐标方法 大胡子青松 http://www.cnblogs.com ...

  8. AtomicInteger相关类

    引用地址:http://blog.csdn.net/xh16319/article/details/17056767 在java6以后我们不但接触到了Lock相关的锁,也接触到了很多更加乐观的原子修改 ...

  9. 利用终端命令实现进入ntfs分区有两种方法。

    一.手动设置ubuntu自动挂载Windows分区方法:1.先用FDISK命令查看一下磁盘的UUID $sudo fdisk -l /dev/sda1 * 1 851 6835626 83 Linux ...

  10. 【java设计模式】之 建造者(Builder)模式

    我们还是举上一节的例子:生产汽车.上一节我们通过模板方法模式控制汽车跑起来的动作,那么需求是无止境的,现在如果老板又增加了额外的需求:汽车启动.停止.鸣笛引擎声都由客户自己控制,他想要什么顺序就什么顺 ...