python之 sqlalchemy

one To many

 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
 """
 @author: zengchunyun
 """
 from sqlalchemy import Column, Integer, String, Float, DateTime, ForeignKey
 from sqlalchemy.orm import sessionmaker, relationship, backref
 from sqlalchemy.ext.declarative import declarative_base
 from sqlalchemy import create_engine

 Base = declarative_base()
 engine = create_engine('mysql+pymysql://root:123@127.0.0.1:3306/day11',echo=True)

 class Child(Base):
     __tablename__ = 'child'  # 表名
     id = Column(Integer, primary_key=True)  # 表字段
     parent_id = Column(Integer, ForeignKey('parent.id'))  # 外键最好不要直接用类名.字段形式,避免类还没有实例化,最好以表名.字段形式
     # 外键关联到另一张表的id字段,通过查找parent_id字段可以找到父亲是谁
     parent = relationship('Parent')  # 通过查到儿子后,通过儿子.parent.name 可以找到父亲是谁,实例相当于儿子.parent等于Parent类.类直接访问自己的name属性

 class Parent(Base):
     __tablename__ = 'parent'
     id = Column(Integer, primary_key=True)
     name = Column(String(64))
     # children = relationship(Child)  # 当设置外键时,第一张表如果是先创建,可以使用类名形式关系映射,否则会造成未声明先引用,最好以表名.字段进行关系映射
     # 这个是单向映射关联,即一个父亲对应多个儿子,或者多个儿子对应一个父亲

 Base.metadata.create_all(engine)

 DBSession = sessionmaker()
 DBSession.configure(bind=engine)
 session = DBSession()  # 打开数据连接

 ret = session.query(Child).filter(Child.id==1).one()
 print(ret.parent.name)
 ret = session.query(Parent).filter(Parent.id == 1).one()
 print(ret.name)

one to many

 class Parent(Base):
     __tablename__ = 'parent'  # 表名
     id = Column(Integer, primary_key=True)
     name = Column(String(64))
     children = relationship('Child', back_populates='parent')  # 第一个参数为类名,当被关联的表先创建时,可以直接写类名,否则只能写字符串形式名字
     # 第二个参数为双向one-to-many关系,即反向的many-to-one

     def __repr__(self):
         return "id: {}, name: {}".format(self.id, self.name)

 class Child(Base):
     __tablename__ = 'child'
     id = Column(Integer, primary_key=True)
     name = Column(String(43))
     parent_id = Column(Integer, ForeignKey('parent.id'))
     parent = relationship('Parent', back_populates='children')

     def __repr__(self):
         return "id: {}, parent_id: {}, ".format(self.id, self.parent_id)

 ret = session.query(Parent).filter(Parent.id ==1).all()
 print(ret)
 print(ret[0].children)  # 通过父亲找儿子

 ret = session.query(Child).filter(Child.parent_id == Parent.id).all()
 print(ret)
 print(ret[0].parent.name)  # 通过儿子找父亲

one to many，这个效果与上面这个实例一样，这样可以少写一个

 # children = relationship('Child', back_populates='parent') 映射关系

 class Parent(Base):
     __tablename__ = 'parent'  # 表名
     id = Column(Integer, primary_key=True)
     name = Column(String(64))
     # children = relationship('Child', back_populates='parent')  # 第一个参数为类名,当被关联的表先创建时,可以直接写类名,否则只能写字符串形式名字
     # 第二个参数为双向one-to-many关系,即反向的many-to-one

     def __repr__(self):
         return "id: {}, name: {}".format(self.id, self.name)

 class Child(Base):
     __tablename__ = 'child'
     id = Column(Integer, primary_key=True)
     name = Column(String(43))
     parent_id = Column(Integer, ForeignKey('parent.id'))
     parent = relationship('Parent', backref='children')

     def __repr__(self):
         return "id: {}, parent_id: {}, ".format(self.id, self.parent_id)

one to many, 通过父亲查多个儿子

 class Child(Base):
     __tablename__ = 'child'  # 表名
     id = Column(Integer, primary_key=True)  # 表字段
     name = Column(String(43))
     parent_id = Column(Integer, ForeignKey('parent.id'))  # 设置child表的字段parent_id为外键关联到parent表的id

 class Parent(Base):
     __tablename__ = 'parent'
     id = Column(Integer, primary_key=True)
     name = Column(String(64))
     children = relationship('Child')  # 通过关系映射,将children映射到child表,这样可以查到父亲下有几个儿子了,

 ret = session.query(Parent).filter(Parent.id ==1).one()
 print(ret)
 print(ret.children)
 print(ret.children[0].name)