Pythonsqlite3SQLite数据库DBAPI2.0接口模块

模块函数和常量¶

sqlite3.version¶

这个模块的版本号，是一个字符串。不是 SQLite 库的版本号。

sqlite3.version_info¶

这个模块的版本号，是一个由整数组成的元组。不是 SQLite 库的版本号。

sqlite3.sqlite_version¶

使用中的 SQLite 库的版本号，是一个字符串。

sqlite3.sqlite_version_info¶

使用中的 SQLite 库的版本号，是一个整数组成的元组。

sqlite3.PARSE_DECLTYPES¶

这个常量可以作为 connect() 函数的 detect_types 参数。

设置这个参数后，sqlite3 模块将解析它返回的每一列申明的类型。它会申明的类型的第一个单词，比如“integer primary key”，它会解析出“integer”，再比如“number(10)”，它会解析出“number”。然后，它会在转换器字典里查找那个类型注册的转换器函数，并调用它。

sqlite3.PARSE_COLNAMES¶

这个常量可以作为 connect() 函数的 detect_types 参数。

设置此参数可使得 SQLite 接口解析它所返回的每一列的列名。 它将在其中查找形式为 [mytype] 的字符串，然后将 'mytype' 确定为列的类型。 它将尝试在转换器字典中查找 'mytype' 条目，然后用找到的转换器函数来返回值。 在 Cursor.description 中找到的列名并不包括类型，举例来说，如果你在你的 SQL 中使用了像 'as"Expirationdate[datetime]"' 这样的写法，那么我们将解析出在第一个 then we will parse out everything until the first '[' 之前的所有内容并去除前导空格作为列名：即列名将为 "Expiration date"。

sqlite3.connect(database[, timeout, detect_types, isolation_level, check_same_thread, factory, cached_statements, uri])¶

连接 SQLite 数据库 database。默认返回 Connection 对象，除非使用了自定义的 factory 参数。

database 是准备打开的数据库文件的路径（绝对路径或相对于当前目录的相对路径），它是 path-like object。你也可以用 ":memory:" 在内存中打开一个数据库。

当一个数据库被多个连接访问的时候，如果其中一个进程修改这个数据库，在这个事务提交之前，这个 SQLite 数据库将会被一直锁定。timeout 参数指定了这个连接等待锁释放的超时时间，超时之后会引发一个异常。这个超时时间默认是 5.0（5秒）。

isolation_level 参数，请查看 Connection 对象的 isolation_level 属性。

SQLite 原生只支持5种类型：TEXT，INTEGER，REAL，BLOB 和 NULL。如果你想用其它类型，你必须自己添加相应的支持。使用 detect_types 参数和模块级别的 register_converter() 函数注册**转换器** 可以简单的实现。

detect_types 默认为0（即关闭，没有类型检测）。你也可以组合 PARSE_DECLTYPES 和 PARSE_COLNAMES 来开启类型检测。

默认情况下，check_same_thread 为 True，只有当前的线程可以使用该连接。 如果设置为 False，则多个线程可以共享返回的连接。 当多个线程使用同一个连接的时候，用户应该把写操作进行序列化，以避免数据损坏。

默认情况下，当调用 connect 方法的时候，sqlite3 模块使用了它的 Connection 类。当然，你也可以创建 Connection 类的子类，然后创建提供了 factory 参数的 connect() 方法。

详情请查阅当前手册的 SQLite 与 Python 类型 部分。

sqlite3 模块在内部使用语句缓存来避免 SQL 解析开销。 如果要显式设置当前连接可以缓存的语句数，可以设置 cached_statements 参数。 当前实现的默认值是缓存100条语句。

如果 uri 为真，则 database 被解释为 URI。 它允许您指定选项。 例如，以只读模式打开数据库：

db=sqlite3.connect('file:path/to/database?mode=ro',uri=True)

有关此功能的更多信息，包括已知选项的列表，可以在 ` SQLite URI 文档 <https://www.sqlite.org/uri.html>`_ 中找到。

