Python-ORM之sqlalchemy的简单使用

ORM之sqlalchemy

基础章节

使用SQLAlchemy链接数据库

from sqlalchemy import create_engine
from sqlalchemy.ext.declarative import declarative_base

engine = create_engine("mysql+pymysql://root:Leon@localhost/study?charset=utf8",encoding='utf-8',echo=True)
Base = declarative_base()

创建数据表

from sqlalchemy import Column, Integer, String

class User(Base):
    __tablename__ = 'user'  # 表名
    # 各个字段
    id = Column(Integer, primary_key=True) # 主键
    name = Column(String(32))
    password = Column(String(64))

    def __repr__(self):  # 返回数据定义
        return "[%s,%s,%s]"%(self.id,self.name,self.password)

Base.metadata.create_all(engine)  # 创建表结构

• 其他的一些经常用到的地方

        # Column中还可以设定是否唯一：unique=True
        # 设置值不为空：nullable=False
        # 时间格式为：DateTime
        # 枚举值：Column(Enum("1","2","3"))
        # 布尔值：Boolean，表现形式为True/False

添加数据

Session_class = sessionmaker(bind=engine)  # 创建与数据库的会话session class ,注意,这里返回给session的是个class,不是实例
session = Session_class()  # 生成session实例

#add
user_obj = User(name="Leon", password="123456")
user_obj1 = User(name="张三", password="156")
session.add_all([user_obj,user_obj1])  #添加
# session.add(obj1)这样可以单个的添加
session.comiit() #事务提交

查询数据

# 返回数据需要在类中的__repr__中设定
session.query(User).filter(User.name=="Leon").first()  # 查询第一个
session.query(User).filter(User.name=="Leon").all()  # 查询多个，返回一个可循环列表对象
# 多个查询使用多个filter进行过滤
# 也可以在filter中用逗号`,`来and匹配

数据修改

user_obj = session.query(User).filter(User.name=="Leon").first()
user_obj.password = "NewPassword"
session.comiit()

数据删除

obj = session.query(User).filter(User.name=="Leon").first()
session.delete(obj)
session.commit()

统计

print(session.query(User).filter(User.name=="Leon").count())

分组

from sqlalchemy import func
print(session.query(func.count(User.name),User.name).group_by(User.name).all())

深入章节

外键关联

1.设置外键

+ 场景：一个学生拥有多个上课记录
+ 数据库表结构

class Student(Base):
    __tablename__ = "student"
    id = Column(Integer,primary_key=True)
    name = Column(String(32),nullable=False)
    register_data = Column(DATE,nullable=False)

    def __repr__(self):
        return "%s,%s" % (self.id, self.name)

class StudyRecord(Base):
    __tablename__ = 'study_record'
    id = Column(Integer, primary_key=True)
    day = Column(Integer,nullable=False)
    status = Column(String(32),nullable=False)
    stu_id = Column(Integer,ForeignKey('student.id'))
    # 加上一个关系,在这个表中可以通过student来反查student表中的数据，而在student表中可以通过my_study_record来反查StudyRecord中的数据
    student = relationship("Student",backref="my_study_record")

    def __repr__(self):
        return "%s day:%s status: %s"%(self.student.name,self.day,self.status)

2.在表中查询数据

# 查询某个人的上课记录
stu_obj = session.query(Student).filter(Student.name=="Leon").first()
print(stu_obj.my_study_record)  # 在student表中通过my_study_record来反查StudyRecord中的数据，显示跟局repr来定，此处返回字符串

# 连表反向查询，查询没来上课的人
record_obj = session.query(StudyRecord).filter(StudyRecord.status=="NO").first()
print(record_obj.student)

多外键关联

1.多外键

• 场景：一个电商用户，拥有两个地址，一个用来收取商品、另外一个用来邮寄账单
• 数据库表结构设计：
  
  

