Python SQLAlchemy

SQLAlchemy

 

SQLAlchemy是Python编程语言下的一款ORM框架，该框架建立在数据库API之上，使用关系对象映射进行数据库操作，简言之便是：将对象转换成SQL，然后使用数据API执行SQL并获取执行结果。

对象映射关系（ORM）

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

优点：

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

缺点：

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

 

sqlalchemy安装

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

MySQL-Python
    mysql+mysqldb://<user>:<password>@<host>[:<port>]/<dbname>
 
pymysql
    mysql+pymysql://<username>:<password>@<host>/<dbname>[?<options>]
 
MySQL-Connector
    mysql+mysqlconnector://<user>:<password>@<host>[:<port>]/<dbname>
 
cx_Oracle
    oracle+cx_oracle://user:pass@host:port/dbname[?key=value&key=value...]
 
更多详见：http://docs.sqlalchemy.org/en/latest/dialects/index.html

注：支持连接MySQL、Oracles数据库

 

安装：

pip install SQLAlchemy
pip install pymysql 
#由于mysqldb依然不支持py3，所以这里我们用pymysql与sqlalchemy交互

基本使用

创建表结构

#!/usr/bin/env python
# -*- coding: UTF-8 -*-

import sqlalchemy
from sqlalchemy import create_engine
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import Column, Integer, String
from sqlalchemy.orm import sessionmaker

engine = create_engine("mysql+pymysql://root@192.168.91.92/sxl", encoding="utf-8", echo=True)  # echo=True 打印程序运行详细信息

Base = declarative_base()  # 生成orm基类


class User(Base):
    __tablename__ = "user"  # 表名
    id = Column(Integer, primary_key=True)
    name = Column(String(32))
    password = Column(String(64))

class color(Base):
    __tablename__ = "color"  # 表名
    id = Column(Integer, primary_key=True)
    name = Column(String(32))
    password = Column(String(64))


Base.metadata.create_all(engine)

 创建数据

最基本的表我们创建好了，那我们开始用orm创建一条数据试试

from sqlalchemy import  create_engine
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import String,Integer,Column
from sqlalchemy.orm import sessionmaker
 
engine = create_engine("mysql+pymysql://root@192.168.91.92/sxl",
                       encoding="utf-8")
 
Base = declarative_base()   #生成orm基类
 
class User(Base):
    __tablename__ = "user"      #表名
    id = Column(Integer,primary_key=True)
    name = Column(String(32))
    password = Column(String(64))
 
#Base.metadata.create_all(engine)    #创建表结构
 
Session_class = sessionmaker(bind=engine)   #Session_class现在不是实例，而是类
Session = Session_class()   #生成Session实例
 
user_obj = User(name="sxl",password="123")   #生成你要创建的数据对象
print(user_obj.name,user_obj.id)  #此时还没创建对象呢，不信你打印一下id发现还是None
 
Session.add(user_obj) #把要创建的数据对象添加到这个session里， 一会统一创建
print(user_obj.name,user_obj.id) #此时也依然还没创建
 
Session.commit()    #现此才统一提交，创建数据

 增删改查

from sqlalchemy import  create_engine
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import String,Integer,Column
from sqlalchemy.orm import sessionmaker
 
engine = create_engine("mysql+pymysql://root@192.168.91.92/sxl",
                       encoding="utf-8")
 
Base = declarative_base()   #生成orm基类
 
class User(Base):
    __tablename__ = "user"      #表名
    id = Column(Integer,primary_key=True)
    name = Column(String(32))
    password = Column(String(64))
 
#Base.metadata.create_all(engine)    #创建表结构
 
Session_class = sessionmaker(bind=engine)   #Session_class现在不是实例，而是类
Session = Session_class()   #生成Session实例
 
#添加数据
user_obj = User(name="sxl",password="123")   #生成你要创建的数据对象
Session.add(user_obj) #把要创建的数据对象添加到这个session里， 一会统一创建
Session.commit()    #现此才统一提交，创建数据


#查询数据
myuser=Session.query(user).filter(user.password=='123').first()
print(myuser)  #myuser现在是一个对象
print(myuser.id,myuser.name,myuser.password)

#修改数据
myuser.name='abc'
Session.commit()

#删除数据
Session.delete(myuser)
Session.commit()

 回滚

Session.rollback()

获取所有数据