在 3.4 版更改: 增加了 uri 参数。

在 3.7 版更改: database 现在可以是一个 path-like object 对象了，不仅仅是字符串。

sqlite3.register_converter(typename, callable)¶

注册一个回调对象 callable, 用来转换数据库中的字节串为自定的 Python 类型。所有类型为 typename 的数据库的值在转换时，都会调用这个回调对象。通过指定 connect() 函数的 detect-types 参数来设置类型检测的方式。注意，typename 与查询语句中的类型名进行匹配时不区分大小写。

sqlite3.register_adapter(type, callable)¶

注册一个回调对象 callable，用来转换自定义Python类型为一个 SQLite 支持的类型。 这个回调对象 callable 仅接受一个 Python 值作为参数，而且必须返回以下某个类型的值：int，float，str 或 bytes。

sqlite3.complete_statement(sql)¶

如果字符串 sql 包含一个或多个完整的 SQL 语句（以分号结束）则返回 True。它不会验证 SQL 语法是否正确，仅会验证字符串字面上是否完整，以及是否以分号结束。

它可以用来构建一个 SQLite shell，下面是一个例子：

# A minimal SQLite shell for experiments
importsqlite3
con=sqlite3.connect(":memory:")
con.isolation_level=None
cur=con.cursor()
buffer=""
print("Enter your SQL commands to execute in sqlite3.")
print("Enter a blank line to exit.")
whileTrue:
line=input()
ifline=="":
break
buffer+=line
ifsqlite3.complete_statement(buffer):
try:
buffer=buffer.strip()
cur.execute(buffer)
ifbuffer.lstrip().upper().startswith("SELECT"):
print(cur.fetchall())
exceptsqlite3.Errorase:
print("An error occurred:",e.args[0])
buffer=""
con.close()

sqlite3.enable_callback_tracebacks(flag)¶

默认情况下，您不会获得任何用户定义函数中的回溯消息，比如聚合，转换器，授权器回调等。如果要调试它们，可以设置 flag 参数为 True 并调用此函数。 之后，回调中的回溯信息将会输出到 sys.stderr。 再次使用 False 来禁用该功能。

连接对象（Connection）¶

class sqlite3.Connection¶

SQLite 数据库连接对象有如下的属性和方法：

isolation_level¶

获取或设置当前默认的隔离级别。 表示自动提交模式的 None 以及 "DEFERRED", "IMMEDIATE" 或 "EXCLUSIVE" 其中之一。 详细描述请参阅 控制事务。

in_transaction¶

如果是在活动事务中（还没有提交改变），返回 True，否则，返回 False。它是一个只读属性。

3.2 新版功能.

cursor(factory=Cursor)¶

这个方法接受一个可选参数 factory，如果要指定这个参数，它必须是一个可调用对象，而且必须返回 Cursor 类的一个实例或者子类。

commit()¶

这个方法提交当前事务。如果没有调用这个方法，那么从上一次提交 commit() 以来所有的变化在其他数据库连接上都是不可见的。如果你往数据库里写了数据，但是又查询不到，请检查是否忘记了调用这个方法。

rollback()¶

这个方法回滚从上一次调用 commit() 以来所有数据库的改变。

close()¶

关闭数据库连接。注意，它不会自动调用 commit() 方法。如果在关闭数据库连接之前没有调用 commit()，那么你的修改将会丢失！

execute(sql[, parameters])¶

这是一个非标准的快捷方法，它会调用 cursor() 方法来创建一个游标对象，并使用给定的 parameters 参数来调用游标对象的 execute() 方法，最后返回这个游标对象。

executemany(sql[, parameters])¶

这是一个非标准的快捷方法，它会调用 cursor() 方法来创建一个游标对象，并使用给定的 parameters 参数来调用游标对象的 executemany() 方法，最后返回这个游标对象。

executescript(sql_script)¶

