ORM框架之SQLAlchemy

一、SQLAlchemy的简介

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

二、SQLAlchemy的初步应用---表的创建

1、单表的创建与删除

#!/usr/bin/env python# -*- coding:utf-8 -*-#Author:ye

#导入模块from sqlalchemy.ext.declarative import declarative_basefrom sqlalchemy import Column, Integer, String, ForeignKey, UniqueConstraint, Indexfrom sqlalchemy.orm import sessionmaker, relationshipfrom sqlalchemy import create_engineimport time

#创建继承类Base(规定的写法)Base = declarative_base()

#创建类,并继承父类Baseclass User(Base):    #创建表,“__talbename__”后的值代表数据库表名    __tablename__ = ‘user‘    #创建数据库表的列字段    id = Column(Integer,primary_key=True,autoincrement=True)    name = Column(String(32))    age = Column(Integer)

#创建索引    __table_args__ = (        UniqueConstraint(‘id‘, ‘name‘, name=‘uix_id_name‘),        Index(‘uix_id_name‘, ‘name‘)    )

def init_db():    #创建引擎,并在此基础上通过pymysql插件,连接数据库。同时创建数据库连接池,设置为5    engine = create_engine("mysql+pymysql://root:[email protected]:3306/day15?charset=utf8", max_overflow=5)

#找到所有继承Base这个类的子类,并创建子类中定义的所有的数据库表    Base.metadata.create_all(engine)

def drop_db():    # 创建引擎,并在此基础上通过pymysql插件,连接数据库。同时创建数据库连接池,设置为5    engine = create_engine("mysql+pymysql://root:[email protected]:3306/day15?charset=utf8", max_overflow=5)

# 找到所有继承Base这个类的子类,并删除子类中定义的所有的数据库表    Base.metadata.drop_all(engine)

#执行函数,创建数据库表init_db()time.sleep(1)print("数据库表创建成功!")

#执行函数,删除数据库表drop_db()time.sleep(1)print("数据库表删除成功!")

2、一对多 

#!/usr/bin/env python# -*- coding:utf-8 -*-#Author:ye

#导入模块from sqlalchemy.ext.declarative import declarative_basefrom sqlalchemy import Column, Integer, String, ForeignKey, UniqueConstraint, Indexfrom sqlalchemy.orm import sessionmaker, relationshipfrom sqlalchemy import create_engineimport time

#创建继承类Base(规定的写法)Base = declarative_base()

class Favor(Base):    __tablename__ = ‘favor‘    nid = Column(Integer, primary_key=True)#设置为主键    caption = Column(String(50), default=‘red‘, unique=True)#默认值为red,设置为唯一约束

class Person(Base):    __tablename__ = ‘person‘    nid = Column(Integer, primary_key=True)#设置为主键    name = Column(String(32), index=True, nullable=True)#可以为空    favor_id = Column(Integer, ForeignKey("favor.nid"))#设置外键,person.favor.id = favor.id
#创建引擎,并在此基础上通过pymysql插件,连接数据库。同时创建数据库连接池,设置为5engine = create_engine("mysql+pymysql://root:[email protected]:3306/day15?charset=utf8", max_overflow=5)

#找到所有继承Base这个类的子类,并创建子类中定义的所有的数据库表Base.metadata.create_all(engine)

3、多对多

#!/usr/bin/env python# -*- coding:utf-8 -*-#Author:ye

#导入模块from sqlalchemy.ext.declarative import declarative_basefrom sqlalchemy import Column, Integer, String, ForeignKey, UniqueConstraint, Indexfrom sqlalchemy.orm import sessionmaker, relationshipfrom sqlalchemy import create_engineimport time

#创建继承类Base(规定的写法)Base = declarative_base()

# 多对多class Group(Base):    __tablename__ = ‘group‘    id = Column(Integer, primary_key=True)    name = Column(String(64), unique=True, nullable=False)

class Server(Base):    __tablename__ = ‘server‘

id = Column(Integer, primary_key=True, autoincrement=True)    hostname = Column(String(64), unique=True, nullable=False)    port = Column(Integer, default=22)

