【sqlite】BEGIN TRANSACTION没用？NONONO！简简单单使插入效率提高100倍！！！

原创 已于 2025-10-15 15:44:17 修改 · 76 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#sqlite #数据库

于 2025-10-15 15:37:32 首次发布

当你不使用 BEGIN TRANSACTION;而直接执行一条 INSERT 语句时，SQLite 会默认将这条语句包装在一个短暂的、隐式的事务中。这个过程可以看作：

-- 你只写了这一句
INSERT INTO table_name ...;

-- SQLite 在背后为你做了这些
BEGIN TRANSACTION;
INSERT INTO table_name ...;
COMMIT;

根据SQLite的特性，使用事务的版本应该比不使用事务的版本快几十到几百倍。这是因为：

  • 隐式事务（单条语句，自动提交）：每条INSERT都要打开/关闭日志文件、获取/释放锁、同步磁盘

  • 显式事务：所有INSERT共享一次日志文件操作、一次锁获取、一次磁盘同步

实验如下，插入664579条数据，分别记录不带BEGIN TRANSACTION和带的情况下的耗时。

#include <iostream>
#include <vector>
#include <chrono>
#include <sqlite3.h>
#include <cmath>

class PrimeSieve {
private:
    std::vector<bool> is_prime;
    int limit;

public:
    PrimeSieve(int n) : limit(n) {
        is_prime.resize(n + 1, true);
        is_prime[0] = is_prime[1] = false;
    }

    std::vector<int> find_primes() {
        int sqrt_n = static_cast<int>(std::sqrt(limit));
        
        for (int i = 2; i <= sqrt_n; ++i) {
            if (is_prime[i]) {
                for (int j = i * i; j <= limit; j += i) {
                    is_prime[j] = false;
                }
            }
        }

        std::vector<int> primes;
        for (int i = 2; i <= limit; ++i) {
            if (is_prime[i]) {
                primes.push_back(i);
            }
        }
        return primes;
    }
};

class DatabaseManager {
private:
    sqlite3* db;
    
public:
    DatabaseManager() : db(nullptr) {}
    
    bool open_database(const std::string& db_name) {
        int rc = sqlite3_open(db_name.c_str(), &db);
        if (rc) {
            std::cerr << "无法打开数据库: " << sqlite3_errmsg(db) << std::endl;
            return false;
        }
        return true;
    }
    
    void close_database() {
        if (db) {
            sqlite3_close(db);
            db = nullptr;
        }
    }
    
    bool create_table() {
        const char* sql = "CREATE TABLE IF NOT EXISTS primes ("
                         "id INTEGER PRIMARY KEY AUTOINCREMENT, "
                         "prime_number INTEGER UNIQUE);";
        
        char* err_msg = nullptr;
        int rc = sqlite3_exec(db, sql, nullptr, nullptr, &err_msg);
        
        if (rc != SQLITE_OK) {
            std::cerr << "创建表失败: " << err_msg << std::endl;
            sqlite3_free(err_msg);
            return false;
        }
        
        // 清空表
        sql = "DELETE FROM primes;";
        rc = sqlite3_exec(db, sql, nullptr, nullptr, &err_msg);
        if (rc != SQLITE_OK) {
            std::cerr << "清空表失败: " << err_msg << std::endl;
            sqlite3_free(err_msg);
            return false;
        }
        
        return true;
    }
    
    // 不使用事务插入
    bool insert_primes_without_transaction(const std::vector<int>& primes) {
        auto start_time = std::chrono::high_resolution_clock::now();
        
        char* err_msg = nullptr;
        int rc = SQLITE_OK;
        int success_count = 0;
        
        // 准备插入语句
        sqlite3_stmt* stmt;
        const char* sql = "INSERT INTO primes (prime_number) VALUES (?);";
        
        rc = sqlite3_prepare_v2(db, sql, -1, &stmt, nullptr);
        if (rc != SQLITE_OK) {
            std::cerr << "准备语句失败: " << sqlite3_errmsg(db) << std::endl;
            return false;
        }
        
        for (size_t i = 0; i < primes.size(); ++i) {
            sqlite3_bind_int(stmt, 1, primes[i]);
            
            rc = sqlite3_step(stmt);
            if (rc == SQLITE_DONE) {
                success_count++;
            } else {
                // 忽略重复键错误等
            }
            
            sqlite3_reset(stmt);
        }
        
        sqlite3_finalize(stmt);
        
        auto end_time = std::chrono::high_resolution_clock::now();
        auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(end_time - start_time);
        
        std::cout << "无事务插入: " << success_count << " 个质数，耗时: " 
                  << duration.count() << " 毫秒" << std::endl;
        
        return true;
    }
    