这是一个非标准的快捷方法，它会调用 cursor() 方法来创建一个游标对象，并使用给定的 sql_script 参数来调用游标对象的 executescript() 方法，最后返回这个游标对象。

create_function(name, num_params, func)¶

创建一个可以在 SQL 语句中使用的自定义函数，其中参数 name 为 SQL 语句中使用的函数名，num_params 是这个函数接受的参数个数（如果 num_params 为 -1，那这个函数可以接受任意数量的参数），最后一个参数 func 是作为 SQL 函数调用的一个 Python 可调用对象。

此函数可返回任何 SQLite 所支持的类型: bytes, str, int, float 和 None。

示例:

importsqlite3
importhashlib
defmd5sum(t):
returnhashlib.md5(t).hexdigest()
con=sqlite3.connect(":memory:")
con.create_function("md5",1,md5sum)
cur=con.cursor()
cur.execute("select md5(?)",(b"foo",))
print(cur.fetchone()[0])
con.close()

create_aggregate(name, num_params, aggregate_class)¶

创建一个自定义的聚合函数。

参数中 aggregate_class 类必须实现两个方法：step 和 finalize。step 方法接受 num_params 个参数（如果 num_params 为 -1，那么这个函数可以接受任意数量的参数）；finalize 方法返回最终的聚合结果。

finalize 方法可以返回任何 SQLite 支持的类型：bytes，str，int，float 和 None。

示例:

importsqlite3
classMySum:
def__init__(self):
self.count=0
defstep(self,value):
self.count+=value
deffinalize(self):
returnself.count
con=sqlite3.connect(":memory:")
con.create_aggregate("mysum",1,MySum)
cur=con.cursor()
cur.execute("create table test(i)")
cur.execute("insert into test(i) values (1)")
cur.execute("insert into test(i) values (2)")
cur.execute("select mysum(i) from test")
print(cur.fetchone()[0])
con.close()

create_collation(name, callable)¶

使用 name 和 callable 创建排序规则。这个 callable 接受两个字符串对象，如果第一个小于第二个则返回 -1， 如果两个相等则返回 0，如果第一个大于第二个则返回 1。注意，这是用来控制排序的（SQL 中的 ORDER BY），所以它不会影响其它的 SQL 操作。

注意，这个 callable 可调用对象会把它的参数作为 Python 字节串，通常会以 UTF-8 编码格式对它进行编码。

以下示例显示了使用“错误方式”进行排序的自定义排序规则：

importsqlite3
defcollate_reverse(string1,string2):
ifstring1==string2:
return0
elifstring1<string2:
return1
else:
return-1
con=sqlite3.connect(":memory:")
con.create_collation("reverse",collate_reverse)
cur=con.cursor()
cur.execute("create table test(x)")
cur.executemany("insert into test(x) values (?)",[("a",),("b",)])
cur.execute("select x from test order by x collate reverse")
forrowincur:
print(row)
con.close()

要移除一个排序规则，需要调用 create_collation 并设置 callable 参数为 None。

con.create_collation("reverse",None)

interrupt()¶

可以从不同的线程调用这个方法来终止所有查询操作，这些查询操作可能正在连接上执行。此方法调用之后， 查询将会终止，而且查询的调用者会获得一个异常。

set_authorizer(authorizer_callback)¶

此方法注册一个授权回调对象。每次在访问数据库中某个表的某一列的时候，这个回调对象将会被调用。如果要允许访问，则返回 SQLITE_OK，如果要终止整个 SQL 语句，则返回 SQLITE_DENY，如果这一列需要当做 NULL 值处理，则返回 SQLITE_IGNORE。这些常量可以在 sqlite3 模块中找到。

回调的第一个参数表示要授权的操作类型。 第二个和第三个参数将是参数或 None，具体取决于第一个参数的值。 第 4 个参数是数据库的名称（“main”，“temp”等），如果需要的话。 第 5 个参数是负责访问尝试的最内层触发器或视图的名称，或者如果此访问尝试直接来自输入 SQL 代码，则为 None。

