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)