    // 使用事务插入
    bool insert_primes_with_transaction(const std::vector<int>& primes) {
        auto start_time = std::chrono::high_resolution_clock::now();
        
        char* err_msg = nullptr;
        int rc = SQLITE_OK;
        int success_count = 0;
        
        // 开始事务
        rc = sqlite3_exec(db, "BEGIN TRANSACTION;", nullptr, nullptr, &err_msg);
        if (rc != SQLITE_OK) {
            std::cerr << "开始事务失败: " << err_msg << std::endl;
            sqlite3_free(err_msg);
            return false;
        }
        
        // 准备插入语句
        sqlite3_stmt* stmt;
        const char* sql = "INSERT INTO primes (prime_number) VALUES (?);";
        
        rc = sqlite3_prepare_v2(db, sql, -1, &stmt, nullptr);
        if (rc != SQLITE_OK) {
            std::cerr << "准备语句失败: " << sqlite3_errmsg(db) << std::endl;
            sqlite3_exec(db, "ROLLBACK;", nullptr, nullptr, nullptr);
            return false;
        }
        
        for (size_t i = 0; i < primes.size(); ++i) {
            sqlite3_bind_int(stmt, 1, primes[i]);
            
            rc = sqlite3_step(stmt);
            if (rc == SQLITE_DONE) {
                success_count++;
            }
            
            sqlite3_reset(stmt);
        }
        
        sqlite3_finalize(stmt);
        
        // 提交事务
        rc = sqlite3_exec(db, "COMMIT;", nullptr, nullptr, &err_msg);
        if (rc != SQLITE_OK) {
            std::cerr << "提交事务失败: " << err_msg << std::endl;
            sqlite3_free(err_msg);
            sqlite3_exec(db, "ROLLBACK;", nullptr, nullptr, nullptr);
            return false;
        }
        
        auto end_time = std::chrono::high_resolution_clock::now();
        auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(end_time - start_time);
        
        std::cout << "有事务插入: " << success_count << " 个质数，耗时: " 
                  << duration.count() << " 毫秒" << std::endl;
        
        return true;
    }
    
    int get_prime_count() {
        sqlite3_stmt* stmt;
        const char* sql = "SELECT COUNT(*) FROM primes;";
        
        int count = 0;
        if (sqlite3_prepare_v2(db, sql, -1, &stmt, nullptr) == SQLITE_OK) {
            if (sqlite3_step(stmt) == SQLITE_ROW) {
                count = sqlite3_column_int(stmt, 0);
            }
            sqlite3_finalize(stmt);
        }
        return count;
    }
};

int main() {
    const int LIMIT = 10000000; // 1000万
    
    std::cout << "正在使用筛法查找 " << LIMIT << " 以内的质数..." << std::endl;
    
    auto sieve_start = std::chrono::high_resolution_clock::now();
    PrimeSieve sieve(LIMIT);
    std::vector<int> primes = sieve.find_primes();
    auto sieve_end = std::chrono::high_resolution_clock::now();
    auto sieve_duration = std::chrono::duration_cast<std::chrono::milliseconds>(sieve_end - sieve_start);
    
    std::cout << "找到 " << primes.size() << " 个质数，筛法耗时: " 
              << sieve_duration.count() << " 毫秒" << std::endl;
    
    // 测试不带事务的插入
    std::cout << "\n=== 测试不带事务的插入 ===" << std::endl;
    {
        DatabaseManager db_mgr;
        if (db_mgr.open_database("primes_no_transaction.db")) {
            if (db_mgr.create_table()) {
                db_mgr.insert_primes_without_transaction(primes);
                std::cout << "数据库中实际存储的质数数量: " << db_mgr.get_prime_count() << std::endl;
            }
            db_mgr.close_database();
        }
    }
    
    // 测试带事务的插入
    std::cout << "\n=== 测试带事务的插入 ===" << std::endl;
    {
        DatabaseManager db_mgr;
        if (db_mgr.open_database("primes_with_transaction.db")) {
            if (db_mgr.create_table()) {
                db_mgr.insert_primes_with_transaction(primes);
                std::cout << "数据库中实际存储的质数数量: " << db_mgr.get_prime_count() << std::endl;
            }
            db_mgr.close_database();
        }
    }
    
    return 0;
}