请参阅 SQLite 文档，了解第一个参数的可能值以及第二个和第三个参数的含义，具体取决于第一个参数。 所有必需的常量都可以在 sqlite3 模块中找到。

set_progress_handler(handler, n)¶

此例程注册回调。 对SQLite虚拟机的每个多指令调用回调。 如果要在长时间运行的操作期间从SQLite调用（例如更新用户界面），这非常有用。

如果要清除以前安装的任何进度处理程序，调用该方法时请将 handler 参数设置为 None。

从处理函数返回非零值将终止当前正在执行的查询并导致它引发 OperationalError 异常。

set_trace_callback(trace_callback)¶

为每个 SQLite 后端实际执行的 SQL 语句注册要调用的 trace_callback。

传递给回调的唯一参数是正在执行的语句（作为字符串）。 回调的返回值将被忽略。 请注意，后端不仅运行传递给 Cursor.execute() 方法的语句。 其他来源包括 Python 模块的事务管理和当前数据库中定义的触发器的执行。

将传入的 trace_callback 设为 None 将禁用跟踪回调。

3.3 新版功能.

enable_load_extension(enabled)¶

此例程允许/禁止SQLite引擎从共享库加载SQLite扩展。 SQLite扩展可以定义新功能，聚合或全新的虚拟表实现。 一个众所周知的扩展是与SQLite一起分发的全文搜索扩展。

默认情况下禁用可加载扩展。 见 1.

3.2 新版功能.

importsqlite3
con=sqlite3.connect(":memory:")
# enable extension loading
con.enable_load_extension(True)
# Load the fulltext search extension
con.execute("select load_extension('./fts3.so')")
# alternatively you can load the extension using an API call:
# con.load_extension("./fts3.so")
# disable extension loading again
con.enable_load_extension(False)
# example from SQLite wiki
con.execute("create virtual table recipe using fts3(name, ingredients)")
con.executescript("""
    insert into recipe (name, ingredients) values ('broccoli stew', 'broccoli peppers cheese tomatoes');
    insert into recipe (name, ingredients) values ('pumpkin stew', 'pumpkin onions garlic celery');
    insert into recipe (name, ingredients) values ('broccoli pie', 'broccoli cheese onions flour');
    insert into recipe (name, ingredients) values ('pumpkin pie', 'pumpkin sugar flour butter');
    """)
forrowincon.execute("select rowid, name, ingredients from recipe where name match 'pie'"):
print(row)
con.close()

load_extension(path)¶

此例程从共享库加载SQLite扩展。 在使用此例程之前，必须使用 enable_load_extension() 启用扩展加载。

默认情况下禁用可加载扩展。 见 1.

3.2 新版功能.

row_factory¶

您可以将此属性更改为可接受游标和原始行作为元组的可调用对象，并将返回实际结果行。 这样，您可以实现更高级的返回结果的方法，例如返回一个可以按名称访问列的对象。

示例:

importsqlite3
defdict_factory(cursor,row):
d={}
foridx,colinenumerate(cursor.description):
d[col[0]]=row[idx]
returnd
con=sqlite3.connect(":memory:")
con.row_factory=dict_factory
cur=con.cursor()
cur.execute("select 1 as a")
print(cur.fetchone()["a"])
con.close()

如果返回一个元组是不够的，并且你想要对列进行基于名称的访问，你应该考虑将 row_factory 设置为高度优化的 sqlite3.Row 类型。 Row 提供基于索引和不区分大小写的基于名称的访问，几乎没有内存开销。 它可能比您自己的基于字典的自定义方法甚至基于 db_row 的解决方案更好。

text_factory¶

使用此属性可以控制为 TEXT 数据类型返回的对象。 默认情况下，此属性设置为 str 和 sqlite3 模块将返回 TEXT 的 Unicode 对象。 如果要返回字节串，可以将其设置为 bytes。

