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()