class ServerToGroup(Base):    __tablename__ = ‘servertogroup‘    nid = Column(Integer, primary_key=True, autoincrement=True)    server_id = Column(Integer, ForeignKey(‘server.id‘))#设置外键 servertogroup.server_id = server.id    group_id = Column(Integer, ForeignKey(‘group.id‘))#设置外键 servertogroup.group_id = group.id

def init_db():    # 创建引擎,并在此基础上通过pymysql插件,连接数据库。同时创建数据库连接池,设置为5    engine = create_engine("mysql+pymysql://root:[email protected]:3306/day15?charset=utf8", max_overflow=5)    # 找到所有继承Base这个类的子类,并创建子类中定义的所有的数据库表    Base.metadata.create_all(engine)

def drop_db():    # 创建引擎,并在此基础上通过pymysql插件,连接数据库。同时创建数据库连接池,设置为5    engine = create_engine("mysql+pymysql://root:[email protected]:3306/day15?charset=utf8", max_overflow=5)

# 找到所有继承Base这个类的子类,并删除子类中定义的所有的数据库表    Base.metadata.drop_all(engine)

# 执行函数,创建数据库表init_db()time.sleep(1)print("数据库表创建成功!")

#执行函数,删除数据库表drop_db()time.sleep(1)print("数据库表删除成功!")

三、SQLAlchemy的进一步应用---表的操作

1、添加数据

#!/usr/bin/env python# -*- coding:utf-8 -*-#Author:ye

#导入模块from sqlalchemy.ext.declarative import declarative_basefrom sqlalchemy import Column, Integer, String, ForeignKey, UniqueConstraint, Indexfrom sqlalchemy.orm import sessionmaker, relationshipfrom sqlalchemy import create_engine

#创建继承类Base(规定的写法)Base = declarative_base()

#创建类,并继承父类Baseclass User(Base):    #创建表,“__talbename__”后的值代表数据库表名    __tablename__ = ‘user‘    #创建数据库表的列字段    id = Column(Integer,primary_key=True,autoincrement=True)    name = Column(String(32))    age = Column(Integer)

#创建引擎,并在此基础上通过pymysql插件,连接数据库。同时创建数据库连接池,设置为5engine = create_engine("mysql+pymysql://root:[email protected]:3306/day15?charset=utf8", max_overflow=5)

#找到所有继承Base这个类的子类,并创建子类中定义的所有的数据库表#Base.metadata.create_all(engine)

#创建session会话Session = sessionmaker(bind = engine)session = Session()

#实例化类对象,并添加到session中obj = User(name = "alex1",age = 35)#添加单条数据session.add(obj)

#添加多条数据session.add_all([    User(name = "alex2",age = 100),    User(name = "alex3",age = 90),])

#提交数据session.commit()

2、删除数据

#!/usr/bin/env python# -*- coding:utf-8 -*-#Author:ye

#导入模块from sqlalchemy.ext.declarative import declarative_basefrom sqlalchemy import Column, Integer, String, ForeignKey, UniqueConstraint, Indexfrom sqlalchemy.orm import sessionmaker, relationshipfrom sqlalchemy import create_engine

#创建继承类Base(规定的写法)Base = declarative_base()

#创建类,并继承父类Baseclass User(Base):    #创建表,“__talbename__”后的值代表数据库表名    __tablename__ = ‘user‘    #创建数据库表的列字段    id = Column(Integer,primary_key=True,autoincrement=True)    name = Column(String(32))    age = Column(Integer)

#创建引擎,并在此基础上通过pymysql插件,连接数据库。同时创建数据库连接池,设置为5engine = create_engine("mysql+pymysql://root:[email protected]:3306/day15?charset=utf8", max_overflow=5)

#创建session会话Session = sessionmaker(bind = engine)session = Session()

#删除数据,query后边是类名,filter后面跟的是where条件session.query(User).filter(User.id > 3).delete()

#提交数据session.commit()

3、修改数据

#!/usr/bin/env python# -*- coding:utf-8 -*-#Author:ye

#导入模块from sqlalchemy.ext.declarative import declarative_basefrom sqlalchemy import Column, Integer, String, ForeignKey, UniqueConstraint, Indexfrom sqlalchemy.orm import sessionmaker, relationshipfrom sqlalchemy import create_engine