您还可以将其设置为接受单个 bytestring 参数的任何其他可调用对象，并返回结果对象。

请参阅以下示例代码以进行说明：

importsqlite3
con=sqlite3.connect(":memory:")
cur=con.cursor()
AUSTRIA="\xd6sterreich"
# by default, rows are returned as Unicode
cur.execute("select ?",(AUSTRIA,))
row=cur.fetchone()
assertrow[0]==AUSTRIA
# but we can make sqlite3 always return bytestrings ...
con.text_factory=bytes
cur.execute("select ?",(AUSTRIA,))
row=cur.fetchone()
asserttype(row[0])isbytes
# the bytestrings will be encoded in UTF-8, unless you stored garbage in the
# database ...
assertrow[0]==AUSTRIA.encode("utf-8")
# we can also implement a custom text_factory ...
# here we implement one that appends "foo" to all strings
con.text_factory=lambdax:x.decode("utf-8")+"foo"
cur.execute("select ?",("bar",))
row=cur.fetchone()
assertrow[0]=="barfoo"
con.close()

total_changes¶

返回自打开数据库连接以来已修改，插入或删除的数据库行的总数。

iterdump()¶

返回以SQL文本格式转储数据库的迭代器。 保存内存数据库以便以后恢复时很有用。 此函数提供与 sqlite3 shell 中的 .dump 命令相同的功能。

示例:

# Convert file existing_db.db to SQL dump file dump.sql
importsqlite3
con=sqlite3.connect('existing_db.db')
withopen('dump.sql','w')asf:
forlineincon.iterdump():
f.write('%s\n'%line)
con.close()

backup(target, *, pages=0, progress=None, name="main", sleep=0.250)¶

即使在 SQLite 数据库被其他客户端访问时，或者同时由同一连接访问，该方法也会对其进行备份。 该副本将写入强制参数 target，该参数必须是另一个 Connection 实例。

默认情况下，或者当 pages 为 0 或负整数时，整个数据库将在一个步骤中复制；否则该方法一次循环复制 pages 规定数量的页面。

如果指定了 progress，则它必须为 None 或一个将在每次迭代时附带三个整数参数执行的可调用对象，这三个参数分别是前一次迭代的状态 status，将要拷贝的剩余页数 remaining 以及总页数 total。

name 参数指定将被拷贝的数据库名称：它必须是一个字符串，其内容为表示主数据库的默认值 "main"，表示临时数据库的 "temp" 或是在 ATTACHDATABASE 语句的 AS 关键字之后指定表示附加数据库的名称。

sleep 参数指定在备份剩余页的连续尝试之间要休眠的秒数，可以指定为一个整数或一个浮点数值。

示例一，将现有数据库复制到另一个数据库中：

importsqlite3
defprogress(status,remaining,total):
print(f'Copied {total-remaining} of {total} pages...')
con=sqlite3.connect('existing_db.db')
bck=sqlite3.connect('backup.db')
withbck:
con.backup(bck,pages=1,progress=progress)
bck.close()
con.close()

示例二，将现有数据库复制到临时副本中：

importsqlite3
source=sqlite3.connect('existing_db.db')
dest=sqlite3.connect(':memory:')
source.backup(dest)

可用性：SQLite 3.6.11 或以上版本

3.7 新版功能.

Cursor 对象¶

class sqlite3.Cursor¶

Cursor 游标实例具有以下属性和方法。

execute(sql[, parameters])¶

执行SQL语句。 可以是参数化 SQL 语句（即，在 SQL 语句中使用占位符）。sqlite3 模块支持两种占位符：问号（qmark风格）和命名占位符（命名风格）。

以下是两种风格的示例：

importsqlite3
con=sqlite3.connect(":memory:")
cur=con.cursor()
cur.execute("create table people (name_last, age)")
who="Yeltsin"
age=72
# This is the qmark style:
cur.execute("insert into people values (?, ?)",(who,age))
# And this is the named style:
cur.execute("select * from people where name_last=:who and age=:age",{"who":who,"age":age})
print(cur.fetchone())
con.close()