class Customer(Base):
    __tablename__ = 'customer'
    id = Column(Integer, primary_key=True)
    name = Column(String(64))
    billing_address_id = Column(Integer, ForeignKey("address.id"))
    shipping_address_id = Column(Integer, ForeignKey("address.id"))
    # 一个人对应一个账单地址和一个购物地址
    address_b = relationship("Address",backref="my_addr_bill",foreign_keys=[billing_address_id])
    address_s = relationship("Address",backref="my_addr_shop",foreign_keys=[shipping_address_id])

    def __repr__(self):
        return "name:%s"%self.name

class Address(Base):
    __tablename__ = 'address'
    id = Column(Integer, primary_key=True)
    street = Column(String(64))
    city = Column(String(64))
    state = Column(String(64))

    def __repr__(self):
        return "street:%s|city:%s|state:%s"%(self.street,self.city,self.state)

2.添加数据

a1 = Address(street='望京',city='北京',state="中国")
a2 = Address(street='雁塔',city='西安',state="中国")
a3 = Address(street='太原',city='山西',state="中国")
session.add_all([a1,a2,a3])
c1 = Customer(name="Leon",address_b=a1,address_s=a2)
c2 = Customer(name="eric",address_b=a1,address_s=a3)
session.add_all([c1,c2])
session.commit()

3.在此表中查询数据

# 通过名字直接查询他的两个地址
customer_obj = session.query(Customer).filter(Customer.name=="Leon").first()
print(customer_obj.address_b,customer_obj.address_s)
# 通过地址查询该地址属于谁
Add_obj = session.query(Address).filter(Address.city=="北京").first()
print(Add_obj.my_addr_bill)

多对多关联

1.创建表结构

• 场景：一个作者可以写很多本书，一本书有多个做这个
• 数据库关系：
  
  

# 一个作者可以出版很多本书，一本书有很多个作者，直接用第三张表来讲作者表和图书表关联起来

class Author(Base):
    __tablename__ = 'authors'
    id = Column(Integer, primary_key=True)
    name = Column(String(32))  # 作者

    def __repr__(self):
        return self.name

book_m2m_author = Table('book_m2m_author', Base.metadata,
                        Column('book_id',Integer,ForeignKey('books.id')),
                        Column('author_id',Integer,ForeignKey('authors.id')),
                        )

class Book(Base):
    __tablename__ = 'books'
    id = Column(Integer,primary_key=True)
    name = Column(String(64))
    pub_date = Column(DATE)  # 出版日期
    authors = relationship('Author',secondary=book_m2m_author,backref='books')

    def __repr__(self):
        return self.name

2.添加数据

# 添加数据
b1 = Book(name='Python',pub_date='2017-08-29')
b2 = Book(name='Linux',pub_date='2011-5-2')
b3 = Book(name='PHP',pub_date='2012-3-9')
b4 = Book(name='Java',pub_date='2015-11-2')

a1 = Author(name="Leon")
a2 = Author(name="Jack")
a3 = Author(name="Rain")

#建立关系
b1.authors=[a1,a2]
b2.authors=[a1,a3]
b3.authors=[a2,a3]
b4.authors=[a1,a2,a3]

Session_class = sessionmaker(bind=engine)
session = Session_class()
session.add_all([b1,b2,b3,b4,a1,a2,a3])
session.commit()

3.数据查询

book_obj = session.query(Book).filter(Book.name=='Python').first()
print(book_obj.authors)

authors_obj = session.query(Author).filter(Author.name=="Leon").first()
print(authors_obj.books)

4.此时删除数据

• 删除一本书中的某一个作者

author_obj =s.query(Author).filter_by(name="Jack").first()

book_obj = s.query(Book).filter_by(name="Python").first()

book_obj.authors.remove(author_obj) #从一本书里删除一个作者
session.commit()

• 直接删除作者或者一本书，这样book_m2m_author表中的数据也会自动更新

author_obj =s.query(Author).filter_by(name="Alex").first()
session.delete(author_obj)
session.commit()