python oracle orm_Python库之SQLAlchemy

一、SQLAlchemy简介

1.1、SQLAlchemy是什么？

sqlalchemy是一个python语言实现的的针对关系型数据库的orm库。可用于连接大多数常见的数据库，比如Postges、MySQL、SQLite、Oracle等。

1.2、为什么要使用SQLAlchemy？

它将你的代码从底层数据库及其相关的SQL特性中抽象出来。

1.3、SQLAlchemy提供了两种主要的使用模式SQL表达式语言(SQLAlchemy Core)

ORM

1.4、应该选择哪种模式？虽然你使用的框架中已经内置了ORM，但是希望添加更强大的报表功能，请选用Core。

如果你想在一个一模式为中心的视图中查看数据(用户类似于SQL)，请使用Core。

如果你的数据不需要业务对象，请使用Core。

如果你要把数据看作业务对象，请使用ORM。

如果你想快速创建原型，请使用ORM。

如果你需要同事使用业务对象和其他与问题域无关的数据，请组合使用Core和ORM。

1.5、连接数据库

要连接到数据库，需要先创建一个SQLAlchemy引擎。SQLAlchemy引擎为数据库创建一个公共接口来执行SQL语句。这是通过包装数据库连接池和方言(不同数据库客户端)来实现的。

SQLAlchemy提供了一个函数来创建引擎。在这个函数中，你可以指定连接字符串，以及其他一些可选的关键字参数。

from sqlalchemy import create_engine

engine = create_engine('sqlite:///cookies.db')

engine1 = create_engine('sqlite:///:memory:')

engine2 = create_engine('sqlite:/home/cookiemonster/cookies.db')

engine3 = create_engine('sqlite:///c:\\Users\\cookiemonster\\cookies.db')

engine_mysql = create_engine('mysql+pymysql://cookiemonster:chocolatechip', '@mysql01.monster.internal/cookies', pool_recycle=3600)

1.6、模式和类型

为了访问底层数据库，SQLAlchemy需要用某种东西来代表数据库中的表。为此，可以使用下面三种方法总的一种：使用用户定义的Table对象

使用代表数据表的声明式类

从数据库中推断

二、SQLAlchemy core

SQLAlchemy core定义表结构使用的是1.5中说的第1种方式。table对象包含一系列带有类型的列和属性，它们与一个常见的元数据容器相关联。

元数据可以看作是一种Table对象目录。这些表可以通过MetaData.tables来访问。

2.1、定义表结构

在SQLAlchemy Core中，我们通过Table构造函数来初始化Table对象。我们要在构造函数中提供MetaData对象(元数据)和表名，任何其他参数都被认为是列对象。列是通过Column()函数创建的。

from sqlalchemy import create_engine

from sqlalchemy import Column

from sqlalchemy import Integer

from sqlalchemy import String

from sqlalchemy import MedaData

metadata = MetaData()

user = table('user', metadata,

Column(id, Integer(), primary_key=True),

Column(name, String(255)),

)

engine = create_engine('sqlite:///:memory:')

metadata.create_all(engine) # 表的持久化

2.2、插入数据

首先创造一条insert语句，用来把小明放入user表中。为此，先调用user表的insert()方法，然后再使用values()语句，关键字参数为各个列及相应值：

ins = user.insert().values(

id=1,

name='小明'

)

print(str(ins))

到此仅仅只是创建了一个inset语句，还没有真正执行呢，接下来执行插入操作：

connection = engine.connect()

result = connection.execute(ins)

print(result.inserted_primary_key)

2.3、查询数据

构建查询时，要用到select函数，它类似于标准SQL SELECT语句。

from sqlalchemy.sql import select

s = select([user])

# 可以使用str(s)查看数据库看到的语句

print(str(s))

rp = connection.execute(s)

results = rp.fetchall()

2.3.1、ResultProxy

execute()函数的返回值是一热ResultProxy对象，它允许使用索引、名称或Column对象进行访问。

使用ResultProxy处理行

first_row = results[0]

first_row[1]

first_row.name

first_row[user.c.name]

迭代ResultProxy

rp = connection.execute(s)

for record in rp:

print(record.user_name)

使用方法访问结果

rp.first() # 若有记录，则返回第一个记录并关闭连接

rp.fetchone() # 返回一行，并保持光标为打开状态，以便你做更多获取调用

rp.scalar() # 入股查询结果是包含一个列的单条记录，则返回单个值

2.3.2、控制查询中的列数

s = select([user.c.name])

rp = connection.execute(s)

print(rp.keys())

result = rp.first()

2.3.3、排序

s = select([user.c.name])

s = s.order_by(user.c.name)

rp = connection.execute(s)

for user in rp:

print(user.name)

2.3.4、限制返回结果集的条数

s = select([user.c.name])

s = s.order_by(user.c.name)

s = s.limit(2)

rp = connection.execute(s)

for user in rp:

print(user.name)

2.3.5、内置SQL函数和标签

from sqlalchemy.sql import func