execute() 将只执行一条单独的 SQL 语句。 如果你尝试用它执行超过一条语句，将会引发 Warning。 如果你想要用一次调用执行多条 SQL 语句请使用 executescript()。

executemany(sql, seq_of_parameters)¶

基于在序列 seq_of_parameters 中找到的所有形参序列或映射执行一条 SQL 命令。 sqlite3 模块还允许使用 iterator 代替序列来产生形参。

importsqlite3
classIterChars:
def__init__(self):
self.count=ord('a')
def__iter__(self):
returnself
def__next__(self):
ifself.count>ord('z'):
raiseStopIteration
self.count+=1
return(chr(self.count-1),)# this is a 1-tuple
con=sqlite3.connect(":memory:")
cur=con.cursor()
cur.execute("create table characters(c)")
theIter=IterChars()
cur.executemany("insert into characters(c) values (?)",theIter)
cur.execute("select c from characters")
print(cur.fetchall())
con.close()

这是一个使用生成器 generator 的简短示例：

importsqlite3
importstring
defchar_generator():
forcinstring.ascii_lowercase:
yield(c,)
con=sqlite3.connect(":memory:")
cur=con.cursor()
cur.execute("create table characters(c)")
cur.executemany("insert into characters(c) values (?)",char_generator())
cur.execute("select c from characters")
print(cur.fetchall())
con.close()

executescript(sql_script)¶

这是一个非标准的便捷方法，可用于一次执行多条 SQL 语句。 它会首先执行一条 COMMIT 语句，再执行以形参方式获取的 SQL 脚本。

sql_script 可以是一个 str 类的实例。

示例:

importsqlite3
con=sqlite3.connect(":memory:")
cur=con.cursor()
cur.executescript("""
    create table person(
        firstname,
        lastname,
        age
    );
    create table book(
        title,
        author,
        published
    );
    insert into book(title, author, published)
    values (
        'Dirk Gently''s Holistic Detective Agency',
        'Douglas Adams',
        1987
    );
    """)
con.close()

fetchone()¶

获取一个查询结果集的下一行，返回一个单独序列，或是在没有更多可用数据时返回 None。

fetchmany(size=cursor.arraysize)¶

获取下一个多行查询结果集，返回一个列表。 当没有更多可用行时将返回一个空列表。

每次调用获取的行数由 size 形参指定。 如果没有给出该形参，则由 cursor 的 arraysize 决定要获取的行数。 此方法将基于 size 形参值尝试获取指定数量的行。 如果获取不到指定的行数，则可能返回较少的行。

请注意 size 形参会涉及到性能方面的考虑。为了获得优化的性能，通常最好是使用 arraysize 属性。 如果使用 size 形参，则最好在从一个 fetchmany() 调用到下一个调用之间保持相同的值。

fetchall()¶

获取一个查询结果的所有（剩余）行，返回一个列表。 请注意 cursor 的 arraysize 属性会影响此操作的执行效率。 当没有可用行时将返回一个空列表。

close()¶

立即关闭 cursor（而不是在当 __del__ 被调用的时候）。

从这一时刻起该 cursor 将不再可用，如果再尝试用该 cursor 执行任何操作将引发 ProgrammingError 异常。

rowcount¶

虽然 sqlite3 模块的 Cursor 类实现了此属性，但数据库引擎本身对于确定 "受影响行"/"已选择行" 的支持并不完善。

对于 executemany() 语句，修改行数会被汇总至 rowcount。

根据 Python DB API 规格描述的要求，rowcount 属性 "当未在 cursor 上执行 executeXX() 或者上一次操作的 rowcount 不是由接口确定时为 -1"。 这包括 SELECT 语句，因为我们无法确定一次查询将产生的行计数，而要等获取了所有行时才会知道。。

在 SQLite 的 3.6.5 版之前，如果你执行 DELETEFROMtable 时不附带任何条件，则 rowcount 将被设为 0。