#创建继承类Base(规定的写法)Base = declarative_base()

#创建类,并继承父类Baseclass User(Base):    #创建表,“__talbename__”后的值代表数据库表名    __tablename__ = ‘user‘    #创建数据库表的列字段    id = Column(Integer,primary_key=True,autoincrement=True)    name = Column(String(32))    age = Column(Integer)

#创建引擎,并在此基础上通过pymysql插件,连接数据库。同时创建数据库连接池,设置为5engine = create_engine("mysql+pymysql://root:[email protected]:3306/day15?charset=utf8", max_overflow=5)

#创建session会话Session = sessionmaker(bind = engine)session = Session()

#修改数据,query后边是类名,filter后面跟的是where条件,update后面跟的是修改的字段及字段内容session.query(User).filter(User.id > 2).update({User.age:User.age + 10},synchronize_session="evaluate")

#提交数据session.commit()

4、查询数据

#!/usr/bin/env python# -*- coding:utf-8 -*-#Author:ye

#导入模块from sqlalchemy.ext.declarative import declarative_basefrom sqlalchemy import Column, Integer, String, ForeignKey, UniqueConstraint, Indexfrom sqlalchemy.orm import sessionmaker, relationshipfrom sqlalchemy import create_engine

#创建继承类Base(规定的写法)Base = declarative_base()

#创建类,并继承父类Baseclass User(Base):    #创建表,“__talbename__”后的值代表数据库表名    __tablename__ = ‘user‘    #创建数据库表的列字段    id = Column(Integer,primary_key=True,autoincrement=True)    name = Column(String(32))    age = Column(Integer)

#创建引擎,并在此基础上通过pymysql插件,连接数据库。同时创建数据库连接池,设置为5engine = create_engine("mysql+pymysql://root:[email protected]:3306/day15?charset=utf8", max_overflow=5)

#创建session会话Session = sessionmaker(bind = engine)session = Session()

#查询数据,query后边是类名result_sql = session.query(User)#结果是生成的sql语句print("result_sql:",result_sql)#SELECT user.id AS user_id, user.name AS user_name, user.age AS user_age FROM user

result_obj = session.query(User).all()#查询出来的是符合条件的User对象print("result_obj:",result_obj)#[<__main__.User object at 0x00000004E0A6EA58>, <__main__.User object at 0x00000004E0A6E9E8>, <__main__.User object at 0x00000004E0A6EFD0>]

#将结果打印for result in result_obj:    print("user_id:",result.id)    print("user_name:",result.name)

#提交数据session.commit()

注:查询的其他方式:filter_by内部调用filter
  session = session.query(User.name, User.age).all()#查询user表中name、age列

  session.query(User).filter_by(name=‘alex‘).all()#查询user表中name是alex的所有行
  session.query(User).filter_by(name=‘alex‘).first()#查询user表中name是alex的第一行数据

5、其他查询条件

# 条件
ret = session.query(Users).filter_by(name=‘alex‘).all()
ret = session.query(Users).filter(Users.id > 1, Users.name == ‘eric‘).all()
ret = session.query(Users).filter(Users.id.between(1, 3), Users.name == ‘eric‘).all()#相当于Users.id >1 and Users.id < 3 and Users.name == eric
ret = session.query(Users).filter(Users.id.in_([1,3,4])).all()
ret = session.query(Users).filter(~Users.id.in_([1,3,4])).all()#~表示非
ret = session.query(Users).filter(Users.id.in_(session.query(Users.id).filter_by(name=‘eric‘))).all()#相当于select * from Users where Users.id in (select * from ...)
from sqlalchemy import and_, or_
ret = session.query(Users).filter(and_(Users.id > 3, Users.name == ‘eric‘)).all()
ret = session.query(Users).filter(or_(Users.id < 2, Users.name == ‘eric‘)).all()
ret = session.query(Users).filter(#先进行最里面括号中的and连接,然后再进行外面括号的or连接
    or_(
        Users.id < 2,
        and_(Users.name == ‘eric‘, Users.id > 3),
        Users.extra != ""
    )).all()