结果:最终两个.db都是16,940 KB，但是执行插入的耗时大不相同。

正在使用筛法查找 10000000 以内的质数…
找到 664579 个质数，筛法耗时: 6609 毫秒
.
=== 测试不带事务的插入 ===
无事务插入: 664579 个质数，耗时: 2970537 毫秒
数据库中实际存储的质数数量: 664579
.
=== 测试带事务的插入 ===
有事务插入: 664579 个质数，耗时: 6837 毫秒
数据库中实际存储的质数数量: 664579

6极地诈唬
关注
Android入门第54天-SQLite中的Transaction
打造全国最全的AI Agent开发知识领域的博客
12-23 1271
在今天的课程中我们要使用SQLite中的表事务操作来熟悉正确提交事务以及没有正确提交事务时结果的不同。
对比sqlite3_exec 和sqlite3_bind 插入100万行数据的速度 with BEGIN TRANSACTION using C++ and SQLite
zongshiwujie
03-26 6281
使用sqlite3_exec 插入100万行数据需要 27 s，而使用sqlite3_bind_double 插入100万行数据只需要3.7 s。 主要是因为采用sqlite3_exec()，相当于每插入一行数据同时用到sqlite3_prepare_v2(), sqlite3_step() 和 sqlite3_finalize()，另外需要把double 强制转换成 string 然后再转换成
SQLite语法 COMMIT TRANSACTION
robin622的专栏
03-04 5221
SQLite的SQL语法[目录]BEGIN TRANSACTION sql-statement ::= BEGIN [ DEFERRED | IMMEDIATE | EXCLUSIVE ] [TRANSACTION [name]]
Android开发中的SQLite事务处理，即beginTransaction()方法
koozework的博客
05-07 8330
使用SQLiteDatabase的beginTransaction()方法可以开启一个事务，程序执行到endTransaction() 方法时会检查事务的标志是否为成功，如果程序执行到endTransaction()之前调用了setTransactionSuccessful() 方法设置事务的标志为成功则提交事务，如果没有调用setTransactionSuccessful() 方法则回滚事务
sqlite3提升执行速度——事务操作
afootball的博客
08-26 3476
数据库在执行多条操作时就会显得速度很慢，为了提升速度可以使用数据库的事务操作来提升速度 一、事务介绍 事务（Transaction）是一个对数据库执行工作单元。事务（Transaction）是以逻辑顺序完成的工作单位或序列，可以是由用户手动操作完成，也可以是由某种数据库程序自动完成。 例如：在一张表中插入一条数据，删除数据，修改数据，查找数据，都是在执行事务。实际上可以把一些相同操作的事务归并在一起，最后一起提交就可以变成一个事务，大大提高了数据库执行的效率。 1.事务操作分类 1."begin tr
SQLite剖析之事务处理技术
aohun0743的博客
08-29 382
前言 　　事务处理是DBMS中最关键的技术，对SQLite也一样，它涉及到并发控制，以及故障恢复等等。在数据库中使用事务可以保证数据的统一和完整性，同时也可以提高效率。假设需要在一张表内一次插入20个人的名字才算是操作成功，那么在不使用事务的情况下，如果插入过程中出现异常或者在插入过程中出现一些其他数据库操作的话，就很有可能影响了操作的完整性。所以事务可以很好地解决这样的情况，首先事务...
『SQLite』事务这么用
一立方星空
01-07 983
SQLite 事务是指一组 SQL 语句的集合，这些语句作为一个单独的工作单元执行，以确保数据的完整性和一致性。事务（Transaction）是以逻辑顺序完成的工作单位或序列，可以是由用户手动操作完成，也可以是由某种数据库程序自动完成。事务（Transaction）是指一个或多个更改数据库的扩展。
SQLite 事务（Transaction）
12-16
SQLite 事务（Transaction） 事务（Transaction）是一个对数据库执行工作单元。事务（Transaction）是以逻辑顺序完成的工作单位或序列，可以是由用户手动操作完成，也可以是由某种数据库程序自动完成。 事务...
Android Studio实现送餐管理系统，优秀课程设计，SQLite数据库，入门必看！
05-21
Android Studio实现送餐管理系统，优秀课程设计，SQLite数据库，入门必看！ Android Studio实现送餐管理系统，优秀课程设计，SQLite数据库，入门必看！ Android Studio实现送餐管理系统，优秀课程设计，SQLite数据库...
从零开始学习 Python 3 - 数据库交互 2：解锁更多 SQLite 操作，玩转数据库！
05-26
还记得上节课我们学习了如何用 Python 操作 SQLite 数据库吗？ 这次，我们将继续深入探索，解锁更多实用操作，让你像数据库大师一样游刃有余！
csv-to-sqlite：一个将CSV文件转换为SQLite数据库的桌面应用程序！
02-04
一个将CSV文件转换为SQLite数据库的桌面应用程序！ 目录 目的 CSV到SQLite是一种电子应用程序，旨在将以逗号分隔的值文件转换为具有SQLite数据库。 与命令行CSV到SQLite的转换方法相比，此桌面应用程序允许用户更快...
SQLite数据库--事务创建,提交及异常回滚
Blue
06-09 3112
下面代码中，`connection` 是一个 SQLite 数据库连接对象，`BeginTransaction()` 方法用于开启一个新的事务，并返回一个 `SQLiteTransaction` 对象，该对象可以用于提交或回滚事务。在事务执行完成后，需要调用 `Commit()` 方法提交事务，或者调用 `Rollback()` 方法回滚事务。总之，事务的目的是为了保证数据的一致性和完整性，而 COMMIT 命令则是将事务中的修改写入磁盘，以保证数据的持久性。// 出现异常，回滚事务。
深入Android SQLite 事务处理详解
sunny_lv的专栏
05-11 5133
 应用程序初始化时需要批量的向sqlite中插入大量数据，单独的使用for+Insert方法导致应用响应缓慢,因为 sqlite插入数据的时候默认一条语句就是一个事务，有多少条数据就有多少次磁盘操作。我的应用初始5000条记录也就是要5000次读写磁盘操作。 而且不能保证所有数据都能同时插入。（有可能部分插入成功，另外一部分失败，后续还得删除。太麻烦） 解决方法： 添加事务处理，把50
