笔记-ORM-sqlalchemy

1. ORM

1.1. ORM框架简介

对象-关系映射（Object/Relation Mapping，简称ORM），是随着面向对象的软件开发方法发展而产生的。面向对象的开发方法是当今企业级应用开发环境中的主流开发方法，关系数据库是企业级应用环境中永久存放数据的主流数据存储系统。对象和关系数据是业务实体的两种表现形式，业务实体在内存中表现为对象，在数据库中表现为关系数据。内存中的对象之间存在关联和继承关系，而在数据库中，关系数据无法直接表达多对多关联和继承关系。因此，对象-关系映射(ORM)系统一般以中间件的形式存在，主要实现程序对象到关系数据库数据的映射。

1.2. 总结

简单来说，因为数据库和开发软件之间的低关联性，开发人员无法直接了解到类对象与DB中表结构及数据的关联性，在修改数据库表结构时需要分别操作数据库并同时修改各处代码，对项目而言是非常麻烦的。

将定义数据库表结构，操纵数据等功能能抽象化，独立出来，配合一定语法，就是ORM了。

对不同的数据库，语言之间的ORM库是不通用的，每一个组合都需要构建新的接口。

2. SQLALchemy

2.1. 简介

The Python SQL Toolkit and Object Relational Mapper

2.2. 实验环境配置

mysql数据库安装配置

略

库安装

pip install sqlalchemy

3. 代码

# sqlalchemy使用测试
# sqlalchemy
from sqlalchemy import Column,String,create_engine,INTEGER,Text
from sqlalchemy.orm import sessionmaker
from sqlalchemy.ext.declarative import declarative_base

# 创建连接
# 格式mysql+pymysql://username:password@ip:db port/db
engine = create_engine('mysql+pymysql://dev_python:123456@localhost:3306/db_python', max_overflow=5)

# 测试连接是否可用
# execute是执行sql 语句
result = engine.execute('select * from t2')
#print(result.fetchall())

# 声明会话对象
session_class = sessionmaker(bind=engine)
session = session_class()

# 使用ORM方式创建表格
# 当然也可能通过执行SQL语句的方式创建表

# 声明一个基类
# 使用Declarative方法定义的映射类依据一个基类，
# 这个基类是维系类和数据表关系的目录-Declarative base class
# 在一个普通的模块入口中，应用通常只需要有一个base的实例。
# 通过declarative_base()功能创建一个基类：
base = declarative_base()

# 声明表类
class User(base):
__tablename__ = 'user_1'

id = Column(String(20), primary_key=True)
    name = Column(String(40))
    password = Column(String(30))
    context = Column(String(100))
    col_test = Column(INTEGER)

def __repr__(self):
return '%s(%r)' % (self.__class__.__name__, self.name)

# 创建表
# 注意：如果表已存在，并不会改动旧表
# 需要了解一下是否有只创建指定表的方法，好像没有。。。。
# print(dir(base.metadata))
# base.metadata.drop_all(engine)
#base.metadata.create_all(engine)
# 删除表
# base.metadata.drop_all(engine)

# 实例化一条记录
new_user = User(id='6', name='ed', password='edspassword', context='reflow
paint')
new_user1 = User(id='7', name='ed', password='edspassword', context='reflow
paint')

# 新增数据到类中并提交到数据库
#session.add(new_user)
#session.add(new_user1)
session.commit()
# session.rollback()

# 表关系
# 上面是最简单的表，没有外键
from sqlalchemy import ForeignKey

# 一对多
class User_2(base):
__tablename__ = 'user_2'

id = Column(INTEGER,
primary_key=True)
    name = Column(String(64), nullable=False, index=True)
    password = Column(String(64), nullable=False)
    email = Column(String(64))
    #articles =
relationship('Article')

def __repr__(self):
return '%s(%r)' % (self.__class__.__name__, self.name)

class Article(base):
__tablename__ = 'articles'

id = Column(INTEGER,
primary_key=True)
    title = Column(String(255), nullable=False, index=True)
    content = Column(Text)
    user_id = Column(INTEGER, ForeignKey('user_2.id'))
    #author =
relationship('User')

def __repr__(self):
return '%s(%r)' % (self.__class__.__name__, self.title)

# 多对多

class User_3(base):
__tablename__ = 'user_3'

id = Column(INTEGER,
primary_key=True, autoincrement=True)
    name = Column(String(64))
    group = Column(INTEGER, ForeignKey('group.id'))
    department = Column(INTEGER,
ForeignKey('department.id'))
    password = Column(String(64))

class Group(base):
__tablename__ = 'group'

id = Column(INTEGER,
primary_key=True)
name = Column(String(64), unique=True, nullable=True)

class Department(base):
__tablename__ = 'department'

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

#base.metadata.drop_all(engine)
base.metadata.create_all(engine)

result = session.execute('show tables')
#print(result.fetchall())

# 基本的表创建完成了，下面是数据操作

# create
'''
new_obj = User(id='wefsfwe', name='sfd')
session.add(new_obj)
session.add_all([User(id='wef', name='wef')

,User(id='wgeer',name='ergrth')])
session.commit()
'''

result = session.query(User).all()
# print(result)

# read
result = session.query(User).all() # 返回User对象列表
result = session.query(User.id, User.name).all() # 返回tuple列表
result = session.query(User).filter_by(name='wef').all() # 返回User对象列表
result = session.query(User).filter_by(name='wef').first()
#同上
print(result)

for _ in session.query(User).order_by(User.id):
#print(_.id, _.name)
pass
result = session.query(User).filter_by(id=r'6').first()
#print(result)

# update
session.query(User).filter(User.id == 'wef').update({'name':'32345'})
result = session.query(User.id, User.name).all() # 返回tuple列表
#print(result)
# 注意，无论是否提交，查询结果都已改变，但不提交数据库中的数据不会变
session.commit()

# delete

session.query(User).filter(User.id == 'wef').delete()
result = session.query(User.id, User.name).all() # 返回tuple列表
print(result)
# 同样，注意提交
session.commit()
result = session.query(User.id, User.name).all() # 返回tuple列表
print(result)

# 其它
# 条件查询
"""
#　条件
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()
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()
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(
    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()
"""