# 通配符
ret = session.query(Users).filter(Users.name.like(‘e%‘)).all()#模糊查询
ret = session.query(Users).filter(~Users.name.like(‘e%‘)).all()

# 限制
ret = session.query(Users)[1:2]

# 排序
ret = session.query(Users).order_by(Users.name.desc()).all()
ret = session.query(Users).order_by(Users.name.desc(), Users.id.asc()).all()

# 分组
from sqlalchemy.sql import func

ret = session.query(Users).group_by(Users.extra).all()
ret = session.query(
    func.max(Users.id),#最大值
    func.sum(Users.id),#求和
    func.min(Users.id)).group_by(Users.name).all()#最小值

ret = session.query(
    func.max(Users.id),
    func.sum(Users.id),
    func.min(Users.id)).group_by(Users.name).having(func.min(Users.id) >2).all()

# 连表

ret = session.query(Users, Favor).filter(Users.id == Favor.nid).all()

ret = session.query(Person).join(Favor).all()

ret = session.query(Person).join(Favor, isouter=True).all()

# 组合
q1 = session.query(Users.name).filter(Users.id > 2)
q2 = session.query(Favor.caption).filter(Favor.nid < 2)
ret = q1.union(q2).all()#组合并去重

q1 = session.query(Users.name).filter(Users.id > 2)
q2 = session.query(Favor.caption).filter(Favor.nid < 2)
ret = q1.union_all(q2).all()#组合不去重

6、多表查询

a.relationship的应用

#!/usr/bin/env python# -*- coding:utf-8 -*-#Author:ye

#导入模块from sqlalchemy.ext.declarative import declarative_basefrom sqlalchemy import Column, Integer, String, ForeignKey, UniqueConstraint, Indexfrom sqlalchemy.orm import sessionmaker, relationshipfrom sqlalchemy import create_engineimport time

#创建继承类Base(规定的写法)Base = declarative_base()

# 多对多class Department(Base):    __tablename__ = ‘department‘    id = Column(Integer, primary_key=True)    depart_name = Column(String(64), unique=True, nullable=False)

class Person(Base):    __tablename__ = ‘person‘

id = Column(Integer, primary_key=True, autoincrement=True)    user_name = Column(String(64), unique=True, nullable=False)    user_depart_id = Column(Integer, ForeignKey(‘department.id‘))#通过此外键进行关联

#创建两表之间的连接    depart = relationship("Department",backref="pers")

# 创建引擎,并在此基础上通过pymysql插件,连接数据库。同时创建数据库连接池,设置为5engine = create_engine("mysql+pymysql://root:[email protected]:3306/day15?charset=utf8", max_overflow=5)

#Base.metadata.create_all(engine)

#创建session会话Session = sessionmaker(bind = engine)session = Session()

result_obj = session.query(Person).all()

for result in result_obj:    print("person.id:",result.id)    print("person.user_name:", result.user_name)    print("depart_name:",result.depart.depart_name)

b.session.add的应用

#创建session会话Session = sessionmaker(bind = engine)session = Session()

#通过session在多表中插入数据session.add(Person(id=10,user_name=‘sb‘,depart=Department(id=9,depart_name="湖南")))session.commit()


				
时间: 2024-10-24 15:31:38

ORM框架之SQLAlchemy的相关文章

Python学习 Day17 Python对Mysql操作和使用ORM框架(SQLAlchemy)

Python对Mysql操作和使用ORM框架(SQLAlchemy) Mysql 常见操作 数据库操作 创建数据库 create database fuzjtest 删除数据库 drop database fuzjtest 查询数据库       show databases 切换数据库       use databas 123123 ###用户授权 创建用户          create user '用户名'@'IP地址' identified by '密码'; 删除用户        

python ORM框架:SqlAlchemy

ORM,对象关系映射,即Object Relational Mapping的简称,通过ORM框架将编程语言中的对象模型与数据库的关系模型建立映射关系,这样做的目的:简化sql语言操作数据库的繁琐过程(原生sql的编写及拼接等),转而直接使用对象模型来操作数据库做替代 第一部分 SqlAlchemy本身无法直接操作数据库,它是建立在第三方数据库API(如python 中的pymysql库)之上,应用程序调用对象模型进行增删改查等操作时,将对象转化成sql语句,然后再通过API调用执行已经转换好的s