s = select([func.sum(user.c.score)])

rp = connection.execute(s)

print(rp.scalar())

2.3.6、过滤

对查询过滤是通过添加where()语句来完成的。

s = select([user]).where(user.c.name == '小明')

rp = connection.execute(s)

record = rp.first()

print(record.items())

这里只是介绍了常用的查询方法，更多复杂的查询请查阅官方文档。

2.3、更新数据

update()方法和前面的insert()方法很相似，它们的语法几乎完全一样，但是update()可以指定一个where()子句，用来指出要更新哪些行。

from sqlalchemy import update

u = update(user).where(user.c.name == '小明')

u = u.values(name='小华')

result = connection.execute(u)

print(result.rowcount)

2.4、删除数据

创建删除语句时，既可以使用delete()函数，也可以使用表的delete()方法。与insert()和update()不同，delete()不接收值参数，只接收一个可选where子句，用来指定删除范文。

from sqlalchemy import delete

u = delete(user).where(user.c.name == '小华')

result = connection.execute(u)

print(result.rowcount)注意：

更多的高级操作：连接、别名、分组、链式调用、原始查询等，请查阅官方文档。

2.5、事务

通过connection.begin()开启一个事务，返回一个transaction对象，接下来根据执行的情况调用transaction.commit()提交修改或者调用transaction.rollback()回滚操作。

三、SQLAlchemy orm

SQLAlchemy orm定义表结构使用的是1.5中说的第2种方式。通过定义一个类，它继承自一个名为declarative_base的特殊基类。declarative_base把元数据容器和映射器(用来把类映射到数据表)结合在一起。

orm使用的类应该满足如下四个要求：继承自declarative_base对象。

包含__tablename__，这是数据库中使用的表名。

包含一个或多个属性，它们都是column对象。

确保一个或多个属性组成主键。

3.1、定义表结构：

from sqlalchemy import create_engine

from sqlalchemy import Column

from sqlalchemy import Integer

from sqlalchemy import String

from sqlalchemy.ext.declarative import declarative_base

Base = declarative_base()

class User(Base):

__tablename__ = 'user'

id = Column(Integer, primary_key=True)

name = Column(String(255))

engine = create_engine('sqlite:///')

Base.metadata.create_all(engine)

Session = sessionmaker(bind=engine)

session = Session()

3.2、会话(session)

会话是SQLAlchemy ORM和数据库交互的方式。它通过引擎包装数据库连接，并为通过会话加载或与会话关联的对象提供标识映射(identity map)。标识映射是一种类似于缓存的数据结构，它包含由对象表和主键确定的一个唯一的对象列表。会话还包装了一个事务，这个事务将一直保持打开状态，直到会话提交或回滚。

为创建会话，SQLAlchemy提供了一个sessionmaker类，这个类可以确保在整个应用程序中能够使用相同的参数创建会话。sessionmaker类通过创建一个Session类来实现这一点，Session类是根据传递给sessionmaker工厂的参数配置的。

from sqlalchemy import create_engine

from sqlalchemy.orm import sessionmaker

engine = create_engine('sqlite:///:memory:')

Session = sessionmaker(bind=engine)

session = Session()

3.2、插入

user = User(1, '小明')

session.add(user)

session.commit()

3.3、查询

for row in session.query(User):

print(row.id, row.name)

常用Query对象的方法：

q = session.query(User)

q.count() # 获取查询结果的数量

q.all() # 返回查询结果的list，会触发执行SQL查询

q.get(id) # 根据primary_key查询单个对象

q.as_scalar() # 返回此次查询的SQL语句

3.3.1、控制查询中的列数

print(session.query(user.name).first())

3.3.2、排序

for record in sesssion.query(user).order_by(user.name):

print(user.name)

3.3.3、限制返回结果集的条数

query = session.query(user).order_by(user.name).[:2]

print([result.user_name for result in query])

3.3.4、内置SQL函数和标签

from sqlalchemy import func

inv_count = session.query(func.sum(user.name)).scalar()

print(inv_count)

3.3.5、过滤

record = session.query(user).filter(user.name == '小华')

print(record)

3.4、更新数据

query = session.query(user)

xm_user = query.filter(user.user_name == '小华').first()

xm_user.name = 'robin'

session.commit()

print(xm_user.quantity)

3.5、删除数据

query = session.query(user)

xm_user = query.filter(user.user_name == '小华').first()

session.delete(xm_user)

session.commit()

print(xm_user)注意：

这里简单介绍了SQLAlchemy orm的常见用法，更高级的用法请查阅官方文档。

四、反射

使用反射技术可以利用先用数据库填充SQLAlchemy对象。

4.1、反射单个表

创建初始对象：

from sqlalchemy import Metadata, create_engines

metadata = MetaData()

engine = reate_engine('sqlite:///')

反射Artist表

from sqlalchmy impport Table

artist = Table('Artist', metadata, autoload=True, autoload_with=engine)

4.2、反射整个数据库

metadata.reflect(bind=engine)

参考资料