sQLite问题:Error cannot start a transaction within a transaction
热门推荐
petershina的专栏
08-27 1万+
SQLite3事务模式问题？ 我用SQLite3在同一个数据库里面同时操作三个表单table，使用事务模式插入数据，提示2个错误“Error cannot start a transaction within a transaction”。当我只操作一个table的时候，没有报错，请问这是怎么回事，改怎么解决，非常感谢！ ------解决方案-------------------
Android开发中的SQLite事务处理，即beginTransaction()方法...
Darry_R的博客
12-20 3829
以下是Android API的官方注解 beginTransaction Added in API level 1 void beginTransaction () Begins a transaction in EXCLUSIVE mode. Transactions can be nested. When the outer transaction is ende
SQLite BEGIN TRANSACTION创建提交事务 http://www.uedsc.com/sqlite-begin-transaction.html
ssyyjj88的专栏
03-30 1123
http://www.uedsc.com/sqlite-begin-transaction.html 除非在一个事务中，否则是不能对数据库进行更改的。 如果当前不在事务中， 任何改变数据库的命令（基本上，任何除SELECT之外的 SQL 语句）都会自动开始一个事务。 自动开始的事务在命令执行完成后会自动提交。 sql-statement ::= BEGIN
SQLite 事务一致性处理 beginTransaction
Winters_huang'Blog
09-26 3435
SQLite 事务一致性处理 beginTransaction 一系列保存数据库操作，如果期间抛出异常，可用 beginTransaction，setTransactionSuccessful，endTransaction 保证事务一致性。 public void beginTransaction () Since: API Level 1 Begins a tran
sqlite BeginTransaction 对象的当前状态使该操作无效
最新发布
09-18
首先，用户的问题是关于解决SQLite中“BeginTransaction对象当前状态使操作无效”的问题。他们提供了几个引用信息，我需要参考这些来给出解决方案。 用户引用的内容： - [^1]: 描述了beginTransaction()的使用方法...
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值