lastrowid¶

这个只读属性会提供最近修改行的 rowid。 它只在你使用 execute() 方法执行 INSERT 或 REPLACE 语句时会被设置。 对于 INSERT 或 REPLACE 以外的操作或者当 executemany() 被调用时，lastrowid 会被设为 None。

如果 INSERT 或 REPLACE 语句操作失败则将返回上一次成功操作的 rowid。

在 3.6 版更改: 增加了 REPLACE 语句的支持。

arraysize¶

用于控制 fetchmany() 返回行数的可读取/写入属性。 该属性的默认值为 1，表示每次调用将获取单独一行。

description¶

这个只读属性将提供上一次查询的列名称。 为了与 Python DB API 保持兼容，它会为每个列返回一个 7 元组，每个元组的最后六个条目均为 None。

对于没有任何匹配行的 SELECT 语句同样会设置该属性。

connection¶

这个只读属性将提供 Cursor 对象所使用的 SQLite 数据库 Connection。 通过调用 con.cursor() 创建的 Cursor 对象所包含的 connection 属性将指向 con:

>>> con=sqlite3.connect(":memory:")
>>> cur=con.cursor()
>>> cur.connection==con
True

行对象*Row*¶

class sqlite3.Row¶

一个 Row 实例，该实例将作为用于 Connection 对象的高度优化的 row_factory。 它的大部分行为都会模仿元组的特性。

它支持使用列名称的映射访问以及索引、迭代、文本表示、相等检测和 len() 等操作。

如果两个 Row 对象具有完全相同的列并且其成员均相等，则它们的比较结果为相等。

keys()¶

此方法会在一次查询之后立即返回一个列名称的列表，它是 Cursor.description 中每个元组的第一个成员。

在 3.5 版更改: 添加了对切片操作的支持。

让我们假设我们如上面的例子所示初始化一个表:

conn=sqlite3.connect(":memory:")
c=conn.cursor()
c.execute('''create table stocks
(date text, trans text, symbol text,
 qty real, price real)''')
c.execute("""insert into stocks
          values ('2006-01-05','BUY','RHAT',100,35.14)""")
conn.commit()
c.close()

现在我们将 Row 插入:

>>> conn.row_factory=sqlite3.Row
>>> c=conn.cursor()
>>> c.execute('select * from stocks')
<sqlite3.Cursor object at 0x7f4e7dd8fa80>
>>> r=c.fetchone()
>>> type(r)
<class 'sqlite3.Row'>
>>> tuple(r)
('2006-01-05', 'BUY', 'RHAT', 100.0, 35.14)
>>> len(r)
5
>>> r[2]
'RHAT'
>>> r.keys()
['date', 'trans', 'symbol', 'qty', 'price']
>>> r['qty']
100.0
>>> formemberinr:
... print(member)
...
2006-01-05
BUY
RHAT
100.0
35.14

classPoint:
def__init__(self,x,y):
self.x,self.y=x,y

importsqlite3
classPoint:
def__init__(self,x,y):
self.x,self.y=x,y
def__conform__(self,protocol):
ifprotocolissqlite3.PrepareProtocol:
return"%f;%f"%(self.x,self.y)
con=sqlite3.connect(":memory:")
cur=con.cursor()
p=Point(4.0,-3.2)
cur.execute("select ?",(p,))
print(cur.fetchone()[0])
con.close()

importsqlite3
classPoint:
def__init__(self,x,y):
self.x,self.y=x,y
defadapt_point(point):
return"%f;%f"%(point.x,point.y)
sqlite3.register_adapter(Point,adapt_point)
con=sqlite3.connect(":memory:")
cur=con.cursor()
p=Point(4.0,-3.2)
cur.execute("select ?",(p,))
print(cur.fetchone()[0])
con.close()

