摘要:参数表示是否检查表已经存在。此外,这条语句列出了表里的每一列,而在插入时一般是不需要指定的,可以通过方法加以限制限制后,列已经没有了可见方法限制了语句所包含的列。
环境:Ubuntu 15.10 64-bit
SQLAlchemy 是 Python 的 ORM 框架,它的理念是:数据库的量级和性能重要于对象集合,而对象集合的抽象又重要于表和行。
安装直接通过 pip 安装:
$ pip install sqlalchemy
打开 Python,测试是否安装成功:
>>> import sqlalchemy >>> sqlalchemy.__version__ "1.0.9"创建引擎 SQLite
首先以 SQLite 为例,因为它比较简单。
from sqlalchemy import create_engine, MetaData engine = create_engine("sqlite:///foo.db", echo=True) metadata = MetaData(engine)
参数 sqlite:///foo.db 解释为:
sqlite:///
其中foo.db是相对路径。也可写成:
sqlite:///./foo.db
SQLAlchemy 缺省使用 Python 内建的 sqlite3 模块来连接或创建 SQLite 数据库。执行完 create_engine 后,可以发现当前目录多了 foo.db 文件,不妨用 sqlite 打开看看。
$ sqlite3 foo.db SQLite version 3.8.11.1 2015-07-29 20:00:57 Enter ".help" for usage hints. sqlite> .tables
注意这里用的是 sqlite3 而非 sqlite,因为 foo.db 是经由 Python 内建的 sqlite3 模块创建的。
MySQL再来看看连接 MySQL 时怎么创建引擎。
本文后续示例全部基于 MySQL,这是与官方文档不同的地方。
先在MySQL里创建一个测试数据库:sa_test,后续示例都将基于这个数据库。
mysql> CREATE DATABASE sa_test DEFAULT CHARACTER SET UTF8;
from sqlalchemy import create_engine, MetaData engine = create_engine("mysql+mysqldb://root:******@localhost/sa_test", echo=True) metadata = MetaData(engine)
这里的参数看上去就比较复杂了,完整的格式为:
dialect+driver://username:password@host:port/database
这里 driver 用了 mysqldb,详见:MySQLdb:Python 操作 MySQL 数据库
引擎配置的详细信息可参考官方文档:Engine Configuration
MetaData前面在创建 MetaData 时绑定了引擎:
metadata = MetaData(engine)
当然也可以不绑定。绑定的好处是,后续很多调用 (比如 MetaData.create_all(),Table.create(),等等)就不用指定引擎了。
创建表创建两张表,user 和 address,address 表里有一个 user id 的外键。
注意:表名没有像官方文档及很多人推荐的那样使用复数形式,个人偏好而已,详细讨论请见 StackOverflow 的这个问题:Table Naming Dilemma: Singular vs. Plural Names (中文版)
from sqlalchemy import create_engine, MetaData, Table, Column, Integer, String, ForeignKey engine = create_engine("mysql+mysqldb://root:******@localhost/sa_test", echo=True) metadata = MetaData(engine)
user_table = Table("user", metadata, Column("id", Integer, primary_key=True), Column("name", String(50)), Column("fullname", String(100)) ) address_table = Table("address", metadata, Column("id", Integer, primary_key=True), Column("user_id", None, ForeignKey("user.id")), Column("email", String(128), nullable=False) ) metadata.create_all()
执行完 metadata.create_all() 这一句,两张表就创建好了,可以在 MySQL 里立即查看。
MetaData.create_all() 可以多次调用,不会报错,它在内部会检查表是否已经创建。
因为 MetaData 创建时已经绑定了引擎,所以此处 create_all() 就不必再指定了,否则得写成:
metadata.create_all(engine)
创建引擎时,echo 参数为 True,程序运行时便有很多调试信息打印出来。在这些调试信息中,可以看到如下两条 MySQL的CREATE TABLE 语句:
CREATE TABLE user ( id INTEGER NOT NULL AUTO_INCREMENT, name VARCHAR(50), fullname VARCHAR(100), PRIMARY KEY (id) ) CREATE TABLE address ( id INTEGER NOT NULL AUTO_INCREMENT, user_id INTEGER, email VARCHAR(128) NOT NULL, PRIMARY KEY (id), FOREIGN KEY(user_id) REFERENCES user (id) )
除了 metadata.create_all(),Table 自己也有 create 方法:
create(bind=None, checkfirst=False)
参数 bind 一般就是指引擎。
参数 checkfirst 表示是否检查表已经存在。为 True 时,若表已经存在,不报错,只是什么也不做;为
False 时,若表已经存在,则将引发异常。
使用这个方法来创建这两张表:
user_table.create(checkfirst=True) address_table.create(checkfirst=True)
这里忽略了 bind 参数,因为创建 MetaData 对象时已经绑定了引擎,而创建表对象时又传入了 metadata,所以顺藤摸瓜,表自己是知道引擎的。
如果调整一下表的创建顺序,就会报错,因为 address 表里有一个 user 表的外键,而这时候 user 表还没创建呢。所以,还是建议使用 MetaData.create_all() 吧,毕竟它也会检查表是否已经存在。
表创建好了,一般也就不动了。所以实际应用时,往往表都已经存在,并不需要创建,只需把它们”导入”进来即可,这时就得使用 autoload 参数。
from sqlalchemy import create_engine, MetaData, Table engine = create_engine("mysql+mysqldb://root:******@localhost/sa_test", echo=False) metadata = MetaData(engine) user_table = Table("user", metadata, autoload=True) print "user" in metadata.tables print [c.name for c in user_table.columns] address_table = Table("address", metadata, autoload=True) print "address" in metadata.tables
输出:
True ["id", "name", "fullname"] True
如果 MetaData 没有绑定引擎,则另需指定 autoload_with 参数:
user_table = Table("user", metadata, autoload=True, autoload_with=engine)
如果被反射的表外键引用了另一个表,那么被引用的表也会一并被反射。比如只反射 address 表,user 表也一并被反射了。
from sqlalchemy import create_engine, MetaData, Table engine = create_engine("mysql+mysqldb://root:******@localhost/sa_test", echo=False) metadata = MetaData(engine) address_table = Table("address", metadata, autoload=True) print "user" in metadata.tables print "address" in metadata.tables
输出:
True True插入数据
插入数据之前,必须要有表对象,不管是新创建的,还是通过反射导入的。
Insert 对象要往表里插数据,先创建一个 Insert 对象:
ins = user_table.insert() print ins
打印这个 Insert 对象,可以看到它所对应的 SQL 语句:
INSERT INTO user (id, name, fullname) VALUES (%s, %s, %s)
如果连接的数据库不是 MySQL 而是 SQLite,那输出可能就是下面这样:
INSERT INTO user (id, name, fullname) VALUES (?, ?, ?)
可见 SQLAlchemy 帮我们封装了不同数据库之间语法的差异。
如果 MetaData 创建时没有绑定引擎,那么输出会略有不同:
INSERT INTO "user" (id, name, fullname) VALUES (:id, :name, :fullname)
这时 SQLAlchemy 还不知道具体的数据库语法,表名加了引号("user"),列名也改用为:id之类一般性的格式。
此外,这条INSERT语句列出了 user 表里的每一列,而id在插入时一般是不需要指定的,可以通过
Insert.values() 方法加以限制:
ins = ins.values(name="adam", fullname="Adam Gu") print ins
限制后,id 列已经没有了:
INSERT INTO user (name, fullname) VALUES (%s, %s)
可见 values() 方法限制了 INSERT 语句所包含的列。但是我们指定的 name 和 fullname 的值并没有打印出来,这两个值保存在 Insert 对象里,只有等到执行时才会用到。
执行我们一直在说的引擎,可以理解成一个数据库连接对象的仓库,通过连接对象可以往数据库发送具体的 SQL 语句。调用引擎的 connect() 方法可以获取一个连接:
conn = engine.connect()
现在把前面的 Insert 对象丢给它来执行:
result = conn.execute(ins)
由调试信息可见具体的 INSERT 语句:
INSERT INTO user (name, fullname) VALUES (%s, %s) ("adam", "Adam Gu") COMMIT
返回值 result 是一个 ResultProxy 对象,ResultProxy 是对 DB-API 中 cursor 的封装。插入语句的结果并不常用,但是查询语句肯定是要用到它的。
不妨在 MySQL 里看一下刚插入的数据。
mysql> select * from user; +----+------+----------+ | id | name | fullname | +----+------+----------+ | 1 | adam | Adam Gu | +----+------+----------+ 1 row in set (0.00 sec)执行多条语句
还记得前面的 Insert 对象使用 values() 方法来限制列吗?
ins = ins.values(name="adam", fullname="Adam Gu")
这种方式其实不利于 Insert 对象的复用,更好的做法是把参数通过 execute() 方法传进去:
ins = user_table.insert() conn.execute(ins, name="adam", fullname="Adam Gu")
Insert 对象本身还是会包含所有列,最终 INSERT 语句里的列由 execute() 的参数决定。由调试信息可见具体的 INSERT 语句:
INSERT INTO user (name, fullname) VALUES (%s, %s) ("adam", "Adam Gu") COMMIT
一次插入多条记录也很简单,只要传一个字典列表(每个字典的键必须一致)给 execute() 即可。
conn.execute(address_table.insert(), [ { "user_id": 1, "email": "sprinfall@gmail.com" }, { "user_id": 1, "email": "sprinfall@hotmail.com" }, ])
调试信息里具体的 INSERT 语句:
INSERT INTO address (user_id, email) VALUES (%s, %s) ((1, "sprinfall@gmail.com"), (1, "sprinfall@hotmail.com")) COMMIT
在 MySQL 里看一下插入的地址:
mysql> select * from address; +----+---------+-----------------------+ | id | user_id | email | +----+---------+-----------------------+ | 1 | 1 | sprinfall@gmail.com | | 2 | 1 | sprinfall@hotmail.com | +----+---------+-----------------------+ 2 rows in set (0.00 sec)
第一部分到此结束。
文章版权归作者所有,未经允许请勿转载,若此文章存在违规行为,您可以联系管理员删除。
转载请注明本文地址:https://www.ucloud.cn/yun/17526.html
摘要:下一篇文章第节查询条件设置是编程语言下的一款开源软件。提供了工具包及对象关系映射工具,使用许可证发行。在关闭连接时会自动进行事务提交操作。引入多条件查询时使用。由于上下文函数退出时会自动提交事务,所以无需显示的调用使新增生效。 下一篇文章:Python-SQLAlchemy:第2节:查询条件设置 SQLAlchemy是Python编程语言下的一款开源软件。提供了SQL工具包及对象关系...
摘要:参数表示是否检查表已经存在。此外,这条语句列出了表里的每一列,而在插入时一般是不需要指定的,可以通过方法加以限制限制后,列已经没有了可见方法限制了语句所包含的列。 环境:Ubuntu 15.10 64-bit SQLAlchemy 是 Python 的 ORM 框架,它的理念是:数据库的量级和性能重要于对象集合,而对象集合的抽象又重要于表和行。 安装 直接通过 pip 安装: $ pi...
摘要:的模型使用模型的原因当项目越来越大的时候会出现很多问题原生较多重复使用率低如果你的数据库发生了改变所有的原生就都要进行修改写原生的时候会有安全隐患中文件关系对象的映射使用去操作数据库的时候不会再去写原生的了通过把表映射成类字段为你的属性在 Flask-SQLalchemy flask的ORM模型 使用ORM模型的原因 当项目越来越大的时候 会出现很多问题 原生SQL较多 重复使...
阅读 735·2023-04-25 20:47
阅读 2505·2019-08-30 15:53
阅读 907·2019-08-26 14:05
阅读 850·2019-08-26 11:59
阅读 1647·2019-08-26 11:43
阅读 1565·2019-08-26 10:57
阅读 1324·2019-08-23 18:23
阅读 2554·2019-08-23 12:57