python(十二)下:ORM框架SQLAlchemy使用学习

此出处:http://blog.csdn.net/fgf00/article/details/52949973 本节内容 ORM介绍 sqlalchemy安装 sqlalchemy基本使用 多外键关联 多对多关系 表结构设计作业  一.ORM介绍 如果写程序用pymysql和程序交互,那是不是要写原生sql语句.如果进行复杂的查询,那sql语句就要进行一点一点拼接,而且不太有重用性,扩展不方便.而且写的sql语句可能不高效,导致程序运行也变慢. 为了避免把sql语句写死在代码里,有没有一种方法直

pyhton ORM框架SQLAlchemy基础与建表

1.ORM框架:SQLALchemy - 作用: 1.提供简单的规则 2.自动转换成SQL语句 - ORM框架的分类:从代码和数据库两个角度来看的 1.DB firest:数据库优先,顾名思义要先手动创建好数据库和表,后面可以利用ORM框架生成相应的类(这种目前还没接触过,听说 Django默认是不支持的但可以通过安装第三方插件得到支持) 2.code first:代码优先,先手动创建好数据库,再用代码定义好表,然后再用orm框架在数据库中生成表(SQLAlchemy.Django都是的) a.

ORM框架SQLAlchemy与权限管理系统的数据库设计

SQLAlchemy是Python编程语言下的一款ORM框架,该框架建立在数据库API之上,使用对象关系映射进行数据库操作,即:将对象转换成SQL,然后使用数据API执行SQL并获取执行结果. 执行流程: 1.使用者通过ORM对象提交命令 2.将命令交给SQLAlchemy Core(Schema/Types SQL Expression Language)转换成SQL 3.使用 Engine/ConnectionPooling/Dialect 进行数据库操作 4.匹配使用者事先配置好的egin

mysql八:ORM框架SQLAlchemy

阅读目录 一 介绍 二 创建表 三 增删改查 四 其他查询相关 五 正查.反查 一 介绍 SQLAlchemy是Python编程语言下的一款ORM框架,该框架建立在数据库API之上,使用关系对象映射进行数据库操作,简言之便是:将对象转换成SQL,然后使用数据API执行SQL并获取执行结果. 1.安装 pip3 install sqlalchemy  2.架构与流程 #1.使用者通过ORM对象提交命令 #2.将命令交给SQLAlchemy Core(Schema/Types SQL Express

ORM框架SQLAlchemy学习(未整理完)

一.基本介绍 以下介绍来自维基百科,自由的百科全书. SQLAlchemy是Python编程语言下的一款开源软件.提供了SQL工具包及对象关系映射(ORM)工具,使用MIT许可证发行. SQLAlchemy“采用简单的Python语言,为高效和高性能的数据库访问设计,实现了完整的企业级持久模型”.SQLAlchemy的理念是,SQL数据库的量级和性能重要于对象集合:而对象集合的抽象又重要于表和行.因此,SQLAlchmey采用了类似于Java里Hibernate的数据映射模型,而不是其他ORM框

MySQL之ORM框架SQLAlchemy

一 介绍 SQLAlchemy是Python编程语言下的一款ORM框架,该框架建立在数据库API之上,使用关系对象映射进行数据库操作,简言之便是:将对象转换成SQL,然后使用数据API执行SQL并获取执行结果. 1.安装 pip3 install sqlalchemy  2.架构与流程 #1.使用者通过ORM对象提交命令 #2.将命令交给SQLAlchemy Core(Schema/Types SQL Expression Language)转换成SQL #3.使用 Engine/Connect

ORM框架SQLAlchemy

一 .SQLAlchemy简介 SQLAlchemy是Python编程语言下的一款ORM框架,该框架建立在数据库API之上,使用关系对象映射进行数据库操作,简言之便是:将对象转换成SQL,然后使用数据API执行SQL并获取执行结果. SQLAlchemy架构. SQLAlchemy流程. #1.使用者通过ORM对象提交命令 #2.将命令交给SQLAlchemy Core(Schema/Types SQL Expression Language)转换成SQL #3.使用 Engine/Connec