importsqlite3
importdatetime
importtime
defadapt_datetime(ts):
returntime.mktime(ts.timetuple())
sqlite3.register_adapter(datetime.datetime,adapt_datetime)
con=sqlite3.connect(":memory:")
cur=con.cursor()
now=datetime.datetime.now()
cur.execute("select ?",(now,))
print(cur.fetchone()[0])
con.close()

defconvert_point(s):
x,y=map(float,s.split(b";"))
returnPoint(x,y)

importsqlite3
classPoint:
def__init__(self,x,y):
self.x,self.y=x,y
def__repr__(self):
return"(%f;%f)"%(self.x,self.y)
defadapt_point(point):
return("%f;%f"%(point.x,point.y)).encode('ascii')
defconvert_point(s):
x,y=list(map(float,s.split(b";")))
returnPoint(x,y)
# Register the adapter
sqlite3.register_adapter(Point,adapt_point)
# Register the converter
sqlite3.register_converter("point",convert_point)
p=Point(4.0,-3.2)
#########################
# 1) Using declared types
con=sqlite3.connect(":memory:",detect_types=sqlite3.PARSE_DECLTYPES)
cur=con.cursor()
cur.execute("create table test(p point)")
cur.execute("insert into test(p) values (?)",(p,))
cur.execute("select p from test")
print("with declared types:",cur.fetchone()[0])
cur.close()
con.close()
#######################
# 1) Using column names
con=sqlite3.connect(":memory:",detect_types=sqlite3.PARSE_COLNAMES)
cur=con.cursor()
cur.execute("create table test(p)")
cur.execute("insert into test(p) values (?)",(p,))
cur.execute('select p as "p [point]" from test')
print("with column names:",cur.fetchone()[0])
cur.close()
con.close()

importsqlite3
importdatetime
con=sqlite3.connect(":memory:",detect_types=sqlite3.PARSE_DECLTYPES|sqlite3.PARSE_COLNAMES)
cur=con.cursor()
cur.execute("create table test(d date, ts timestamp)")
today=datetime.date.today()
now=datetime.datetime.now()
cur.execute("insert into test(d, ts) values (?, ?)",(today,now))
cur.execute("select d, ts from test")
row=cur.fetchone()
print(today,"=>",row[0],type(row[0]))
print(now,"=>",row[1],type(row[1]))
cur.execute('select current_date as "d [date]", current_timestamp as "ts [timestamp]"')
row=cur.fetchone()
print("current_date",row[0],type(row[0]))
print("current_timestamp",row[1],type(row[1]))
con.close()

importsqlite3
persons=[
("Hugo","Boss"),
("Calvin","Klein")
]
con=sqlite3.connect(":memory:")
# Create the table
con.execute("create table person(firstname, lastname)")
# Fill the table
con.executemany("insert into person(firstname, lastname) values (?, ?)",persons)
# Print the table contents
forrowincon.execute("select firstname, lastname from person"):
print(row)
print("I just deleted",con.execute("delete from person").rowcount,"rows")
# close is not a shortcut method and it's not called automatically,
# so the connection object should be closed manually
con.close()

importsqlite3
con=sqlite3.connect(":memory:")
con.row_factory=sqlite3.Row
cur=con.cursor()
cur.execute("select 'John' as name, 42 as age")
forrowincur:
assertrow[0]==row["name"]
assertrow["name"]==row["nAmE"]
assertrow[1]==row["age"]
assertrow[1]==row["AgE"]
con.close()

importsqlite3
con=sqlite3.connect(":memory:")
con.execute("create table person (id integer primary key, firstname varchar unique)")
# Successful, con.commit() is called automatically afterwards
withcon:
con.execute("insert into person(firstname) values (?)",("Joe",))
# con.rollback() is called after the with block finishes with an exception, the
# exception is still raised and must be caught
try:
withcon:
con.execute("insert into person(firstname) values (?)",("Joe",))
exceptsqlite3.IntegrityError:
print("couldn't add Joe twice")
# Connection object used as context manager only commits or rollbacks transactions,
# so the connection object should be closed manually
con.close()