print(Session.query(myuser.name,myuser.password).all()

多条件查询

 Session.query(user).filter(user.id>0).filter(user.id<7).all()

统计和分组

Session.query(user).filter(user.name.like("Ra%")).count()

分组

from sqlalchemy import func
print(Session.query(func.count(user.name),user.name).group_by(user.name).all() )

 

外键关联

我们先创建个study_record表与student进行关联

 

from sqlalchemy import create_engine
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import String,Column,Integer,ForeignKey,DATE
from sqlalchemy.orm import sessionmaker,relationship
 
engine = create_engine("mysql+pymysql://root:zyw@123@192.168.0.59/lzl",
                       encoding="utf-8")
 
Base = declarative_base()
 
class Student(Base):
    __tablename__ ="student"
    id = Column(Integer,primary_key=True)
    name = Column(String(32),nullable=False)
    register_date = Column(DATE,nullable=False)
 
    def __repr__(self):
        return "<%s name:%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表里的id
 
    my_student = relationship("Student",backref="my_study_record") # Student为关联的类
def __repr__(self):
        return "<%s name:%s>" % (self.id, self.name)
 
Base.metadata.create_all(engine)
 
Session_class = sessionmaker(bind=engine)
session = Session_class()
 
s1 = Student(name="lzl",register_date="2016-10-26")
s2 = Student(name="alex",register_date="2015-10-26")
s3 = Student(name="eric",register_date="2014-10-26")
s4 = Student(name="rain",register_date="2013-10-26")
 
r1 = StudyRecord(day=1,status="YES",stu_id=1)
r2 = StudyRecord(day=2,status="No",stu_id=1)
r3 = StudyRecord(day=3,status="YES",stu_id=1)
r4 = StudyRecord(day=1,status="YES",stu_id=2)
 
session.add_all([s1,s2,s3,s4,r1,r2,r3,r4])
session.commit()

 

注：my_student = relationship("Student",backref="my_study_record")这个nb，允许你在user表里通过backref字段反向查出所有它在addresses表里的关联项

 

Session_class = sessionmaker(bind=engine)
session = Session_class()
 
stu_obj = session.query(Student).filter(Student.name=="lzl").first()
print(stu_obj)
#<id:1 name:lzl>
 
print(stu_obj.my_study_record)

 

多外键关联

下表中，Customer表有2个字段都关联了Address表，首先先创建表结构

 

from sqlalchemy import create_engine
from sqlalchemy import Integer,String,Column,ForeignKey
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker,relationship
 
engine = create_engine("mysql+pymysql://root:zyw@123@192.168.20.219/lzl",
                       encoding="utf-8",echo= True)
 
Base =  declarative_base()
 
class Customer(Base):
    __tablename__ = "customer"
    id = Column(Integer,primary_key=True)
    name = Column(String(32))
    billing_address_id = Column(Integer,ForeignKey("address.id"))
    shipping_address_id = Column(Integer, ForeignKey("address.id"))
 
    billing_address = relationship("Address",foreign_keys=[billing_address_id]) #必须写foreign_keys
    shipping_address = relationship("Address",foreign_keys=[shipping_address_id])
 
class Address(Base):
    __tablename__ = 'address'
    id = Column(Integer, primary_key=True)
    street = Column(String(32))
    city = Column(String(32))
    state = Column(String(32))
 
Base.metadata.create_all(engine)

 

生成数据：

 

Session = sessionmaker(bind=engine)
session = Session()
 
a1 = Address(street="Tiantongyuan",city="ChangPing",state="BJ")
a2 = Address(street="Wudaokou",city="HaiDian",state="BJ")
a3 = Address(street="Yanjiao",city="LangFang",state="HB")
 
session.add_all([a1,a2,a3])
c1 = Customer(name="lzl",billing_address_id=1,shipping_address_id=2)
c2 = Customer(name="Alex",billing_address_id=3,shipping_address_id=3)
 
session.add_all([c1,c2])
 
session.commit()

 

查询数据：

 

Session = sessionmaker(bind=engine)
session = Session()
 
cus_obj = session.query(Customer).filter_by(name="lzl").first()
print(cus_obj)

 

多对多关联

现在来设计一个能描述“图书”与“作者”的关系的表结构，需求是

1. 一本书可以有好几个作者一起出版
2. 一个作者可以写好几本书

创建表结构：

 

#一本书可以有多个作者，一个作者又可以出版多本书
 
 
from sqlalchemy import Table, Column, Integer,String,DATE, ForeignKey
from sqlalchemy.orm import relationship
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker
 
engine = create_engine("mysql+pymysql://root:zyw@123@192.168.20.219/lzl",
                       encoding="utf-8")
 
Base = declarative_base()
 
#创建book_m2m_author表，表不用用户操作，系统自动维护，自动添加数据
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)
    #关联Author类，secondary表示通过book_m2m_author表进行查询关联数据，backref反向查询也一样
    authors = relationship('Author',secondary=book_m2m_author,backref='books')
     
 
    def __repr__(self):
        return self.name
 
class Author(Base):
    __tablename__ = 'authors'
    id = Column(Integer, primary_key=True)
    name = Column(String(32))
 
    def __repr__(self):
        return self.name
 
Base.metadata.create_all(engine)

 

创建表数据：　

 

Session = sessionmaker(bind=engine)
session = Session()
 
b1 = Book(name="learn python with Alex",pub_date="2014-05-02")
b2 = Book(name="learn linux with Alex",pub_date="2015-05-02")
b3 = Book(name="learn go with Alex",pub_date="2016-05-02")
 
a1 = Author(name="Alex")
a2 = Author(name="Jack")
a3 = Author(name="Rain")
 
#关键来了，创建关联关系
b1.authors = [a1,a3]
b3.authors = [a1,a2,a3]
 
session.add_all([b1,b2,b3,a1,a2,a3])
session.commit()

 

查询：

 

author_obj = session.query(Author).filter_by(name="Alex").first()
print(author_obj,author_obj.books)
 
book_obj = session.query(Book).filter_by(id=2).first()
print(book_obj,book_obj.authors)
 
 
# Alex [learn python with Alex, learn go with Alex]
# learn go with Alex [Alex, Jack, Rain]

 

多对多删除

删除数据时不用管boo_m2m_authors　， sqlalchemy会自动帮你把对应的数据删除

通过书删除作者

 

author_obj =s.query(Author).filter_by(name="Jack").first()
  
book_obj = s.query(Book).filter_by(name="跟Alex学把妹").first()
  
book_obj.authors.remove(author_obj) #从一本书里删除一个作者
s.commit()

 

直接删除作者　

删除作者时，会把这个作者跟所有书的关联关系数据也自动删除

 

author_obj =s.query(Author).filter_by(name="Alex").first()
# print(author_obj.name , author_obj.books)
s.delete(author_obj)
s.commit()