精华内容
下载资源
问答
  • 主要介绍了Python sqlite3事务处理方法,结合具体实例形式分析了Python针对sqlite3事务处理的操作技巧,代码中包含详尽的注释,需要的朋友可以参考下
  • 2019独角兽企业重金招聘Python工程师标准>>> ...

    Python sqlite3 的事务控制

    官方文档的描述:

    Controlling Transactions

    By default, the sqlite3 module opens transactions implicitly before a Data Modification Language (DML) statement (i.e. INSERT/UPDATE/DELETE/REPLACE), and commits transactions implicitly before a non-DML, non-query statement (i. e. anything other than SELECT or the aforementioned).

    So if you are within a transaction and issue a command like CREATE TABLE ...VACUUMPRAGMA, thesqlite3 module will commit implicitly before executing that command. There are two reasons for doing that. The first is that some of these commands don’t work within transactions. The other reason is that pysqlite needs to keep track of the transaction state (if a transaction is active or not).

    You can control which kind of BEGIN statements sqlite3 implicitly executes (or none at all) via the isolation_level parameter to the connect() call, or via the isolation_level property of connections.

    (译文:你能控制sqlite3默认执行的BEGIN语句类型(或者什么类型都不),这是通过设置connect()函数的isolation_level 参数,或connection对象的isolation_level属性实现的。)

    If you want autocommit mode, then set isolation_level to None.

    (译文:如果想使用自动提交模式,设置isolation_level为None。)

    Otherwise leave it at its default, which will result in a plain “BEGIN” statement, or set it to one of SQLite’s supported isolation levels: “DEFERRED”, “IMMEDIATE” or “EXCLUSIVE”.

    (译文:不设置isolation_level(使用默认)将会执行朴素的BEGIN语句(即下文sql语句图中,BEGIN或BEGIN TRANSACTION),或者设置为“DEFERRED”, “IMMEDIATE” 或“EXCLUSIVE”(即BEGIN DEFERRED/IMMEDIATE/EXCLUSIVE TRANSACTION)。)

    isolation_level控制的是什么

    从上文我们看到,这个变量与BEGIN语句的模式有关,可选值为 “None“,“空“(不设置),“DEFERRED”, “IMMEDIATE” ,“EXCLUSIVE”

    设置为None即自动提交,即每次写数据库都提交。
    官网文档前两段写的是智能提交,在某些语句自动开启事务,执行某些语句前自动commit。

    后边四个是什么?

    后来我找到sqlite官方的这个图:
    https://www.sqlite.org/lang_transaction.html 
    https://grox.net/doc/sqlite/lang_transaction.html

    syntax diagram begin-stmt

    注:原文中begin-stmt应该是begin-statement的缩写

    这是描述sql语句语法的图,即:

    BEGIN TRANSACTION
    BEGIN
    BEGIN DEFERRED TRANSACTION
    BEGIN DEFERRED

    ...

    情况就明了了,isolation_level决定开启事务时使用的是BEGIN TRANSACTION, BEGIN DEFERRED TRANSACTION, BEGIN IMMEDIATE TRANSACTION, BEGIN EXCLUSIVE TRANSACTION中的那种。

    注:这几种类型的意义http://sqlite.1065341.n5.nabble.com/WAL-difference-between-IMMEDIATE-and-DEFERRED-transaction-td86669.html
    https://www.sqlite.org/lockingv3.html#excl_lock

    我是这么认为的,immediate 是begin语句处获得PENDING锁,deferred是获取RESERVED锁,update,delete,insert等写语句出现时才获得PENDING锁,exclusive是获取EXCLUSIVE排他锁

    isolation_level为None是开启自动commit功能,非None是设置BEGIN的类型,开启智能commit。

    我理解为:1.BEGIN是自动开启的 2.设为None每次写数据库都会自动commit 3.设为其他会在某些语句前自动commit,其他地方想立即commit要手动执行。

    例子来了!

    智能commit

    import sqlite3
    
    con = sqlite3.connect(":memory:")
    cur = con.cursor()
    cur.execute("create table people (num, age)")
    
    num = 1 
    age = 2 * num 
    
    while num <= 1000000:
        cur.execute("insert into people values (?, ?)", (num, age))
        num += 1
        age = 2 * num 
    
    cur.execute("select count(*) from people")
    
    print cur.fetchone()

    保存为test.py执行之

    # time python test.py
    (1000000,)

    real    0m6.537s
    user    0m6.440s
    sys     0m0.086s

    自动commit

    import sqlite3
    
    con = sqlite3.connect(":memory:",isolation_level=None)
    cur = con.cursor()
    cur.execute("create table people (num, age)")
    
    num = 1 
    age = 2 * num 
    
    while num <= 1000000:
        cur.execute("insert into people values (?, ?)", (num, age))
        num += 1
        age = 2 * num 
    
    cur.execute("select count(*) from people")
    
    print cur.fetchone()

     执行之

    # time python test.py
    (1000000,)

    real    0m10.693s
    user    0m10.569s
    sys     0m0.099s

    智能commit用时6秒,自动commit用时10秒 (例子是写内存,如果写文件速度会更慢,建议改为写100条数据)

    智能commit
    优点:速度快,单进程情况下运行良好
    缺点:多个控制流并发操作数据库时,这边写完了,另一边可能读不出来
    克服缺点:每次写完数据,手动执行commit

    自动commit
    优点:每次写数据库都能保证确实写入了,防止并发操作数据库时出现逻辑问题
    缺点:太慢了!!!
    克服缺点:批量操作前手动BEGIN TRANSACTION,操作后手动COMMIC

    克服缺点的例子

    智能commit时实现即时commit

    # coding:utf-8
    import sqlite3
    
    con = sqlite3.connect(":memory:")
    cur = con.cursor()
    cur.execute("create table people (num, age)")
    
    num = 1 
    age = 2 * num 
    
    while num <= 1000000:
        cur.execute("insert into people values (?, ?)", (num, age))
        con.commit()  # 关键在这里
        num += 1
        age = 2 * num 
    
    cur.execute("select count(*) from people")
    
    print cur.fetchone()

    time python test.py
    (1000000,)

    real    0m20.797s
    user    0m20.611s
    sys     0m0.156s

    自动commit时阻止即时commit

    # coding:utf-8
    import sqlite3
    
    con = sqlite3.connect(":memory:",isolation_level=None)
    cur = con.cursor()
    cur.execute("create table people (num, age)")
    
    num = 1 
    age = 2 * num 
    
    cur.execute("BEGIN TRANSACTION") # 关键点
    while num <= 1000000:
        cur.execute("insert into people values (?, ?)", (num, age))
        num += 1
        age = 2 * num 
    cur.execute("COMMIT")  #关键点
    
    cur.execute("select count(*) from people")
    print cur.fetchone()

     # time python test.py
    (1000000,)

    real    0m6.649s
    user    0m6.555s
    sys     0m0.076s

    这次,智能commit用时20秒(性能下降很多),自动commit用时6秒 ,完全反过来了

    注:sqlite API中有个executemany()函数,和循环execute是一样的,自动commit情况下执行慢的话,需要手动开启事务,提交commit。
    http://stackoverflow.com/questions/35013453/apsw-or-sqlite3-very-slow-insert-on-executemany

    转载于:https://my.oschina.net/tinyhare/blog/719039

    展开全文
  • python SQLite数据库

    2020-04-30 17:01:04
    简介 SQLite 是一种轻型嵌入式关系型数据库,它包含在一个相对小的 C 库中。SQLite 占用资源低,处理速度快,它... SQLite 是一个进程内的库,它实现了自给自足、无服务器、无需配置、支持事务Python 可以通过...
    • 简介

          SQLite 是一种轻型嵌入式关系型数据库,它包含在一个相对小的 C 库中。SQLite 占用资源低,处理速度快,它支持 Windows、Linux、Unix 等多种主流操作系统,支持 Python、Java、C# 等多种语言,目前的版本已经发展到了 SQLite3

         SQLite 是一个进程内的库,它实现了自给自足、无服务器、无需配置、支持事务。Python 可以通过 sqlite3 模块与 SQLite3 集成,Python 2.5.x 以上版本内置了 sqlite3 模块,因此,我们在 Python 中可以直接使用 SQLite

     

    # 导入SQLite驱动:
    >>> import sqlite3
    # 连接到SQLite数据库
    # 数据库文件是test.db
    # 如果文件不存在,会自动在当前目录创建:
    >>> conn = sqlite3.connect('test.db')
    # 创建一个Cursor:
    >>> cursor = conn.cursor()
    # 执行一条SQL语句,创建user表:
    >>> cursor.execute('create table user (id varchar(20) primary key, name varchar(20))')
    <sqlite3.Cursor object at 0x10f8aa260>
    # 继续执行一条SQL语句,插入一条记录:
    >>> cursor.execute('insert into user (id, name) values (\'1\', \'Michael\')')
    <sqlite3.Cursor object at 0x10f8aa260>
    # 通过rowcount获得插入的行数:
    >>> cursor.rowcount
    1
    # 关闭Cursor:
    >>> cursor.close()
    # 提交事务:
    >>> conn.commit()
    # 关闭Connection:
    >>> conn.close()
    >>> conn = sqlite3.connect('test.db')
    >>> cursor = conn.cursor()
    # 执行查询语句:
    >>> cursor.execute('select * from user where id=?', ('1',))
    <sqlite3.Cursor object at 0x10f8aa340>
    # 获得查询结果集:
    >>> values = cursor.fetchall()
    >>> values
    [(u'1', u'Michael')]
    >>> cursor.close()
    >>> conn.close()
    • SQLite 数据类型

      在介绍使用之前,我们先了解下 SQLite 数据类型。

    • SQLite 采用动态数据类型,也就是说数据的类型取决于数据本身。

    • 存储类型

      存储类型就是数据保存成文件后的表现形式,存储类型有 5 种,如下所示

    • 类型 描述
      NULL 空值
      INTEGER 有符号的整数类型
      REAL 浮点数类型
      TEXT 字符串,使用数据库编码(UTF-8、UTF-16BE 或 UTF-16LE)存储
      BLOB 二进制表示
    • 亲和类型

      亲和类型简单来说就是数据表列的数据对应存储类型的倾向性,当数据插入时,字段的数据将会优先采用亲缘类型作为值的存储方式,同样有 5 种,如下所示:

    • 类型 描述
      NONE 不做任何转换,直接以该数据所属的数据类型进行存储
      NUMERIC 该列可以包含使用所有五个存储类型的值
      INTEGER 类似于 NUMERIC,区别是在执行 CAST 表达式时
      TEXT 该列使用存储类型 NULL、TEXT 或 BLOB 存储数据
      REAL 类似于 NUMERIC,区别是它会强制把整数值转换为浮点类型
    • 声明类型

      声明类型也就是我们写 SQL 时字段定义的类型,我们看一下常用的声明类型与亲和类型的对应关系。

    • 声明类型 亲和类型
      INT/INTEGER/TINYINT/BIGINT INTEGER
      VARCHAR/TEXT/CLOB TEXT
      BLOB NONE
      DOUBLE/FLOAT REAL
      DECIMAL/BOOLEAN/DATE/DATETIME NUMERIC
    展开全文
  • python SQLite数据库操作

    万次阅读 2020-05-05 10:38:42
    SQLite是一个软件库,实现了自给自足的、无服务器的、零配置的、事务性的 SQL 数据库引擎。SQLite是一个增长最快的数据库引擎,这是在普及方面的增长,与它的尺寸大小无关。SQLite 源代码不受版权限制。 它是一个零...

    SQLite

    SQLite是一个软件库,实现了自给自足的、无服务器的、零配置的、事务性的 SQL 数据库引擎。SQLite是一个增长最快的数据库引擎,这是在普及方面的增长,与它的尺寸大小无关。SQLite 源代码不受版权限制。
    它是一个零配置的数据库,这意味着与其他数据库一样,您不需要在系统中配置。

    SQLite数据库优点

    1. 不需要一个单独的服务器进程或操作的系统(无服务器的)
    2. SQLite 不需要配置,这意味着不需要安装或管理
    3. 一个完整的 SQLite 数据库是存储在一个单一的跨平台的磁盘文件
    4. SQLite 是非常小的,是轻量级的
    5. SQLite 是自给自足的,这意味着不需要任何外部的依赖
    6. SQLite 可在 UNIX(Linux, Mac OS-X, Android, iOS)和 Windows(Win32, WinCE, WinRT)中运行

    代码实现SQLite创建、插入、查询、删除操作

    import sqlite3
    class Mysqlite(object):
        def __init__(self,dbpath):
            # 如果不存在则创建
            self.con = sqlite3.connect(dbpath)
            self.cur = self.con.cursor()
    
        def __del__(self):
            self.close()
        
        def execute_sqlite3(self,sql):
            # 命令处理
            sql = sql.lower()
            if 'insert' in sql or 'delete' in sql or  'update' in sql or  'create' in sql:
                self.cur.execute(sql)
                self.con.commit()
                print('done..')
                return 
            elif 'select' in sql :
                self.cur.execute(sql)
                data = self.cur.fetchall()
                print(data)
                return data
    
        def create_table(self,table_name,title):
            # 自定义创建表
            sql = "CREATE TABLE {}({})".format(table_name,title)
            self.execute_sqlite3(sql)
    
        def insert_value(self,table_name,value):
            # 插入自定义数据
            sql = "INSERT INTO {} values({})".format(table_name,value)
            self.execute_sqlite3(sql)
    
        def select_data(self,table_name):
            # 查询数据
            sql = "SELECT * FROM {}".format(table_name)
            self.execute_sqlite3(sql)
    
        def update_data(self,table_name,field,value,id):
            # 修改数据
            sql = "UPDATE {} set {} = '{}' where id = {}".format(table_name,field,value,id)
            self.execute_sqlite3(sql)
        
        def delete_data(self,table_name,id):
            # 删除数据
            sql = "DELETE FROM {} where id = {}".format(table_name,id)
            self.execute_sqlite3(sql)
    
        def close(self):
            # 关闭资源
            self.cur.close()
            self.con.close()
    
    if __name__ == "__main__":
        sqlite = Mysqlite('test.db')
        table_name = 'foo'
        try:
            sqlite.create_table(table_name,'id integer primary key autoincrement, name varchar(128), info varchar(128)')
        except:
            print("{} created..")
        sqlite.insert_value(table_name,'NULL,\"apple\",\"broccoli\"')
        sqlite.select_data(table_name)
        sqlite.update_data(table_name,'name',"orange",1)
        sqlite.select_data(table_name)
        sqlite.delete_data(table_name,2)
        sqlite.select_data(table_name)
    

    运行结果

    在这里插入图片描述

    展开全文
  • python-sqlite3事务

    2017-02-18 16:09:00
    sqlite3事务总结: 在connect()中不传入 isolation_level 事务处理: 使用connection.commit() #!/usr/bin/env python # -*- coding:utf-8 -*- '''sqlite3事务总结: 在connect()中不传入 isolation_level ...

    sqlite3事务总结:

    在connect()中不传入 isolation_level

    事务处理:

    使用connection.commit()

    #!/usr/bin/env python
    # -*- coding:utf-8 -*-
    '''sqlite3事务总结:
    在connect()中不传入 isolation_level
    事务处理:
        使用connection.commit()
    
    分析:
        智能commit状态:
            生成方式: 在connect()中不传入 isolation_level, 此时isolation_level==''
                在进行 执行Data Modification Language (DML) 操作(INSERT/UPDATE/DELETE/REPLACE)时, 会自动打开一个事务,
                在执行 非DML, 非query (非 SELECT 和上面提到的)语句时, 会隐式执行commit
                可以使用 connection.commit()方法来进行提交
            注意:
                不能和cur.execute("COMMIT")共用
        
        自动commit状态:
            生成方式: 在connect()中传入 isolation_level=None
                这样,在任何DML操作时,都会自动提交
            事务处理
                connection.execute("BEGIN TRANSACTION")
                connection.execute("COMMIT")
            如果不使用事务, 批量添加数据非常缓慢
    
    数据对比:
        两种方式, 事务耗时差别不大
        count = 100000
            智能commit即时提交耗时: 0.621
            自动commit耗时: 0.601
            智能commit即时提交耗时: 0.588
            自动commit耗时: 0.581
            智能commit即时提交耗时: 0.598
            自动commit耗时: 0.588
            智能commit即时提交耗时: 0.589
            自动commit耗时: 0.602
            智能commit即时提交耗时: 0.588
            自动commit耗时: 0.622
    '''
    
    
    import sys
    import time
    
    
    class Elapse_time(object):
        '''耗时统计工具'''
        def __init__(self, prompt=''):
            self.prompt = prompt
            self.start = time.time()
            
        def __del__(self):
            print('%s耗时: %.3f' % (self.prompt, time.time() - self.start))
    CElapseTime = Elapse_time
    
    import sqlite3
    
    # -------------------------------------------------------------------------------
    # 测试
    #
    
    filename = 'e:/temp/a.db'
    
    def prepare(isolation_level = ''):
        connection = sqlite3.connect(filename, isolation_level = isolation_level)
        connection.execute("create table IF NOT EXISTS  people (num, age)")
        connection.execute('delete from people')
        connection.commit()
        return connection, connection.cursor()
    
    def db_insert_values(cursor, count):
        num = 1 
        age = 2 * num 
        
        while num <= count:
            cursor.execute("insert into people values (?, ?)", (num, age))
            num += 1
            age = 2 * num 
    
    def study_case1_intelligent_commit(count):
        '''
        在智能commit状态下, 不能和cur.execute("COMMIT")共用
        '''
        connection, cursor = prepare()
        
        elapse_time = Elapse_time('  智能commit')
        db_insert_values(cursor, count)
        #cursor.execute("COMMIT")  #产生异常
        
        cursor.execute("select count(*) from people")
        print (cursor.fetchone())
        
    def study_case2_autocommit(count):
        connection, cursor = prepare(isolation_level = None)
        
        elapse_time = Elapse_time('  自动commit')
        db_insert_values(cursor, count)
        
        cursor.execute("select count(*) from people")    
        print (cursor.fetchone())
    
    
    def study_case3_intelligent_commit_manual(count):
        connection, cursor = prepare()
        
        elapse_time = Elapse_time('  智能commit即时提交')
        db_insert_values(cursor, count)
        connection.commit()
        
        cursor.execute("select count(*) from people")
        print (cursor.fetchone())
    
    
    def study_case4_autocommit_transaction(count):
        connection, cursor = prepare(isolation_level = None)
        
        elapse_time = Elapse_time('  自动commit')
        connection.execute("BEGIN TRANSACTION;") # 关键点
        db_insert_values(cursor, count)
        connection.execute("COMMIT;")  #关键点
        
        cursor.execute("select count(*) from people;")
        print (cursor.fetchone())
    
    
    if __name__ == '__main__':
        count = 10000
        prepare()
        for i in range(5):
            #study_case1_intelligent_commit(count) #不提交数据
            #study_case2_autocommit(count)  #非常缓慢
            study_case3_intelligent_commit_manual(count)
            study_case4_autocommit_transaction(count)

     

    转载于:https://www.cnblogs.com/yaoyu126/p/6413423.html

    展开全文
  • python sqlite3插入测试

    千次阅读 2013-09-24 16:44:46
    python sqlite3插入测试代码,默认情况下需要提交事务的,如果要设置con.isolation_level = None则每次自动提交事务: 当插入1000条数据时,自己提交事务用了,0.11s;程序自动提交事务用了1分半钟。     #!/...
  • Python sqlite模块

    千次阅读 2012-06-29 18:45:22
    #-*- encoding:gb2312 -*- ...conn.isolation_level = None #这个就是事务隔离级别,默认是需要自己commit才能修改数据库,置为None则自动每次修改都提交,否则为"" # 下面就是创建一个表 conn.execute("create table
  • Python SQLite3库

    2017-05-26 14:30:43
    SQLite3 API连接对象(connection)class sqlite3.Connection 方法 描述 cursor([cursorClass]) 游标方法接受单个可选参数cursorClass。 commit() 此方法提交当前事务。如果不调用此方法,自上次调用commit()后做...
  • Python SQLite3 基本操作类

    千次阅读 2019-05-17 16:26:10
    SQLite是一个进程内的库,实现了自给自足的、无服务器的、零配置的、事务性的 SQL 数据库引擎。它是一个零配置的数据库,这意味着与其他数据库一样,您不需要在系统中配置。 就像其他数据库,SQLite 引擎不是一个...
  • Python Sqlite3数据库相关操作

    千次阅读 2011-12-04 21:31:32
    cx= sqlite3.connect(‘database.db’) ,cx是一个数据库连接对象,它有以下操作: commit()--事务提交 rollback()--事务回滚 close()--关闭一个数据库连接 cursor()--创建一个游标 2、获得游标对象: ...
  • 一个简单的python sqlite wrapper

    千次阅读 2011-02-07 00:19:00
    sqlite执行事务操作的开销是很大的,所以应尽量减少执行commit的次数。我做了一个简单的实验,插入1百万行的数据(每行三列INT型数据),一条一条插入需要半个小时,而以128K为一个batch批量插入只需要3分钟。try:  ...
  • python操作sqlite数据库

    千次阅读 2018-04-18 22:34:08
    SQLite数据库是一款轻量级的数据库,无服务器、零配置、事务性的SQL数据库引擎。SQLite是世界上最广泛部署的SQL数据库引擎,而且SQLite的源代码不受版权限制,是小型项目和简单web应用的理想选择。SQLite数据库是一...
  • Python使用sqlite数据库

    2018-12-17 22:57:27
    文章目录SQLite简介Python的SQLitecreateinsertdeleteupdatequery完整代码 SQLite简介 SQLite 是一个软件库,实现了自给自足的、无服务器的、零配置的、事务性的 SQL 数据库引擎。SQLite 是在世界上最广泛部署的...
  • python调用sqlite

    2019-07-14 23:15:00
    参考资料:...SQLite是一个进程内的库,实现了自给自足的、无服务器的、零配置的、事务性的 SQL 数据库引擎。它是一个零配置的数据库,这意味着与其他数据库一样,您不...
  • Pythonsqlite3

    2018-02-01 10:49:00
    Python3内置了sqlite SQLite是一个软件库,实现了自给自足的、无服务器的、零配置的、事务性的 SQL 数据库引擎  是在世界上最广泛部署的 SQL 数据库引擎  SQLite 源代码不受版权限制 下载安装:...
  • python 操作sqlite3 python3 中已内置 sqlite3 可以直接使用 具体使用 1.import import sqlite3 2.获取数据库连接 conn = sqlite3.connect('test.db') 相关方法 conn.cursor() 创建一个游标对象 conn.commit() ...
  • SQLite是内嵌在Python中的轻量级、基于磁盘文件袋额数据库管理系统,不需要安装和配置服务,支持使用SQL语句来访问数据库。该数据库使用C语言开发,支持大多数SQL91标准,支持原子的、一致的、独立的和持久的事务,...
  • 一、环境 python版本:Python 3.6.8 sqlite版本:windows下的 ... SQLite是一个进程内的库,实现了自给自足的、无服务器的、零配置的、事务性的 SQL 数据库引擎。它是一个零配置的数据库,这意味着与其他数...
  • 如题,本文记录如何使用python上下文管理器的方式管理sqlite3的句柄创建和释放以及事务机制。 1、python上下文管理(with) python上下文管理(context),解决的是这样一类问题,在进入逻辑之前需要进行一些准备...
  • python 操作sqlite用法

    2013-10-21 15:55:38
    sqlite数据库是非常小巧,非常适用于嵌入式软件开发,且占用资源非常低。 打开数据库时返回的对象是一个数据库连接对象,它可以有以下操作: commit()--事务提交 rollback()--事务回滚 close()--关闭一个数据库...
  •  SQLite是一个进程内的库,实现了自给自足的、无服务器的、零配置的、事务性的 SQL 数据库引擎。它的设计目标是嵌入式的,而且目前已经在很多嵌入式产品中使用了它(如安卓系统),它占用资源非常的低...
  • SQLite是内嵌在Python中的轻量级、基于磁盘文件袋额数据库管理系统,不需要安装和配置服务,支持使用SQL语句来访问数据库。该数据库使用C语言开发,支持大多数SQL91标准,支持原子的、一致的、独立的和持久的事务,...
  • 官网介绍到SQLite是一个进程内库,它实现了一个自包含的、无服务器的、零配置的事务性SQL数据库引擎(官网:https://www.sqlite.org/)。后来也是偶然的机会,公司使用的数据库存储有问题,无意中看到了三线开发...
  • con = sqlite3.connect('D:\study\practice\python\sqlite3\mydb.db') #这个就是事务隔离级别,默认是需要自己commit才能修改数据库,置为None则自动每次修改都提交,否则为"" con.isolation_lev
  • 2019独角兽企业重金招聘Python工程师标准>>> ...
  • tips:python内嵌了SQLite文件数据库(嵌入式数据库),无需额外安装,一种自给自足、无服务器、零配置、事务性的 SQL 数据库引擎,它本身使用C语言写的,体积很小,可以被嵌入到很多应用中,甚至很多APP都使用sqlite...
  • 原因 MySQL事务隔离级别 解决方案 conn.commit() conn.close()   转载于:https://www.cnblogs.com/xdea/p/6250009.html

空空如也

空空如也

1 2 3 4 5 ... 9
收藏数 175
精华内容 70
关键字:

pythonsqlite事务

python 订阅