SQLite 的 C 语言接口规范

此页面旨在提供精确而详细的规范。有关教程介绍，请参阅：

• SQLite 在 3 分钟或更短时间内和/或
• SQLite C/C++ 接口简介 。

实验性和弃用的接口

SQLite接口可以细分为三类：

1. 稳定的
2. 实验性的
3. 弃用

稳定的接口将以向后兼容的方式无限期维护。仅使用稳定接口的应用程序应该始终能够重新链接到更新版本的 SQLite，而无需进行任何更改。

实验界面可能会发生变化。使用实验性接口的应用程序在升级到较新的 SQLite 版本时可能需要进行修改，尽管这种情况很少见。当新接口添加到 SQLite 时，它​​们通常以实验接口开始。当一个接口使用了一段时间后，开发人员确信接口的设计是合理的，值得长期支持，这个接口就被标记为稳定的。

已弃用的接口已被更好的方法所取代，可以完成相同的事情，在新的应用程序中应该避免使用。为了向后兼容，继续支持已弃用的接口。在将来的某个时候，可能会删除已弃用的接口。

关键点：

• 实验界面随时可能更改和/或删除。
• 不推荐使用的接口不应在新代码中使用，并且可能会在未来的某个版本中删除。

对象列表：

常量列表：

也可用：错误代码列表

功能列表：

注意：标有“ (exp) ”的函数是实验性的，名称中带有 删除线的函数已弃用。

虚拟表扫描标志

#define SQLITE_INDEX_SCAN_UNIQUE      1     /* Scan visits at most 1 row */

允许虚拟表实现将 sqlite3_index_info .idxFlags 字段设置为这些位的某种组合。

sqlite3_serialize 的标志

#define SQLITE_SERIALIZE_NOCOPY 0x001   /* Do no memory allocations */

对于sqlite3_serialize(D,S,P,F) 的 F 参数，可以对以下零个或多个常量进行“或”运算。

SQLITE_SERIALIZE_NOCOPY 意味着sqlite3_serialize()将返回一个指向它当前正在使用的连续内存数据库的指针，而不制作数据库的副本。如果 SQLite 当前未使用连续的内存数据库，则此选项会导致 sqlite3_serialize()返回 NULL 指针。如果 SQLite 已通过先前调用sqlite3_deserialize()进行了初始化，则它只会使用连续的内存数据库。

最大 xShmLock 索引

#define SQLITE_SHM_NLOCK        8

sqlite3_io_methods 上的 xShmLock 方法可以使用 0 和此上限之间的值作为其“偏移量”参数。SQLite 核心永远不会尝试获取或释放此范围之外的锁

可加载扩展 Thunk

typedef struct sqlite3_api_routines sqlite3_api_routines;

指向不透明 sqlite3_api_routines 结构的指针作为第三个参数传递给可加载扩展的入口点。必须对该结构进行类型定义，以解决某些平台上的编译器警告。

在线备份对象

typedef struct sqlite3_backup sqlite3_backup;

sqlite3_backup 对象记录有关正在进行的在线备份操作的状态信息。sqlite3_backup 对象通过调用 sqlite3_backup_init() 创建，并通过调用sqlite3_backup_finish ()销毁 。

另请参阅：使用 SQLite 在线备份 API

SQL 函数上下文对象

typedef struct sqlite3_context sqlite3_context;

SQL 函数执行的上下文存储在 sqlite3_context 对象中。指向 sqlite3_context 对象的指针始终是应用程序定义的 SQL 函数的第一个参数。应用程序定义的 SQL 函数实现会将此指针传递给对sqlite3_result()、 sqlite3_aggregate_context()、sqlite3_user_data()、 sqlite3_context_db_handle()、sqlite3_get_auxdata()和/或sqlite3_set_auxdata()的调用。

26种方法：

保存数据库文件的文件夹的名称

SQLITE_EXTERN char *sqlite3_data_directory;

如果这个全局变量指向一个字符串，它是一个文件夹（又名目录）的名称，那么所有使用相对路径名指定并在使用内置 Windows VFS时由 SQLite 创建或访问的数据库文件将被假定为相对于该目录。如果此变量是 NULL 指针，则 SQLite 假定所有使用相对路径名指定的数据库文件都相对于进程的当前目录。只有 Windows VFS 使用这个全局变量；它被 unix VFS 忽略。

在数据库连接打开时更改此变量的值可能会导致数据库损坏。

一次在多个线程中读取或修改此变量是不安全的。如果在单独的线程中同时使用数据库连接，则读取或修改此变量是不安全的。旨在将此变量设置为进程初始化的一部分，并在调用任何 SQLite 接口例程之前设置一次，此后此变量保持不变。

data_store_directory pragma可能会修改此变量并使其指向从sqlite3_malloc获得的内存。此外，data_store_directory pragma始终假定此变量指向的任何字符串都保存在从 sqlite3_malloc获得的内存中，并且 pragma 可能会尝试使用sqlite3_free释放该内存。因此，如果直接修改此变量，则应将其设置为 NULL 或指向从sqlite3_malloc获得的内存， 否则应避免 使用data_store_directory pragma 。

操作系统接口打开文件句柄

typedef struct sqlite3_file sqlite3_file;
struct sqlite3_file {
  const struct sqlite3_io_methods *pMethods;  /* Methods for an open file */
};

sqlite3_file对象表示 操作系统接口层中打开 的文件。各个 OS 接口实现将希望通过附加其他字段来子类化该对象以供自己使用。pMethods 条目是一个指向 sqlite3_io_methods对象的指针，该对象定义了对打开的文件执行 I/O 操作的方法。

虚拟表索引信息

struct sqlite3_index_info {
  /* Inputs */
  int nConstraint;           /* Number of entries in aConstraint */
  struct sqlite3_index_constraint {
     int iColumn;              /* Column constrained.  -1 for ROWID */
     unsigned char op;         /* Constraint operator */
     unsigned char usable;     /* True if this constraint is usable */
     int iTermOffset;          /* Used internally - xBestIndex should ignore */
  } *aConstraint;            /* Table of WHERE clause constraints */
  int nOrderBy;              /* Number of terms in the ORDER BY clause */
  struct sqlite3_index_orderby {
     int iColumn;              /* Column number */
     unsigned char desc;       /* True for DESC.  False for ASC. */
  } *aOrderBy;               /* The ORDER BY clause */
  /* Outputs */
  struct sqlite3_index_constraint_usage {
    int argvIndex;           /* if >0, constraint is part of argv to xFilter */
    unsigned char omit;      /* Do not code a test for this constraint */
  } *aConstraintUsage;
  int idxNum;                /* Number used to identify the index */
  char *idxStr;              /* String, possibly obtained from sqlite3_malloc */
  int needToFreeIdxStr;      /* Free idxStr using sqlite3_free() if true */
  int orderByConsumed;       /* True if output is already ordered */
  double estimatedCost;           /* Estimated cost of using this index */
  /* Fields below are only available in SQLite 3.8.2 and later */
  sqlite3_int64 estimatedRows;    /* Estimated number of rows returned */
  /* Fields below are only available in SQLite 3.9.0 and later */
  int idxFlags;              /* Mask of SQLITE_INDEX_SCAN_* flags */
  /* Fields below are only available in SQLite 3.10.0 and later */
  sqlite3_uint64 colUsed;    /* Input: Mask of columns used by statement */
};

sqlite3_index_info 结构及其子结构用作虚拟表接口的一部分，用于将信息传递到虚拟表模块的xBestIndex 方法并从中接收回复。**Inputs** 下的字段是 xBestIndex 的输入并且是只读的。xBestIndex 将其结果插入 **Outputs** 字段。

aConstraint[] 数组记录以下形式的 WHERE 子句约束：

列 OP 表达式

其中 OP 是 =、<、<=、> 或 >=。特定运算符使用SQLITE_INDEX_CONSTRAINT_ 值之一存储在 aConstraint[].op 中 。列的索引存储在 aConstraint[].iColumn 中。aConstraint[].usable 如果可以计算右侧的 expr（因此约束可用），则为 TRUE，如果不能，则为 false。

优化器自动反转“expr OP column”形式的术语并对 WHERE 子句进行其他简化，以尝试将尽可能多的 WHERE 子句术语放入上面显示的形式中。aConstraint[] 数组仅报告与正在查询的特定虚拟表相关的 WHERE 子句术语。

有关 ORDER BY 子句的信息存储在 aOrderBy[] 中。aOrderBy 的每一项记录 ORDER BY 子句的一列。

colUsed 字段指示当前扫描可能需要虚拟表的哪些列。虚拟表列按照它们在传递给 sqlite3_declare_vtab() 的 CREATE TABLE 语句中出现的顺序从零开始编号。对于前 63 列（0-62 列），如果 SQLite 可能需要该列，则在 colUsed 掩码中设置相应的位。如果该表至少有 64 列，并且需要前 63 列右侧的任何列，则还会设置 colUsed 的第 63 位。换句话说，如果表达式 (colUsed & ((sqlite3_uint64)1 << (iCol>=63 ? 63 : iCol))) 计算结果为非零，则可能需要列 iCol。

xBestIndex方法必须使用有关要传递给 xFilter 的参数的信息填充 aConstraintUsage[]。如果 argvIndex>0，则评估相应 aConstraint[] 的右侧并成为 argv 中的第 argvIndex 项。如果 aConstraintUsage[].omit 为 true，则假定约束完全由虚拟表处理，字节代码可能不会再次检查。aConstraintUsage[].omit 标志是一个优化提示。当 omit 标志保留其默认设置 false 时，将始终在字节代码中单独检查约束。如果 omit 标志更改为 true，则可能会或可能不会在字节代码中检查约束。换句话说，当 omit 标志为真时，不能保证不会使用字节代码再次检查约束。

idxNum 和 idxPtr 值被记录并传递给 xFilter方法。 当且仅当 needToFreeIdxPtr 为真时， sqlite3_free()用于释放 idxPtr。

orderByConsumed 意味着xFilter / xNext的输出将以正确的顺序出现以满足 ORDER BY 子句，因此不需要单独的排序步骤。

estimatedCost 值是对特定策略成本的估计。成本 N 表示该策略的成本类似于具有 N 行的 SQLite 表的线性扫描。log(N) 的成本表示该操作的开销类似于对具有 N 行的 SQLite 表的唯一索引字段进行二进制搜索的开销。

estimatedRows 值是策略将返回的行数的估计值。

xBestIndex 方法可以选择使用 SQLITE_INDEX_SCAN_* 标志的掩码填充 idxFlags 字段。目前只有一个这样的标志——SQLITE_INDEX_SCAN_UNIQUE。如果 xBestIndex 方法设置了这个标志，SQLite 假定该策略最多可以访问一行。

此外，如果 xBestIndex 设置了 SQLITE_INDEX_SCAN_UNIQUE 标志，则 SQLite 还假设如果调用 xUpdate() 方法作为删除或更新虚拟表行的同一语句的一部分并且实现返回 SQLITE_CONSTRAINT，则不需要回滚任何数据库更改。换句话说，如果 xUpdate() 返回 SQLITE_CONSTRAINT，则数据库内容必须与调用 xUpdate 之前完全相同。相反，如果未设置 SQLITE_INDEX_SCAN_UNIQUE 并且 xUpdate 返回 SQLITE_CONSTRAINT，则 xUpdate 方法所做的任何数据库更改都会由 SQLite 自动回滚。

重要提示：已将 estimatedRows 字段添加到 SQLite版本 3.8.2 (2013-12-06)的 sqlite3_index_info 结构中。如果虚拟表扩展与 3.8.2 之前的 SQLite 版本一起使用，则尝试读取或写入 estimatedRows 字段的结果是未定义的（但可能包括使应用程序崩溃）。因此，只有当sqlite3_libversion_number()返回的值大于或等于 3008002 时，才应使用 estimatedRows 字段。同样，idxFlags 字段是为版本 3.9.0 (2015-10-14) 添加的。因此，它只能在 sqlite3_libversion_number() 返回大于或等于 3009000 的值时使用。

3 个方法： sqlite3_vtab_collat​​ion()、 sqlite3_vtab_distinct()、 sqlite3_vtab_rhs_value()

操作系统接口文件虚拟方法对象

typedef struct sqlite3_io_methods sqlite3_io_methods;
struct sqlite3_io_methods {
  int iVersion;
  int (*xClose)(sqlite3_file*);
  int (*xRead)(sqlite3_file*, void*, int iAmt, sqlite3_int64 iOfst);
  int (*xWrite)(sqlite3_file*, const void*, int iAmt, sqlite3_int64 iOfst);
  int (*xTruncate)(sqlite3_file*, sqlite3_int64 size);
  int (*xSync)(sqlite3_file*, int flags);
  int (*xFileSize)(sqlite3_file*, sqlite3_int64 *pSize);
  int (*xLock)(sqlite3_file*, int);
  int (*xUnlock)(sqlite3_file*, int);
  int (*xCheckReservedLock)(sqlite3_file*, int *pResOut);
  int (*xFileControl)(sqlite3_file*, int op, void *pArg);
  int (*xSectorSize)(sqlite3_file*);
  int (*xDeviceCharacteristics)(sqlite3_file*);
  /* Methods above are valid for version 1 */
  int (*xShmMap)(sqlite3_file*, int iPg, int pgsz, int, void volatile**);
  int (*xShmLock)(sqlite3_file*, int offset, int n, int flags);
  void (*xShmBarrier)(sqlite3_file*);
  int (*xShmUnmap)(sqlite3_file*, int deleteFlag);
  /* Methods above are valid for version 2 */
  int (*xFetch)(sqlite3_file*, sqlite3_int64 iOfst, int iAmt, void **pp);
  int (*xUnfetch)(sqlite3_file*, sqlite3_int64 iOfst, void *p);
  /* Methods above are valid for version 3 */
  /* Additional methods may be added in future releases */
};

sqlite3_vfs.xOpen方法 打开的每个文件都会填充一个 sqlite3_file对象（或者，更常见的是， sqlite3_file对象的子类），并带有指向该对象实例的指针。该对象定义了用于对sqlite3_file对象表示的打开文件执行各种操作的方法。

如果sqlite3_vfs.xOpen方法将 sqlite3_file.pMethods 元素设置为非 NULL 指针，则即使sqlite3_vfs.xOpen报告失败，也可以调用 sqlite3_io_methods.xClose 方法。阻止在sqlite3_vfs.xOpen失败后调用 xClose 的唯一方法 是让sqlite3_vfs.xOpen将 sqlite3_file.pMethods 元素设置为 NULL。

xSync 的标志参数可以是SQLITE_SYNC_NORMAL或 SQLITE_SYNC_FULL 之一。第一个选择是普通的 fsync()。第二个选择是 Mac OS X 风格的全同步。SQLITE_SYNC_DATAONLY标志可以进行ORed ，以指示只需要同步文件的数据而不是其 inode。

xLock() 和 xUnlock() 的整数值是其中之一

• SQLITE_LOCK_NONE,
• SQLITE_LOCK_SHARED,
• SQLITE_LOCK_RESERVED,
• SQLITE_LOCK_PENDING, or
• SQLITE_LOCK_EXCLUSIVE.

xFileControl() 方法是一个通用接口，允许自定义 VFS 实现使用 sqlite3_file_control()接口直接控制打开的文件。第二个“op”参数是一个整数操作码。第三个参数是一个通用指针，旨在指向一个结构，该结构可能包含参数或用于写入返回值的空间。xFileControl() 的潜在用途可能是启用超时阻塞锁、更改锁定策略（例如使用点文件锁）、查询锁的状态或打破陈旧锁的功能。SQLite 核心保留所有小于 100 的操作码供自己使用。操作码列表少于 100 个可用。定义自定义 xFileControl 方法的应用程序应使用大于 100 的操作码以避免冲突。VFS 实现应该为它们不识别的文件控制操作码返回SQLITE_NOTFOUND 。

xSectorSize() 方法返回作为文件基础的设备的扇区大小。扇区大小是在不影响文件中其他字节的情况下可以执行的最小写入。xDeviceCharacteristics() 方法返回一个描述底层设备行为的位向量：

• SQLITE_IOCAP_ATOMIC
• SQLITE_IOCAP_ATOMIC512
• SQLITE_IOCAP_ATOMIC1K
• SQLITE_IOCAP_ATOMIC2K
• SQLITE_IOCAP_ATOMIC4K
• SQLITE_IOCAP_ATOMIC8K
• SQLITE_IOCAP_ATOMIC16K
• SQLITE_IOCAP_ATOMIC32K
• SQLITE_IOCAP_ATOMIC64K
• SQLITE_IOCAP_SAFE_APPEND
• SQLITE_IOCAP_SEQUENTIAL
• SQLITE_IOCAP_UNDELETABLE_WHEN_OPEN
• SQLITE_IOCAP_POWERSAFE_OVERWRITE
• SQLITE_IOCAP_IMMUTABLE
• SQLITE_IOCAP_BATCH_ATOMIC

SQLITE_IOCAP_ATOMIC 属性意味着任何大小的所有写入都是原子的。SQLITE_IOCAP_ATOMICnnn 值意味着写入大小为 nnn 字节且与 nnn 的整数倍地址对齐的块是原子的。SQLITE_IOCAP_SAFE_APPEND 值意味着当数据附加到文件时，首先附加数据，然后扩展文件的大小，而不是相反。SQLITE_IOCAP_SEQUENTIAL 属性意味着信息写入磁盘的顺序与调用 xWrite() 的顺序相同。

如果 xRead() 返回 SQLITE_IOERR_SHORT_READ，它还必须用零填充缓冲区的未读部分。无法对短读取进行零填充的 VFS 似乎可以工作。但是，未能对短读取进行零填充最终会导致数据库损坏。

内存分配例程

typedef struct sqlite3_mem_methods sqlite3_mem_methods;
struct sqlite3_mem_methods {
  void *(*xMalloc)(int);         /* Memory allocation function */
  void (*xFree)(void*);          /* Free a prior allocation */
  void *(*xRealloc)(void*,int);  /* Resize an allocation */
  int (*xSize)(void*);           /* Return the size of an allocation */
  int (*xRoundup)(int);          /* Round up request size to allocation size */
  int (*xInit)(void*);           /* Initialize the memory allocator */
  void (*xShutdown)(void*);      /* Deinitialize the memory allocator */
  void *pAppData;                /* Argument to xInit() and xShutdown() */
};

该对象的实例定义了 SQLite 和低级内存分配例程之间的接口。

该对象仅在 SQLite 界面中的一个地方使用。当配置选项为 SQLITE_CONFIG_MALLOC或SQLITE_CONFIG_GETMALLOC时，指向该对象实例的指针是 sqlite3_config()的参数。通过创建该对象的一个​​实例并在配置期间将其传递给sqlite3_config ( SQLITE_CONFIG_MALLOC )，应用程序可以为 SQLite 指定一个替代内存分配子系统以用于其所有动态内存需求。

请注意，SQLite 带有几个内置的内存分配器 ，这些内存分配器完全适合绝大多数应用程序，并且该对象仅对极少数具有专门内存分配要求的应用程序有用。在测试 SQLite 期间也使用此对象，以指定模拟内存耗尽情况的替代内存分配器，以验证 SQLite 是否从此类情况中正常恢复。

xMalloc、xRealloc 和 xFree 方法必须像标准 C 库中的 malloc()、realloc() 和 free() 函数一样工作。SQLite 保证 xRealloc 的第二个参数始终是先前调用 xRoundup 返回的值。

xSize 应返回先前从 xMalloc 或 xRealloc 获得的内存分配的分配大小。分配的大小始终至少与请求的大小一样大，但也可能更大。

xRoundup 方法返回给定特定请求大小的内存分配的分配大小。大多数内存分配器将内存分配至少舍入到 8 的下一个倍数。一些分配器舍入到更大的倍数或 2 的幂。通过sqlite3_malloc() 或sqlite3_realloc()进入的每个内存分配请求首先调用 xRoundup。如果 xRoundup 返回 0，则会导致相应的内存分配失败。

xInit 方法初始化内存分配器。例如，它可能会分配任何所需的互斥体或初始化内部数据结构。xShutdown 方法由 sqlite3_shutdown()调用（间接）并且应该释放 xInit 获取的任何资源。pAppData 指针用作 xInit 和 xShutdown 的唯一参数。

SQLite 在调用 xInit 方法时持有SQLITE_MUTEX_STATIC_MAIN互斥量，因此 xInit 方法不需要是线程安全的。xShutdown 方法仅从sqlite3_shutdown()调用，因此它也不需要是线程安全的。对于所有其他方法，只要 打开SQLITE_CONFIG_MEMSTATUS配置选项（默认情况下），SQLite 就会持有SQLITE_MUTEX_STATIC_MEM互斥体，因此这些方法会自动序列化。但是，如果SQLITE_CONFIG_MEMSTATUS被禁用，那么其他方法必须是线程安全的，否则会自行安排序列化。

如果没有对 xShutdown() 的干预调用，SQLite 将永远不会多次调用 xInit()。

互斥句柄

typedef struct sqlite3_mutex sqlite3_mutex;

SQLite 中的互斥模块将sqlite3_mutex定义为互斥对象的抽象类型。SQLite 核心从不查看sqlite3_mutex的内部表示。它只处理指向sqlite3_mutex对象的指针。

互斥量是使用sqlite3_mutex_alloc()创建的。

互斥方法对象

typedef struct sqlite3_mutex_methods sqlite3_mutex_methods;
struct sqlite3_mutex_methods {
  int (*xMutexInit)(void);
  int (*xMutexEnd)(void);
  sqlite3_mutex *(*xMutexAlloc)(int);
  void (*xMutexFree)(sqlite3_mutex *);
  void (*xMutexEnter)(sqlite3_mutex *);
  int (*xMutexTry)(sqlite3_mutex *);
  void (*xMutexLeave)(sqlite3_mutex *);
  int (*xMutexHeld)(sqlite3_mutex *);
  int (*xMutexNotheld)(sqlite3_mutex *);
};

该结构的一个实例定义了用于分配和使用互斥量的低级例程。

通常，SQLite 提供的默认互斥锁实现就足够了，但是应用程序可以选择用自定义实现替换 SQLite 未提供合适实现的专用部署或系统。在这种情况下，应用程序创建并填充此结构的实例以传递给 sqlite3_config() 以及SQLITE_CONFIG_MUTEX选项。此外，在使用SQLITE_CONFIG_GETMUTEX选项查询系统当前互斥锁实现时，此结构的实例可用作输出变量。

此结构定义的 xMutexInit 方法作为系统初始化的一部分由 sqlite3_initialize() 函数调用。每次有效调用sqlite3_initialize()时，SQLite 只调用一次 xMutexInit 例程。

此结构定义的 xMutexEnd 方法作为系统关闭的一部分由 sqlite3_shutdown() 函数调用。此方法的实现预计会释放所有由互斥方法实现获得的未完成资源，尤其是那些由 xMutexInit 方法获得的资源。每次调用sqlite3_shutdown()时，xMutexEnd() 接口只被调用一次。

该结构定义的其余七个方法（xMutexAlloc、xMutexFree、xMutexEnter、xMutexTry、xMutexLeave、xMutexHeld和xMutexNotheld）实现了以下接口（分别）：

• sqlite3_mutex_alloc()
• sqlite3_mutex_free()
• sqlite3_mutex_enter()
• sqlite3_mutex_try()
• sqlite3_mutex_leave()
• sqlite3_mutex_held()
• sqlite3_mutex_notheld()

唯一的区别是上面列举的公共 sqlite3_XXX 函数默默地忽略任何传递 NULL 指针而不是有效互斥句柄的调用。此结构定义的方法的实现不需要处理这种情况。传递一个 NULL 指针而不是一个有效的互斥句柄的结果是未定义的（即，如果它被传递一个 NULL 指针，则提供一个段错误的实现是可以接受的）。

xMutexInit() 方法必须是线程安全的。在同一个进程中多次调用 xMutexInit() 并且不干预对 xMutexEnd() 的调用一定是无害的。对 xMutexInit() 的第二次和后续调用必须是空操作。

xMutexInit() 不得使用 SQLite 内存分配（sqlite3_malloc() 及其关联）。同样，xMutexAlloc() 不得将 SQLite 内存分配用于静态互斥锁。但是 xMutexAlloc() 可以使用 SQLite 内存分配来实现快速或递归互斥锁。

SQLite 将在调用sqlite3_shutdown()时调用 xMutexEnd() 方法，但前提是先前对 xMutexInit 的调用返回了 SQLITE_OK。如果 xMutexInit 以任何方式失败，它应该在返回之前自行清理。

自定义页面缓存对象

typedef struct sqlite3_pcache sqlite3_pcache;

sqlite3_pcache 类型是不透明的。它由可插拔模块实现。SQLite 核心不知道它的大小或内部结构，除了保存和传递指向对象的指针外，从不处理 sqlite3_pcache 对象。

有关其他信息，请参阅sqlite3_pcache_methods2。

自定义页面缓存对象

typedef struct sqlite3_pcache_page sqlite3_pcache_page;
struct sqlite3_pcache_page {
  void *pBuf;        /* The content of the page */
  void *pExtra;      /* Extra information associated with the page */
};

sqlite3_pcache_page 对象表示页面缓存中的单个页面。页面缓存将分配该对象的实例。页面缓存的各种方法使用指向该对象实例的指针作为参数或作为它们的返回值。

有关其他信息，请参阅sqlite3_pcache_methods2。

存放临时文件的文件夹名称

SQLITE_EXTERN char *sqlite3_temp_directory;

如果这个全局变量指向一个字符串，它是一个文件夹（又名目录）的名称，那么 SQLite 在使用内置VFS时创建的所有临时文件 都将放在该目录中。如果这个变量是一个 NULL 指针，那么 SQLite 会搜索一个合适的临时文件目录。

强烈建议不要使用此全局变量。需要在 Windows 运行时 (WinRT) 上设置一个临时文件夹。但对于所有其他平台，强烈建议应用程序既不读取也不写入此变量。这个全局变量是为了遗留应用程序的向后兼容性而存在的遗物，在新项目中应该避免使用。

一次在多个线程中读取或修改此变量是不安全的。如果在单独的线程中同时使用数据库连接，则读取或修改此变量是不安全的。旨在将此变量设置为进程初始化的一部分，并在调用任何 SQLite 接口例程之前设置一次，此后此变量保持不变。

temp_store_directory pragma可能会修改此变量并使其指向从sqlite3_malloc获得的内存。此外，temp_store_directory pragma始终假定此变量指向的任何字符串都保存在从 sqlite3_malloc获得的内存中，并且 pragma 可能会尝试使用sqlite3_free释放该内存。因此，如果直接修改此变量，则应将其设置为 NULL 或指向从sqlite3_malloc获得的内存， 否则应避免使用temp_store_directory pragma 。除非temp_store_directory pragma请求, SQLite 不会释放 sqlite3_temp_directory 指向的内存。如果应用程序想要释放该内存，它必须自己这样做，注意只有在所有数据库连接 对象都被销毁后才这样做。

Windows 运行时用户请注意： 必须在调用sqlite3_open或sqlite3_open_v2之前设置临时目录。否则，需要使用临时文件的各种功能可能会失败。以下是如何使用 C++ 和 Windows 运行时执行此操作的示例：

LPCWSTR zPath = Windows::Storage::ApplicationData::Current->
      TemporaryFolder->Path->Data();
char zPathBuf[MAX_PATH + 1];
memset(zPathBuf, 0, sizeof(zPathBuf));
WideCharToMultiByte(CP_UTF8, 0, zPath, -1, zPathBuf, sizeof(zPathBuf),
      NULL, NULL);
sqlite3_temp_directory = sqlite3_mprintf("%s", zPathBuf);

操作系统接口对象

typedef struct sqlite3_vfs sqlite3_vfs;
typedef void (*sqlite3_syscall_ptr)(void);
struct sqlite3_vfs {
  int iVersion;            /* Structure version number (currently 3) */
  int szOsFile;            /* Size of subclassed sqlite3_file */
  int mxPathname;          /* Maximum file pathname length */
  sqlite3_vfs *pNext;      /* Next registered VFS */
  const char *zName;       /* Name of this virtual file system */
  void *pAppData;          /* Pointer to application-specific data */
  int (*xOpen)(sqlite3_vfs*, const char *zName, sqlite3_file*,
               int flags, int *pOutFlags);
  int (*xDelete)(sqlite3_vfs*, const char *zName, int syncDir);
  int (*xAccess)(sqlite3_vfs*, const char *zName, int flags, int *pResOut);
  int (*xFullPathname)(sqlite3_vfs*, const char *zName, int nOut, char *zOut);
  void *(*xDlOpen)(sqlite3_vfs*, const char *zFilename);
  void (*xDlError)(sqlite3_vfs*, int nByte, char *zErrMsg);
  void (*(*xDlSym)(sqlite3_vfs*,void*, const char *zSymbol))(void);
  void (*xDlClose)(sqlite3_vfs*, void*);
  int (*xRandomness)(sqlite3_vfs*, int nByte, char *zOut);
  int (*xSleep)(sqlite3_vfs*, int microseconds);
  int (*xCurrentTime)(sqlite3_vfs*, double*);
  int (*xGetLastError)(sqlite3_vfs*, int, char *);
  /*
  ** The methods above are in version 1 of the sqlite_vfs object
  ** definition.  Those that follow are added in version 2 or later
  */
  int (*xCurrentTimeInt64)(sqlite3_vfs*, sqlite3_int64*);
  /*
  ** The methods above are in versions 1 and 2 of the sqlite_vfs object.
  ** Those below are for version 3 and greater.
  */
  int (*xSetSystemCall)(sqlite3_vfs*, const char *zName, sqlite3_syscall_ptr);
  sqlite3_syscall_ptr (*xGetSystemCall)(sqlite3_vfs*, const char *zName);
  const char *(*xNextSystemCall)(sqlite3_vfs*, const char *zName);
  /*
  ** The methods above are in versions 1 through 3 of the sqlite_vfs object.
  ** New fields may be appended in future versions.  The iVersion
  ** value will increment whenever this happens.
  */
};

sqlite3_vfs 对象的实例定义了 SQLite 核心和底层操作系统之间的接口。对象名称中的“vfs”代表“虚拟文件系统”。有关详细信息，请参阅VFS 文档。

VFS 接口有时会通过在末尾添加新方法来扩展。每次发生这样的扩展时，iVersion 字段都会递增。iVersion 值在 2007-09-04 的 SQLite版本 3.5.0中开始为 1 ，然后在 2010-07-21 的 SQLite版本 3.7.0中增加到 2，然后在 2011 年的 SQLite版本 3.7.6中增加到 3 -04-12。附加字段可能会附加到 sqlite3_vfs 对象，并且 iVersion 值可能会在 SQLite 的未来版本中再次增加。请注意，由于疏忽，sqlite3_vfs 对象的结构在 2008 年 7 月 16 日从 SQLite 3.5.9版过渡到3.6.0版时发生了变化，但 iVersion 字段没有增加。

szOsFile 字段是 此 VFS 使用的子类sqlite3_file结构的大小。mxPathname 是此 VFS 中路径名的最大长度。

已注册的 sqlite3_vfs 对象保存在由 pNext 指针形成的链表中。sqlite3_vfs_register() 和sqlite3_vfs_unregister()接口以线程安全的方式管理这个列表。sqlite3_vfs_find()接口搜索列表。应用程序代码和 VFS 实现都不应该使用 pNext 指针。

pNext 字段是 SQLite 将永远修改的 sqlite3_vfs 结构中的唯一字段。SQLite 将仅在持有特定静态互斥锁时访问或修改此字段。对象注册后，应用程序永远不应修改 sqlite3_vfs 对象中的任何内容。

zName 字段包含 VFS 模块的名称。该名称在所有 VFS 模块中必须是唯一的。

SQLite 保证 xOpen 的 zFilename 参数是 NULL 指针或从 xFullPathname() 获得的字符串，并添加了可选的后缀。如果将后缀添加到 zFilename 参数，它将由一个“-”字符后跟不超过 11 个字母数字和/或“-”字符组成。SQLite 进一步保证在调用 xClose() 之前字符串有效且不变。由于前面的句子，如果出于某种原因需要记住文件名， sqlite3_file可以安全地存储指向文件名的指针。如果 xOpen 的 zFilename 参数是 NULL 指针，则 xOpen 必须为该文件创建自己的临时名称。.

xOpen() 的标志参数包括在sqlite3_open_v2()的标志参数中设置的所有位。或者，如果使用sqlite3_open() 或sqlite3_open16()，则标志至少包括 SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE。如果 xOpen() 以只读方式打开文件，则它会将 *pOutFlags 设置为包含SQLITE_OPEN_READONLY。*pOutFlags 中的其他位可能会被设置。

SQLite 还会将以下标志之一添加到 xOpen() 调用中，具体取决于正在打开的对象：

• SQLITE_OPEN_MAIN_DB
• SQLITE_OPEN_MAIN_JOURNAL
• SQLITE_OPEN_TEMP_DB
• SQLITE_OPEN_TEMP_JOURNAL
• SQLITE_OPEN_TRANSIENT_DB
• SQLITE_OPEN_SUBJOURNAL
• SQLITE_OPEN_SUPER_JOURNAL
• SQLITE_OPEN_WAL

文件 I/O 实现可以使用对象类型标志来改变它处理文件的方式。例如，不关心崩溃恢复或回滚的应用程序可能会使打开日志文件成为空操作。写入该日志也将是空操作，任何读取该日志的尝试都将返回 SQLITE_IOERR。或者实现可能会识别出数据库文件将以随机顺序进行页面对齐的扇区读取和写入，并相应地设置其 I/O 子系统。

SQLite 还可能将以下标志之一添加到 xOpen 方法中：

• SQLITE_OPEN_DELETEONCLOSE
• SQLITE_OPEN_EXCLUSIVE

SQLITE_OPEN_DELETEONCLOSE标志意味着文件在关闭时应该被删除。SQLITE_OPEN_DELETEONCLOSE将为 TEMP 数据库及其日志、临时数据库和子日志设置。

SQLITE_OPEN_EXCLUSIVE标志总是与 SQLITE_OPEN_CREATE 标志结合使用，它们都直接类似于 POSIX open() API 的 O_EXCL 和 O_CREAT 标志。SQLITE_OPEN_EXCLUSIVE 标志与 SQLITE_OPEN_CREATE 配对时，用于指示应始终创建文件，如果文件已经存在则为错误。它不用于指示文件应该以独占访问方式打开。

SQLite 至少分配了 szOsFile 字节的内存来保存作为第三个参数传递给 xOpen的sqlite3_file结构。xOpen 方法不必分配结构；它应该只是填写它。请注意，xOpen 方法必须将 sqlite3_file.pMethods 设置为有效的sqlite3_io_methods对象或 NULL。即使打开失败，xOpen 也必须这样做。SQLite 期望 sqlite3_file.pMethods 元素在 xOpen 返回后有效，而不管 xOpen 调用成功或失败。

xAccess() 的 flags 参数可以是SQLITE_ACCESS_EXISTS 来测试文件是否存在，或者是SQLITE_ACCESS_READWRITE来测试文件是否可读和可写，或者是SQLITE_ACCESS_READ 来测试文件是否至少可读。SQLITE_ACCESS_READ 标志从未实际使用过，也没有在 SQLite 的内置 VFS 中实现。该文件由第二个参数命名，可以是一个目录。xAccess 方法在成功时返回SQLITE_OK，如果出现 I/O 错误或第二个参数中给出的文件名非法，则返回一些非零错误代码。如果返回 SQLITE_OK，则将非零或零写入 *pResOut 以指示文件是否可访问。

SQLite 将始终为输出缓冲区 xFullPathname 分配至少 mxPathname+1 个字节。输出缓冲区的确切大小也作为参数传递给这两种方法。如果输出缓冲区不够大，则应返回SQLITE_CANTOPEN 。由于 SQLite 将此作为致命错误处理，因此 vfs 实现应努力通过将 mxPathname 设置为足够大的值来防止这种情况发生。

xRandomness()、xSleep()、xCurrentTime() 和 xCurrentTimeInt64() 接口严格来说并不是文件系统的一部分，但为了完整性，它们包含在 VFS 结构中。xRandomness() 函数尝试将 nBytes 字节的高质量随机性返回到 zOut。返回值是实际得到的随机字节数。xSleep() 方法使调用线程至少休眠指定的微秒数。xCurrentTime() 方法返回当前日期和时间的 Julian Day Number 作为浮点值。xCurrentTimeInt64() 方法以整数形式返回儒略日数乘以 86400000（一天 24 小时的毫秒数）。

SQLite 核心不使用 xSetSystemCall()、xGetSystemCall() 和 xNestSystemCall() 接口。这些可选接口由一些 VFS 提供，以方便测试 VFS 代码。通过用其控制下的功能覆盖系统调用，测试程序可以模拟故障和错误条件，否则很难或不可能诱发。可以覆盖的系统调用集因一个 VFS 而异，也因同一 VFS 的一个版本而异。使用这些接口的应用程序必须为任何或所有这些接口为 NULL 或它们的行为从一个版本更改为下一个版本做好准备。如果 VFS 的 iVersion 小于 3，应用程序不得尝试访问这些方法中的任何一个。

虚拟表实例对象

struct sqlite3_vtab {
  const sqlite3_module *pModule;  /* The module for this virtual table */
  int nRef;                       /* Number of open cursors */
  char *zErrMsg;                  /* Error message from sqlite3_mprintf() */
  /* Virtual table implementations will typically add additional fields */
};

每个虚拟表模块实现都使用此对象的子类来描述虚拟表的特定实例。每个子类都将根据模块实现的特定需求进行定制。这个超类的目的是定义所有模块实现共有的某些字段。

虚拟表方法可以通过将从sqlite3_mprintf()获得的字符串分配给 zErrMsg来设置错误消息。该方法应注意 在将新字符串分配给 zErrMsg 之前调用sqlite3_free()释放任何先前的字符串。错误消息传递到客户端应用程序后，字符串将由 sqlite3_free() 自动释放，并且 zErrMsg 字段将清零。

获取聚合函数上下文

void *sqlite3_aggregate_context(sqlite3_context*, int nBytes);

聚合 SQL 函数的实现使用此例程来分配内存来存储它们的状态。

第一次为特定聚合函数调用 sqlite3_aggregate_context(C,N) 例程时，SQLite 分配 N 字节内存，将该内存清零，并返回指向新内存的指针。在为同一聚合函数实例第二次和后续调用 sqlite3_aggregate_context() 时，将返回相同的缓冲区。Sqlite3_aggregate_context() 通常在每次调用 xStep 回调时调用一次，然后在调用 xFinal 回调时调用最后一次。当没有行与聚合查询匹配时，永远不会调用聚合函数实现的 xStep() 回调，并且只调用一次 xFinal()。在这些情况下，可能会在 xFinal() 中首次调用 sqlite3_aggregate_context()。

如果 N 小于或等于零，或者发生内存分配错误，则 sqlite3_aggregate_context(C,N) 例程在首次调用时返回 NULL 指针。

sqlite3_aggregate_context(C,N) 分配的空间量由第一次成功调用时的 N 参数决定。在同一聚合函数实例中对 sqlite3_aggregate_context() 的任何后续调用中更改 N 的值将不会调整内存分配的大小。在 xFinal 回调中，通常在调用 sqlite3_aggregate_context(C,N) 时设置 N=0，这样就不会发生无意义的内存分配。

当聚合查询结束时，SQLite 自动释放由 sqlite3_aggregate_context() 分配的内存。

第一个参数必须是 SQL 函数上下文的副本，它是实现聚合函数的 xStep 或 xFinal 回调例程的第一个参数。

必须从运行聚合 SQL 函数的同一线程调用此例程。

自动加载静态链接扩展

int sqlite3_auto_extension(void(*xEntryPoint)(void));

该接口导致为每个创建的新数据库连接调用 xEntryPoint() 函数。这里的想法是 xEntryPoint() 是静态链接的SQLite 扩展的入口点， 它将自动加载到所有新的数据库连接中。

尽管函数原型显示 xEntryPoint() 不带任何参数并返回 void，SQLite 调用带有三个参数的 xEntryPoint() 并期望一个整数结果，就像入口点的签名一样，如下所示：

   int xEntryPoint(
     sqlite3 *db,
     const char **pzErrMsg,
     const struct sqlite3_api_routines *pThunk
   );

如果 xEntryPoint 例程遇到错误，它应该使 *pzErrMsg 指向适当的错误消息（从sqlite3_mprintf()获得）并返回适当的错误代码。SQLite 在调用 xEntryPoint() 之前确保 *pzErrMsg 为 NULL。SQLite 将 在 xEntryPoint() 返回后在 *pzErrMsg 上调用sqlite3_free() 。如果任何 xEntryPoint() 返回错误，则引发 xEntryPoint() 的sqlite3_open()、sqlite3_open16()或sqlite3_open_v2()调用将失败。

使用已经在自动扩展列表中的入口点 X 调用 sqlite3_auto_extension(X) 是无害的空操作。对于打开的每个数据库连接，不会多次调用入口点。

另见：sqlite3_reset_auto_extension() 和sqlite3_cancel_auto_extension()

Autovacuum 压实量回调

int sqlite3_autovacuum_pages(
  sqlite3 *db,
  unsigned int(*)(void*,const char*,unsigned int,unsigned int,unsigned int),
  void*,
  void(*)(void*)
);

sqlite3_autovacuum_pages(D,C,P,X) 接口注册了一个回调函数 C，它在数据库文件的每个自​​动清理之前被调用。向回调传递通用数据指针 (P) 的副本、正在自动清理的附加数据库的模式名称、数据库文件的页面大小、空闲页面数和每个字节数页，分别。回调应返回应由 autovacuum 删除的空闲页面数。如果回调返回零，则不会发生 autovacuum。如果返回的值大于或等于空闲页面的数量，则会发生完整的 autovacuum。

如果有多个 ATTACH-ed 数据库文件作为事务提交的一部分被修改，那么将为每个文件单独调用 autovacuum 页面回调。

回调不可重入。回调函数不应尝试调用任何其他 SQLite 接口。如果是这样，可能会发生不好的事情，包括分段错误和损坏的数据库文件。回调函数应该是一个简单的函数，它对其输入参数进行一些运算并返回结果。

sqlite3_autovacuum_pages(D,C,P,X) 的 X 参数是 P 参数的可选析构函数。如果 X 不为 NULL，则每当数据库连接关闭或回调被 sqlite3_autovacuum_pages() 的另一次调用覆盖时，都会调用 X(P)。

每个数据库连接只有一个 autovacuum 页面回调。对 sqlite3_autovacuum_pages() 接口的每次调用都会覆盖该数据库连接的所有先前调用。如果 sqlite3_autovacuum_pages(D,C,P,X) 的回调参数 (C) 是 NULL 指针，那么 autovacuum 步骤回调将被取消。sqlite3_autovacuum_pages() 的返回值通常是 SQLITE_OK，但如果出现问题，可能是其他错误代码。当前的实现只会返回 SQLITE_OK 或 SQLITE_MISUSE，但在未来的版本中可能会添加其他返回码。

如果未指定 autovacuum 页面回调（通常情况）或为回调提供 NULL 指针，则默认行为是清理所有空闲页面。所以，换句话说，默认行为就像回调函数是这样的一样：

    unsigned int demonstration_autovac_pages_callback(
      void *pClientData,
      const char *zSchema,
      unsigned int nDbPage,
      unsigned int nFreePage,
      unsigned int nBytePerPage
    ){
      return nFreePage;
    }

SQL 参数的数量

int sqlite3_bind_parameter_count(sqlite3_stmt*);

该例程可用于查找准备好的语句中SQL 参数 的数量。SQL 参数是“?”、“?NNN”、“:AAA”、“$AAA”或“@AAA”形​​式的标记，用作稍后绑定 到参数的值的占位符。

该例程实际上返回最大（最右边）参数的索引。对于除 ?NNN 之外的所有形式，这将对应于唯一参数的数量。如果使用 ?NNN 形式的参数，列表中可能会有间隙。

另请参阅：sqlite3_bind()、 sqlite3_bind_parameter_name()和 sqlite3_bind_parameter_index()。

具有给定名称的参数的索引

int sqlite3_bind_parameter_index(sqlite3_stmt*, const char *zName);

返回给定名称的 SQL 参数的索引。返回的索引值适合用作sqlite3_bind()的第二个参数。如果未找到匹配参数，则返回零。即使原始语句是使用sqlite3_prepare16_v2()或 sqlite3_prepare16_v3()从 UTF-16 文本准备的，参数名称也必须以 UTF-8 格式给出。

另请参阅：sqlite3_bind()、 sqlite3_bind_parameter_count()和 sqlite3_bind_parameter_name()。

主机参数名称

const char *sqlite3_bind_parameter_name(sqlite3_stmt*, int);

sqlite3_bind_parameter_name(P,N)接口返回预处理语句P中 第N个SQL参数的名称。形如“?NNN”或“:AAA”或“@AAA”或“$AAA”的SQL参数有一个name 分别是字符串“?NNN”或“:AAA”或“@AAA”或“$AAA”。换句话说，首字母“：”或“$”或“@”或“？” 作为名称的一部分包含在内。“？”形式的参数 没有后面的整数就没有名字，被称为“无名”或“匿名参数”。

第一个主机参数的索引为 1，而不是 0。

如果值 N 超出范围或第 N 个参数是无名的，则返回 NULL。返回的字符串始终采用 UTF-8 编码，即使命名参数最初在sqlite3_prepare16()、 sqlite3_prepare16_v2()或sqlite3_prepare16_v3()中指定为 UTF-16 。

另请参阅：sqlite3_bind()、 sqlite3_bind_parameter_count()和 sqlite3_bind_parameter_index()。

返回打开的 BLOB 的大小

int sqlite3_blob_bytes(sqlite3_blob *);

返回可通过其唯一参数中成功打开的BLOB 句柄 访问的 BLOB 的字节大小。增量 blob I/O 例程只能读取或覆盖现有的 blob 内容；他们不能改变 blob 的大小。

此例程仅适用于由先前成功调用sqlite3_blob_open()创建且未被sqlite3_blob_close()关闭的BLOB 句柄。将任何其他指针传递给此例程会导致未定义且可能不受欢迎的行为。

关闭 BLOB 句柄

int sqlite3_blob_close(sqlite3_blob *);

此函数关闭打开的BLOB 句柄。BLOB 句柄无条件关闭。即使此例程返回错误代码，句柄仍处于关闭状态。

如果正在关闭的 blob 句柄已打开以进行读写访问，并且如果数据库处于自动提交模式并且没有其他打开的读写 blob 句柄或活动的写入语句，则提交当前事务。如果在提交事务时发生错误，则返回错误代码并回滚事务。

使用不是 NULL 指针或打开的 blob 句柄的参数调用此函数会导致未定义的行为。使用空指针调用此例程（例如调用 sqlite3_blob_open()失败时返回的指针）是无害的空操作。否则，如果此函数传递了一个有效的打开的 blob 句柄，则 sqlite3_errcode() 和 sqlite3_errmsg() 函数返回的值在返回之前设置。

为增量 I/O 打开一个 BLOB

int sqlite3_blob_open(
  sqlite3*,
  const char *zDb,
  const char *zTable,
  const char *zColumn,
  sqlite3_int64 iRow,
  int flags,
  sqlite3_blob **ppBlob
);

该接口打开位于数据库 zDb 中行 iRow、列 zColumn、表 zTable 中的 BLOB的句柄；换句话说，相同的 BLOB 将由以下人员选择：

SELECT zColumn FROM zDb.zTable WHERE rowid = iRow;

参数 zDb 不是包含数据库的文件名，而是数据库的符号名称。对于附加数据库，这是出现在ATTACH语句中 AS 关键字之后的名称。对于主数据库文件，数据库名称是“main”。对于 TEMP 表，数据库名称是“temp”。

如果标志参数不为零，则打开 BLOB 以进行读写访问。如果标志参数为零，则打开 BLOB 以进行只读访问。

成功时，将返回SQLITE_OK并将新的BLOB 句柄存储在 *ppBlob 中。否则返回一个错误代码，除非错误代码是 SQLITE_MISUSE，*ppBlob 被设置为 NULL。这意味着，只要 API 未被滥用， 在该函数返回后调用 *ppBlob 上的sqlite3_blob_close()总是安全的。

如果以下任一情况为真，此函数将失败并返回 SQLITE_ERROR：

• 数据库 zDb 不存在，
• 数据库 zDb 中不存在表 zTable，
• 表 zTable 是一个 WITHOUT ROWID 表，
• 列 zColumn 不存在，
• 表中不存在行 iRow，
• iRow 行的指定列包含一个不是 TEXT 或 BLOB 值的值，
• 列 zColumn 是索引、PRIMARY KEY 或 UNIQUE 约束的一部分，并且正在打开 blob 以进行读/写访问，
• 外键约束已启用，列 zColumn 是子键定义的一部分，并且正在打开 blob 以进行读/写访问。

除非返回 SQLITE_MISUSE，否则此函数设置 数据库连接错误代码和消息，可通过 sqlite3_errcode()和sqlite3_errmsg()及相关函数访问。

sqlite3_blob_open() 引用的 BLOB 可以使用 sqlite3_blob_read()接口读取并 使用sqlite3_blob_write () 修改。可以使用sqlite3_blob_reopen() 接口将BLOB 句柄移动到同一表的不同行。但是，打开BLOB 句柄 后，不能更改BLOB 句柄的列、表或数据库。

如果 BLOB 句柄指向的行被 UPDATE、DELETE或ON CONFLICT副作用修改，则 BLOB 句柄被标记为“已过期”。如果行的任何列发生更改，即使是打开 BLOB 句柄的列以外的列，也是如此。为过期的 BLOB 句柄调用sqlite3_blob_read()和sqlite3_blob_write()失败，返回代码为SQLITE_ABORT。在 BLOB 到期之前写入 BLOB 的更改不会在 BLOB 到期时回滚。如果事务继续完成，此类更改最终将提交。

使用sqlite3_blob_bytes()接口来确定打开的 blob 的大小。此接口不能更改 blob 的大小。使用UPDATE SQL 命令更改 blob 的大小。

sqlite3_bind_zeroblob()和sqlite3_result_zeroblob()接口以及内置的zeroblob SQL函数可用于创建零填充的 blob，以使用增量 blob 接口进行读取或写入。

为了避免资源泄漏，每个打开的BLOB 句柄最终都应该通过调用sqlite3_blob_close()来释放。

另见：sqlite3_blob_close()、 sqlite3_blob_reopen()、sqlite3_blob_read()、 sqlite3_blob_bytes()、sqlite3_blob_write()。

从 BLOB 中增量读取数据

int sqlite3_blob_read(sqlite3_blob *, void *Z, int N, int iOffset);

此函数用于将数据从打开的BLOB 句柄读取到调用者提供的缓冲区中。N 个字节的数据从打开的 BLOB 复制到缓冲区 Z，从偏移量 iOffset 开始。

如果偏移量 iOffset 小于 BLOB 末尾的 N 个字节， 则返回SQLITE_ERROR并且不读取任何数据。如果 N 或 iOffset 小于零，则返回SQLITE_ERROR并且不读取任何数据。可以使用sqlite3_blob_bytes()接口确定 blob 的大小（以及 N+iOffset 的最大值）。

尝试读取过期的BLOB 句柄失败，错误代码为SQLITE_ABORT。

成功时，sqlite3_blob_read() 返回 SQLITE_OK。否则，返回错误代码或扩展错误代码。

此例程仅适用于由先前成功调用sqlite3_blob_open()创建且未被sqlite3_blob_close()关闭的BLOB 句柄。将任何其他指针传递给此例程会导致未定义且可能不受欢迎的行为。

另见：sqlite3_blob_write()。

将 BLOB 句柄移动到新行

int sqlite3_blob_reopen(sqlite3_blob *, sqlite3_int64);

此函数用于移动现有的BLOB 句柄，使其指向同一数据库表的不同行。新行由作为第二个参数传递的 rowid 值标识。只能更改行。打开 blob 句柄的数据库、表和列保持不变。将现有BLOB 句柄移动到新行比关闭现有句柄并打开新句柄更快。

新行必须满足与sqlite3_blob_open()相同的条件——它必须存在，并且必须有一个 blob 或文本值存储在指定的列中。如果表中不存在新行，或者它不包含 blob 或文本值，或者发生另一个错误，则返回 SQLite 错误代码并且 blob 句柄被视为中止。在中止的 blob 句柄上对sqlite3_blob_read()、sqlite3_blob_write()或 sqlite3_blob_reopen()的所有后续调用立即返回 SQLITE_ABORT。在中止的 blob 句柄上调用sqlite3_blob_bytes()总是返回零。

此函数设置数据库句柄错误代码和消息。

将数据增量写入 BLOB

int sqlite3_blob_write(sqlite3_blob *, const void *z, int n, int iOffset);

此函数用于将数据从调用者提供的缓冲区写入打开的BLOB 句柄。N 个字节的数据从缓冲区 Z 复制到打开的 BLOB，从偏移量 iOffset 开始。

成功时，sqlite3_blob_write() 返回 SQLITE_OK。否则， 返回错误代码或扩展错误代码。除非返回 SQLITE_MISUSE，否则此函数设置 数据库连接错误代码和消息，可通过 sqlite3_errcode()和sqlite3_errmsg()及相关函数访问。

如果作为第一个参数传递的BLOB 句柄未打开以进行写入（sqlite3_blob_open()的标志参数为零），则此函数返回SQLITE_READONLY。

该函数只能修改 BLOB 的内容；无法使用此 API 增加 BLOB 的大小。如果偏移量 iOffset 小于 BLOB 末尾的 N 个字节， 则返回SQLITE_ERROR并且不写入任何数据。BLOB 的大小（以及 N+iOffset 的最大值）可以使用sqlite3_blob_bytes()接口来确定。如果 N 或 iOffset 小于零，则返回SQLITE_ERROR并且不写入任何数据。

尝试写入过期的BLOB 句柄失败，错误代码为SQLITE_ABORT。在BLOB 句柄过期之前发生的对 BLOB 的写入不会因句柄过期而回滚，尽管这些更改当然可能已被使 BLOB 句柄过期的语句或其他独立语句覆盖。

此例程仅适用于由先前成功调用sqlite3_blob_open()创建且未被sqlite3_blob_close()关闭的BLOB 句柄。将任何其他指针传递给此例程会导致未定义且可能不受欢迎的行为。

另见：sqlite3_blob_read()。

设置忙碌超时

int sqlite3_busy_timeout(sqlite3*, int ms);

此例程设置一个繁忙的处理程序，当表被锁定时，它会休眠一段指定的时间。处理程序将睡眠多次，直到至少累积了“ms”毫秒的睡眠时间。在睡眠至少“ms”毫秒后，处理程序返回 0，这导致sqlite3_step()返回 SQLITE_BUSY。

使用小于或等于零的参数调用此例程将关闭所有繁忙的处理程序。

在任何给定时刻，特定数据库连接只能有一个繁忙的处理程序 。如果在调用此例程之前定义了另一个繁忙的处理程序（使用sqlite3_busy_handler() ），则该其他繁忙的处理程序将被清除。

另见： PRAGMA busy_timeout

取消自动扩展加载

int sqlite3_cancel_auto_extension(void(*xEntryPoint)(void));

sqlite3_cancel_auto_extension(X)接口注销使用先前调用 sqlite3_auto_extension(X ) 注册 的初始化例程X。如果初始化例程 X 成功取消注册，sqlite3_cancel_auto_extension(X) 例程返回 1，如果 X 不在初始化例程列表中，则返回 0。

重置准备好的语句上的所有绑定

int sqlite3_clear_bindings(sqlite3_stmt*);

与许多人的直觉相反，sqlite3_reset()不会重置准备好的语句上的绑定。使用此例程将所有主机参数重置为 NULL。

结果集中的列数

int sqlite3_column_count(sqlite3_stmt *pStmt);

返回准备语句 返回的结果集中的列数 。如果此例程返回 0，则意味着 准备好的语句不返回任何数据（例如UPDATE）。但是，仅仅因为此例程返回一个正数并不意味着将返回一行或多行数据。SELECT 语句将始终具有正数 sqlite3_column_count() 但取决于 WHERE 子句约束和表内容，它可能不返回任何行。

另见：sqlite3_data_count()

配置 SQLite 库

int sqlite3_config(int, ...);

sqlite3_config() 接口用于对 SQLite 进行全局配置更改，以便根据应用程序的特定需求调整 SQLite。对于大多数应用，建议使用默认配置，因此通常不需要此例程。提供它是为了支持具有特殊需求的罕见应用程序。

sqlite3_config() 接口不是线程安全的。应用程序必须确保在运行 sqlite3_config() 时没有其他 SQLite 接口被其他线程调用。

sqlite3_config() 接口只能在使用 sqlite3_initialize()进行库初始化之前或通过sqlite3_shutdown()关闭之后调用。如果在 sqlite3_initialize() 之后和sqlite3_shutdown()之前 调用sqlite3_config( ) ，那么它将返回 SQLITE_MISUSE。但是请注意，可以调用 sqlite3_config() 作为应用程序定义的sqlite3_os_init()实现的一部分。

sqlite3_config() 的第一个参数是一个整数 配置选项，用于确定要配置的 SQLite 属性。后续参数因第一个参数中的配置选项而异 。

设置配置选项后，sqlite3_config() 返回SQLITE_OK。如果该选项未知或 SQLite 无法设置该选项，则此例程返回一个非零错误代码。

函数的数据库连接

sqlite3 *sqlite3_context_db_handle(sqlite3_context*);

sqlite3_context_db_handle() 接口返回指向最初注册应用程序定义函数 的sqlite3_create_function() 和sqlite3_create_function16()例程的数据库连接（第一个参数）的 指针副本。

结果集中的列数

int sqlite3_data_count(sqlite3_stmt *pStmt);

sqlite3_data_count(P) 接口返回预处理语句P 结果集当前行中的列数。如果预处理语句 P 没有准备好返回的结果（通过调用sqlite3_column()系列接口），则 sqlite3_data_count( P) 返回 0。如果 P 是 NULL 指针，sqlite3_data_count(P) 例程也返回 0。如果先前对 sqlite3_step (P) 的调用返回SQLITE_DONE ，则 sqlite3_data_count(P) 例程返回 0 。如果之前对sqlite3_step (P) 的调用返回 了 SQLITE_ROW ，则 sqlite3_data_count(P) 将返回非零值， PRAGMA incremental_vacuum的情况除外 它总是返回零，因为该多步编译指示的每一步都返回 0 列数据。

另见：sqlite3_column_count()

一个日志对应的数据库文件

sqlite3_file *sqlite3_database_file_object(const char*);

如果 X 是传递给 sqlite3_vfs 的 xOpen 方法的回滚或 WAL 模式日志文件的名称，则 sqlite3_database_file_object(X) 返回一个指向代表主数据库文件的sqlite3_file 对象的指针。

此例程仅用于自定义VFS实现。它不是通用接口。参数 sqlite3_file_object(X) 必须是已传递到sqlite3_vfs .xOpen 方法的文件名指针，其中 xOpen 的标志参数包含 SQLITE_OPEN_MAIN_JOURNAL或SQLITE_OPEN_WAL位之一。此例程的任何其他使用都会导致未定义的和可能不受欢迎的行为。

在事务中将缓存刷新到磁盘

int sqlite3_db_cacheflush(sqlite3*);

如果在调用sqlite3_db_cacheflush(D)接口时在数据库连接D 上打开写事务，则页面缓存中当前未使用的任何脏页都将写出到磁盘。如果活动 SQL 语句创建的数据库游标正在读取脏页，或者如果它是数据库文件的第 1 页（第 1 页始终“正在使用”），则脏页可能正在使用中。sqlite3_db_cacheflush(D)接口刷新所有模式的 缓存——“main”、“temp”和任何附加的数据库。

如果此函数需要在脏页刷新到磁盘之前获得额外的数据库锁，它会这样做。如果无法立即获得这些锁，并且配置了忙处理程序回调，则会以通常的方式调用它。如果仍然无法获得所需的锁，则跳过该数据库并尝试刷新属于下一个（如果有）数据库的任何脏页。如果因为无法获得锁而跳过任何数据库，但没有发生其他错误，则此函数返回 SQLITE_BUSY。

如果在将脏页刷新到磁盘时发生任何其他错误（例如 IO 错误或内存不足情况），则处理将被放弃并立即将 SQLite错误代码返回给调用者。

否则，如果没有错误发生，sqlite3_db_cacheflush()返回 SQLITE_OK。

此函数不设置数据库句柄错误代码或由sqlite3_errcode()和sqlite3_errmsg()函数返回的消息。

配置数据库连接

int sqlite3_db_config(sqlite3*, int op, ...);

sqlite3_db_config() 接口用于对数据库连接进行配置更改。该接口类似于 sqlite3_config()，不同之处在于更改适用于单个 数据库连接（在第一个参数中指定）。

sqlite3_db_config(D,V,...) 的第二个参数是 配置动词- 一个整数代码，指示正在配置数据库连接的哪个方面。后续参数因配置动词而异。

当且仅当调用被认为成功时，调用 sqlite3_db_config() 返回 SQLITE_OK。

返回数据库连接的文件名

const char *sqlite3_db_filename(sqlite3 *db, const char *zDbName);

sqlite3_db_filename(D,N) 接口返回一个指向与连接 D 的数据库 N 关联的文件名的指针。如果数据库连接 D 上没有附加的数据库 N，或者如果数据库 N 是一个临时或内存数据库，那么这个函数将返回 NULL 指针或空字符串。

此例程返回的字符串值由数据库连接拥有和管理。该值将有效，直到数据库 N 被DETACH编辑或直到数据库连接关闭。

此函数返回的文件名是VFS的 xFullPathname 方法的输出。换句话说，文件名将是一个绝对路径名，即使最初用于打开数据库的文件名是一个 URI 或相对路径名。

如果此例程返回的文件名指针不为 NULL，则它可用作这些例程的文件名输入参数：

• sqlite3_uri_parameter()
• sqlite3_uri_boolean()
• sqlite3_uri_int64()
• sqlite3_filename_database()
• sqlite3_filename_journal()
• sqlite3_filename_wal()

查找准备好的语句的数据库句柄

sqlite3 *sqlite3_db_handle(sqlite3_stmt*);

sqlite3_db_handle 接口返回准备好的语句所属的数据库连接句柄。 sqlite3_db_handle 返回的数据库连接与最初用于创建语句的sqlite3_prepare_v2()调用（或其变体） 的第一个参数相同。

检索数据库连接的互斥锁

sqlite3_mutex *sqlite3_db_mutex(sqlite3*);

当线程模式为序列化时，该接口返回一个sqlite3_mutex对象 的指针，该对象序列化对参数中给定的数据库连接的访问​​。如果线程模式是单线程或多线程，则此例程返回 NULL 指针。

返回数据库连接的架构名称

const char *sqlite3_db_name(sqlite3 *db, int N);

sqlite3_db_name(D,N) 接口返回一个指向数据库连接 D 上第 N 个数据库的模式名称的指针，或者 N 的 NULL 指针超出范围。N 值为 0 表示主数据库文件。N 为 1 是“temp”架构。较大的 N 值对应于各种 ATTACH-ed 数据库。

存放 sqlite3_db_name() 返回的字符串的空间由 SQLite 本身管理。该字符串可能会被任何更改模式的操作释放，包括ATTACH或DETACH或调用 sqlite3_serialize()或sqlite3_deserialize()，甚至发生在不同线程上的操作。需要长期记住字符串的应用程序应该制作自己的副本。在多个线程上同时访问同一数据库连接的应用程序应该互斥保护调用此 API，并且应该在释放互斥锁之前制作自己的结果私有副本。

确定数据库是否为只读

int sqlite3_db_readonly(sqlite3 *db, const char *zDbName);

如果连接 D 的数据库 N 是只读的，则 sqlite3_db_readonly(D,N) 接口返回 1，如果是读/写则返回 0，如果 N 不是连接 D 上的数据库名称则返回 -1。

数据库连接使用的空闲内存

int sqlite3_db_release_memory(sqlite3*);

sqlite3_db_release_memory(D) 接口尝试从数据库连接 D 释放尽可能多的堆内存。与 sqlite3_release_memory()接口不同，即使省略了SQLITE_ENABLE_MEMORY_MANAGEMENT编译时选项，该接口仍然有效。

另见：sqlite3_release_memory()

数据库连接状态

int sqlite3_db_status(sqlite3*, int op, int *pCur, int *pHiwtr, int resetFlg);

此接口用于检索有关单个数据库连接的运行时状态信息。第一个参数是要查询的数据库连接对象。第二个参数是一个整数常量，取自 SQLITE_DBSTATUS options的集合，它决定了要查询的参数。SQLITE_DBSTATUS 选项集 可能会在 SQLite 的未来版本中增加。

请求参数的当前值写入*pCur，最高瞬时值写入*pHiwtr。如果 resetFlg 为真，则最高瞬时值将重置回当前值。

sqlite3_db_status() 例程在成功时返回 SQLITE_OK，在失败时返回非零错误代码。

另见：sqlite3_status()和sqlite3_stmt_status()。

声明虚拟表的架构

int sqlite3_declare_vtab(sqlite3*, const char *zSQL);

虚拟表模块 的xCreate和xConnect方法 调用此接口来声明它们实现的虚拟表的格式（列的名称和数据类型）。

反序列化数据库

int sqlite3_deserialize(
  sqlite3 *db,            /* The database connection */
  const char *zSchema,    /* Which DB to reopen with the deserialization */
  unsigned char *pData,   /* The serialized database content */
  sqlite3_int64 szDb,     /* Number bytes in the deserialization */
  sqlite3_int64 szBuf,    /* Total size of buffer pData[] */
  unsigned mFlags         /* Zero or more SQLITE_DESERIALIZE_* flags */
);

sqlite3_deserialize(D,S,P,N,M,F)接口导致 数据库连接D断开与数据库S的连接，然后根据P中包含的序列化重新打开S作为内存数据库。序列化后的数据库P为N字节大小。M 是缓冲区 P 的大小，它可能大于 N。如果 M 大于 N，并且 F 中没有设置 SQLITE_DESERIALIZE_READONLY 位，那么 SQLite 允许向内存数据库添加内容，只要总大小不超过 M 字节。

如果在 F 中设置了 SQLITE_DESERIALIZE_FREEONCLOSE 位，则当数据库连接关闭时，SQLite 将在序列化缓冲区上调用 sqlite3_free()。如果设置了 SQLITE_DESERIALIZE_RESIZEABLE 位，则如果对数据库的写入导致其增长超过 M 字节，则 SQLite 将尝试使用 sqlite3_realloc64() 增加缓冲区大小。

如果数据库当前处于读取事务或涉及备份操作，则 sqlite3_deserialize() 接口将失败并返回 SQLITE_BUSY。

无法反序列化到 TEMP 数据库中。如果 sqlite3_deserialize(D,S,P,N,M,F) 的 S 参数是“temp”，则该函数返回 SQLITE_ERROR。

如果 sqlite3_deserialize(D,S,P,N,M,F) 由于任何原因失败，并且如果在参数 F 中设置了 SQLITE_DESERIALIZE_FREEONCLOSE 位，则 在返回之前对参数 P 调用sqlite3_free() 。

如果使用SQLITE_OMIT_DESERIALIZE选项 编译 SQLite，则省略此接口 。

删除不必要的虚拟表实现

int sqlite3_drop_modules(
  sqlite3 *db,                /* Remove modules from this connection */
  const char **azKeep         /* Except, do not remove the ones named here */
);

sqlite3_drop_modules(D,L) 接口从数据库连接 D 中删除所有虚拟表模块，列表 L 中命名的除外。L 参数必须为 NULL 或指向字符串指针数组的指针，其中数组由单个 NULL 终止指针。如果 L 参数为 NULL，则删除所有虚拟表模块。

另见：sqlite3_create_module()

启用或禁用扩展加载

int sqlite3_enable_load_extension(sqlite3 *db, int onoff);

为了不在未准备好处理扩展加载的旧应用程序中打开安全漏洞，并且作为在评估用户输入的 SQL 时禁用 扩展加载的一种方法，提供了以下 API 来打开和关闭sqlite3_load_extension()机制。

扩展加载默认关闭。使用 onoff==1 调用 sqlite3_enable_load_extension() 例程以打开扩展加载并使用 onoff==0 调用它以再次关闭它。

此接口启用或禁用 C-API sqlite3_load_extension()和 SQL 函数load_extension()。使用sqlite3_db_config (db, SQLITE_DBCONFIG_ENABLE_LOAD_EXTENSION ,..) 仅启用或禁用 C-API。

安全警告：建议使用SQLITE_DBCONFIG_ENABLE_LOAD_EXTENSION方法而非此接口启用扩展加载，因此load_extension() SQL 函数保持禁用状态。这将防止 SQL 注入使攻击者能够访问扩展加载功能。

启用或禁用共享寻呼机缓存

int sqlite3_enable_shared_cache(int);

此例程启用或禁用在同一个数据库的连接 之间共享数据库缓存和模式数据结构 。如果参数为真，则启用共享；如果参数为假，则禁用共享。

为整个进程启用和禁用缓存共享。这是 SQLite版本 3.5.0 (2007-09-04) 的更改。在以前的 SQLite 版本中，每个线程分别启用或禁用共享。

此接口设置的缓存共享模式会影响对sqlite3_open()、sqlite3_open_v2()和sqlite3_open16()的所有后续调用。现有数据库连接继续使用在打开它们时有效的共享模式。

如果成功启用或禁用共享缓存，此例程返回SQLITE_OK 。否则返回错误代码。

默认情况下禁用共享缓存。建议保持这种状态。换句话说，不要使用这个例程。继续提供此接口以实现历史兼容性，但不鼓励使用它。不鼓励使用共享缓存。如果必须使用共享缓存，建议仅使用带有SQLITE_OPEN_SHAREDCACHE标志的sqlite3_open_v2()接口为单个数据库连接启用共享缓存。

注意：此方法在 MacOS X 10.7 和 iOS 5.0 版中被禁用，并且将始终返回 SQLITE_MISUSE。在这些系统上，应该通过 带有SQLITE_OPEN_SHAREDCACHE的sqlite3_open_v2()为每个数据库连接启用共享缓存模式。

此接口在写入 32 位整数是原子的处理器上是线程安全的。

另见： SQLite 共享缓存模式

一步查询执行接口

int sqlite3_exec(
  sqlite3*,                                  /* An open database */
  const char *sql,                           /* SQL to be evaluated */
  int (*callback)(void*,int,char**,char**),  /* Callback function */
  void *,                                    /* 1st argument to callback */
  char **errmsg                              /* Error msg written here */
);

sqlite3_exec() 接口是sqlite3_prepare_v2()、sqlite3_step()和sqlite3_finalize() 的便利包装器 ，它允许应用程序运行多个 SQL 语句而无需使用大量 C 代码。

sqlite3_exec() 接口在作为第一个参数传入的数据库连接的上下文中运行零个或多个 UTF-8 编码的、以分号分隔的 SQL 语句并传入其第二个参数。如果 sqlite3_exec() 的第 3 个参数的回调函数不为 NULL，那么它会为来自评估 SQL 语句的每个结果行调用。sqlite3_exec() 的第四个参数被传递到每个回调调用的第一个参数。如果指向 sqlite3_exec() 的回调指针为 NULL，则不会调用回调并且忽略结果行。

如果在评估传递给 sqlite3_exec() 的 SQL 语句时发生错误，则当前语句的执行将停止并跳过后续语句。如果 sqlite3_exec() 的第 5 个参数不是 NULL，那么任何错误消息都会写入从sqlite3_malloc()获得的内存中，并通过第 5 个参数传回。为避免内存泄漏，应用程序应 在不再需要错误消息字符串后，对通过 sqlite3_exec() 的第 5 个参数返回的错误消息字符串调用sqlite3_free() 。如果 sqlite3_exec() 的第 5 个参数不是 NULL 并且没有发生错误，则 sqlite3_exec() 在返回之前将其第 5 个参数中的指针设置为 NULL。

如果 sqlite3_exec() 回调返回非零值，则 sqlite3_exec() 例程返回 SQLITE_ABORT 而无需再次调用回调且不运行任何后续 SQL 语句。

sqlite3_exec() 回调函数的第二个参数是结果中的列数。sqlite3_exec() 回调的第三个参数是一个指向字符串的指针数组，就像从 sqlite3_column_text()中获得的一样，每列一个。如果结果行的元素为 NULL，则 sqlite3_exec() 回调的相应字符串指针为 NULL 指针。sqlite3_exec() 回调的第四个参数是指向字符串的指针数组，其中每个条目代表从sqlite3_column_name()获得的相应结果列的名称。

如果 sqlite3_exec() 的第二个参数是 NULL 指针、指向空字符串的指针或仅包含空格和/或 SQL 注释的指针，则不会评估任何 SQL 语句并且不会更改数据库。

限制：

• 应用程序必须确保 sqlite3_exec() 的第一个参数是有效且打开的数据库连接。
• 当 sqlite3_exec() 运行时 ，应用程序不得关闭由第一个参数指定的与 sqlite3_exec() 的数据库连接。
• 当 sqlite3_exec() 运行时，应用程序不得修改传递给 sqlite3_exec() 第二个参数的 SQL 语句文本。

启用或禁用扩展结果代码

int sqlite3_extended_result_codes(sqlite3*, int onoff);

sqlite3_extended_result_codes() 例程启用或禁用 SQLite 的 扩展结果代码功能。为了历史兼容性，默认情况下禁用扩展结果代码。

销毁准备好的语句对象

int sqlite3_finalize(sqlite3_stmt *pStmt);

调用 sqlite3_finalize() 函数来删除准备好的语句。如果语句的最近评估没有遇到错误，或者从未评估过语句，则 sqlite3_finalize() 返回 SQLITE_OK。如果语句 S 的最新评估失败，则 sqlite3_finalize(S) 返回适当的错误代码或 扩展错误代码。

sqlite3_finalize(S) 例程可以在准备语句S 的生命周期中的任何时候调用：在对语句 S 进行评估之前，在对sqlite3_reset()进行一次或多次调用之后，或者在对sqlite3_step()的任何调用之后，无论是否或不是语句已经执行完毕。

在 NULL 指针上调用 sqlite3_finalize() 是无害的空操作。

应用程序必须完成每个准备好的语句以避免资源泄漏。应用程序在完成后尝试使用准备好的语句是一个严重的错误。准备好的语句在完成后的任何使用都可能导致未定义和不良行为，例如段错误和堆损坏。

中断长时间运行的查询

void sqlite3_interrupt(sqlite3*);

此函数会导致任何挂起的数据库操作中止并尽早返回。此例程通常被调用以响应用户操作，例如在用户希望长时间查询操作立即停止时按下“取消”或 Ctrl-C。

从与当前运行数据库操作的线程不同的线程调用此例程是安全的。但是使用已关闭或可能在 sqlite3_interrupt() 返回之前关闭的数据库连接调用此例程是不安全的。

如果在调用 sqlite3_interrupt() 时 SQL 操作非常接近完成，那么它可能没有机会被中断，可能会继续完成。

被中断的 SQL 操作将返回SQLITE_INTERRUPT。如果中断的 SQL 操作是显式事务内的 INSERT、UPDATE 或 DELETE，则整个事务将自动回滚。

sqlite3_interrupt(D) 调用一直有效，直到数据库连接D 上所有当前运行的 SQL 语句完成。在 sqlite3_interrupt() 调用之后和运行语句计数达到零之前启动的任何新 SQL 语句都会被中断，就好像它们在 sqlite3_interrupt() 调用之前已经运行一样。在运行语句计数为零后启动的新 SQL 语句不受 sqlite3_interrupt() 的影响。在没有正在运行的 SQL 语句时发生的对 sqlite3_interrupt(D) 的调用是空操作，并且对在 sqlite3_interrupt() 调用返回后启动的 SQL 语句没有影响。

最后插入行号

sqlite3_int64 sqlite3_last_insert_rowid(sqlite3*);

大多数 SQLite 表（WITHOUT ROWID表除外）中的每个条目都有一个唯一的 64 位带符号整数键，称为“rowid”。rowid 始终可用作名为 ROWID、OID 或 _ROWID_ 的未声明列，只要这些名称未被显式声明的列也使用。如果表有一个INTEGER PRIMARY KEY类型的列，那么该列是 rowid 的另一个别名。

sqlite3_last_insert_rowid(D) 接口通常返回最近一次成功插入数据库连接 D 上的rowid表或虚拟表的 rowid 。插入WITHOUT ROWID表不被记录。如果在数据库连接 D 上没有成功插入rowid 表，则 sqlite3_last_insert_rowid(D) 返回零。

除了在将行插入数据库表时自动设置外，此函数返回的值还可以由 sqlite3_set_last_insert_rowid()显式设置

一些虚拟表实现可能将行插入 rowid 表作为提交事务的一部分（例如，将内存中累积的数据刷新到磁盘）。在这种情况下，对该函数的后续调用返回与这些内部 INSERT 操作关联的 rowid，这会导致不直观的结果。以这种方式写入 rowid 表的虚拟表实现可以通过在将控制权返回给用户之前使用sqlite3_set_last_insert_rowid()恢复原始 rowid 值来避免此问题。

如果INSERT发生在触发器中，那么只要触发器正在运行，此例程就会返回插入行的rowid 。触发器程序结束后，此例程返回的值将恢复为触发触发器之前的值。

由于违反约束而失败的INSERT不是成功的INSERT，并且不会更改此例程返回的值。因此，INSERT OR FAIL、INSERT OR IGNORE、INSERT OR ROLLBACK 和 INSERT OR ABORT 在插入失败时不会更改此例程的返回值。当 INSERT OR REPLACE 遇到约束冲突时，它不会失败。INSERT 在删除导致约束问题的行后继续完成，因此 INSERT 或 REPLACE 将始终更改此接口的返回值。

就此例程而言，INSERT被认为是成功的，即使它随后被回滚。

SQL 语句可通过 last_insert_rowid() SQL 函数访问此函数。

如果一个单独的线程在sqlite3_last_insert_rowid() 函数运行时对同一个数据库连接执行新的INSERT并因此更改最后插入的rowid，则sqlite3_last_insert_rowid()返回的值是不可预测的并且可能不等于旧的或新的 last插入行号。

运行时限制

int sqlite3_limit(sqlite3*, int id, int newVal);

该接口允许在逐个连接的基础上限制各种构造的大小。第一个参数是 要设置或查询限制的数据库连接。第二个参数是限制类别之一，用于定义要限制大小的构造类。第三个参数是该构造的新限制。

如果新限制为负数，则限制不变。对于每个限制类别 SQLITE_LIMIT_ NAME都有一个 硬上限 在编译时由一个名为 SQLITE_MAX_ NAME的 C 预处理器宏设置。（名称中的“_LIMIT_”更改为“_MAX_”。）将限制增加到其硬上限之上的尝试会被默默地截断到硬上限。

无论限制是否更改， sqlite3_limit()接口都会返回限制的先前值。因此，要在不更改限制的情况下找到限制的当前值，只需调用此接口并将第三个参数设置为 -1。

运行时限制旨在用于管理自己的内部数据库以及由不受信任的外部源控制的数据库的应用程序。一个示例应用程序可能是一个 Web 浏览器，它有自己的数据库来存储历史记录和由从 Internet 下载的 JavaScript 应用程序控制的独立数据库。可以为内部数据库提供较大的默认限制。可以为外部资源管理的数据库提供更小的限制，旨在防止拒绝服务攻击。开发人员可能还想使用sqlite3_set_authorizer() 接口来进一步控制不受信任的 SQL。可以使用 max_page_count PRAGMA包含由不受信任的脚本创建的数据库的大小。

未来的版本中可能会添加新的运行时限制类别。

加载扩展

int sqlite3_load_extension(
  sqlite3 *db,          /* Load the extension into this database connection */
  const char *zFile,    /* Name of the shared library containing extension */
  const char *zProc,    /* Entry point.  Derived from zFile if 0 */
  char **pzErrMsg       /* Put error message here if not 0 */
);

此接口从命名文件加载 SQLite 扩展库。

sqlite3_load_extension() 接口尝试加载 文件 zFile 中包含的SQLite 扩展库。如果无法直接加载文件，则会尝试加载各种操作系统特定的扩展。因此，例如，如果无法加载“samplelib”，则也可以尝试使用“samplelib.so”或“samplelib.dylib”或“samplelib.dll”之类的名称。

入口点是 zProc。zProc 可能为 0，在这种情况下，SQLite 将尝试自己提出一个入口点名称。它首先尝试“sqlite3_extension_init”。如果这不起作用，它会构造一个名称“sqlite3_X_init”，其中 X 由文件名中从最后一个“/”到第一个“.”的所有 ASCII 字母字符的小写等价物组成。并省略任何初始的“lib”。sqlite3_load_extension() 接口 在成功时返回SQLITE_OK ，如果出现问题则返回SQLITE_ERROR 。如果发生错误并且 pzErrMsg 不为 0，则 sqlite3_load_extension()接口将尝试用存储在从sqlite3_malloc()获得的内存中的错误消息文本填充 *pzErrMsg. 调用函数应通过调用sqlite3_free()释放此内存。

在调用此 API 之前，必须使用 sqlite3_enable_load_extension()或 sqlite3_db_config (db, SQLITE_DBCONFIG_ENABLE_LOAD_EXTENSION ,1,NULL) 启用扩展加载，否则将返回错误。

安全警告：建议使用 SQLITE_DBCONFIG_ENABLE_LOAD_EXTENSION方法只启用该接口。应避免使用sqlite3_enable_load_extension()接口。这将使 SQL 函数load_extension()保持 禁用状态，并防止 SQL 注入使攻击者能够访问扩展加载功能。

另请参阅load_extension() SQL 函数。

错误记录接口

void sqlite3_log(int iErrCode, const char *zFormat, ...);

sqlite3_log()接口 将消息写入由SQLITE_CONFIG_LOG选项 建立的错误日志中sqlite3_config()。如果启用日志记录，则 zFormat 字符串和后续参数与sqlite3_snprintf()一起使用以生成最终输出字符串。

sqlite3_log() 接口旨在供虚拟表、整理函数和 SQL 函数等扩展使用。虽然没有什么可以阻止应用程序调用 sqlite3_log()，但这样做被认为是错误的形式。

zFormat 字符串不能为 NULL。

为避免死锁和其他线程问题，sqlite3_log() 例程不会使用动态分配的内存。日志消息存储在堆栈上的固定长度缓冲区中。如果日志消息超过几百个字符，它将被截断为缓冲区的长度。

查找下一个准备好的语句

sqlite3_stmt *sqlite3_next_stmt(sqlite3 *pDb, sqlite3_stmt *pStmt);

该接口返回一个指针，指向与数据库连接pDb关联的 pStmt 之后的下一个准备语句。如果 pStmt 为 NULL，则此接口返回指向与数据库连接 pDb 关联的第一个准备好的语句的指针。如果没有准备好的语句满足此例程的条件，则返回 NULL。

sqlite3_next_stmt(D,S)调用中的数据库连接指针 D 必须引用打开的数据库连接，尤其不能是 NULL 指针。

为虚拟表重载函数

int sqlite3_overload_function(sqlite3*, const char *zFuncName, int nArg);

虚拟表可以使用虚拟表模块的xFindFunction方法提供函数的替代实现。但是这些函数的全局版本必须存在才能被重载。

此 API 确保存在具有特定名称和参数数量的函数的全局版本。如果在调用此 API 之前不存在此类函数，则会创建一个新函数。新函数的实现总是导致抛出异常。所以新功能本身对任何事情都没有好处。它的唯一目的是成为一个可以被虚拟表重载的占位符函数。

查询进度回调

void sqlite3_progress_handler(sqlite3*, int, int(*)(void*), void*);

sqlite3_progress_handler(D,N,X,P) 接口导致回调函数 X 在长时间运行时调用 sqlite3_exec()、sqlite3_step()和sqlite3_get_table()用于数据库连接 D。此接口的一个示例使用是在大型查询期间保持 GUI 更新。

参数 P 作为回调函数 X 的唯一参数传递。参数 N 是在回调 X 的连续调用之间评估的 虚拟机指令的近似数量。如果 N 小于 1，则禁用进度处理程序.

每个数据库连接一次只能定义一个进度处理程序 ；设置新的进度处理程序会取消旧的。将参数 X 设置为 NULL 会禁用进度处理程序。进度处理程序也可以通过将 N 设置为小于 1 的值来禁用。

如果进度回调返回非零值，则操作中断。此功能可用于在 GUI 进度对话框上实现“取消”按钮。

进度处理程序回调不得执行任何会修改调用进度处理程序的数据库连接的操作。注意，sqlite3_prepare_v2()和sqlite3_step()都针对本段“修改”的意思修改了自己的数据库连接。

伪随机数生成器

void sqlite3_randomness(int N, void *P);

SQLite 包含一个高质量的伪随机数生成器 (PRNG)，用于在将新记录插入到已使用最大可能 ROWID 的表中时选择随机ROWID。PRNG 还用于内置的 random() 和 randomblob() SQL 函数。此接口允许应用程序出于其他目的访问相同的 PRNG。

对该例程的调用将 N 个字节的随机性存储到缓冲区 P 中。P 参数可以是 NULL 指针。

如果之前未调用此例程，或者如果之前的调用中 N 小于 1 或 P 的 NULL 指针，则使用从默认sqlite3_vfs对象的 xRandomness 方法获得的随机性为 PRNG 播种。如果之前对该例程的调用具有 1 或更大的 N 和非 NULL P，则伪随机性是在内部生成的，无需求助于sqlite3_vfs xRandomness 方法。

尝试释放堆内存

int sqlite3_release_memory(int);

sqlite3_release_memory() 接口尝试通过释放数据库库持有的非必要内存分配来释放 N 字节的堆内存。用于缓存数据库页面以提高性能的内存是非必需内存的一个示例。sqlite3_release_memory() 返回实际释放的字节数，可能多于或少于请求的数量。如果 SQLite 未使用SQLITE_ENABLE_MEMORY_MANAGEMENT编译，则 sqlite3_release_memory() 例程是一个返回零的空操作。

另见：sqlite3_db_release_memory()

重置准备好的语句对象

int sqlite3_reset(sqlite3_stmt *pStmt);

调用 sqlite3_reset() 函数将准备好的语句 对象重置回其初始状态，准备重新执行。使用sqlite3_bind_*() API将值绑定到它们的任何 SQL 语句变量都会保留它们的值。使用sqlite3_clear_bindings()重置绑定。

sqlite3_reset(S)接口将准备好的语句S重置回其程序的开头。

如果最近一次为 准备好的语句S 调用sqlite3_step(S)返回SQLITE_ROW或SQLITE_DONE，或者如果以前从未在 S 上调用过 sqlite3_step(S) ，则sqlite3_reset (S)返回SQLITE_OK。

如果最近为 准备好的语句S 调用sqlite3_step(S)指示错误，则 sqlite3_reset(S)返回适当的错误代码。

sqlite3_reset(S)接口不会更改预处理语句S 上任何绑定的值。

重置自动扩展加载

void sqlite3_reset_auto_extension(void);

该接口禁用了之前使用sqlite3_auto_extension()注册的所有自动扩展。

设置 SQL 函数的子类型

void sqlite3_result_subtype(sqlite3_context*,unsigned int);

sqlite3_result_subtype(C,T) 函数导致应用程序定义的 SQL 函数的结果的子类型与 sqlite3_context C 的值为 T。在当前版本的 SQLite 中仅保留子类型 T 的低 8 位；高阶位被丢弃。在 SQLite 的未来版本中，SQLite 保留的子类型字节数可能会增加。

序列化数据库

unsigned char *sqlite3_serialize(
  sqlite3 *db,           /* The database connection */
  const char *zSchema,   /* Which DB to serialize. ex: "main", "temp", ... */
  sqlite3_int64 *piSize, /* Write size of the DB here, if not NULL */
  unsigned int mFlags    /* Zero or more SQLITE_SERIALIZE_* flags */
);

sqlite3_serialize(D,S,P,F) 接口返回一个指向内存的指针，它是数据库连接D 上 S 数据库的序列化。如果 P 不是 NULL 指针，则数据库的大小（以字节为单位）写入 * P.

对于普通的磁盘数据库文件，序列化只是磁盘文件的一个副本。对于内存数据库或“TEMP”数据库，如果该数据库备份到磁盘，序列化是将写入磁盘的相同字节序列。

通常的情况是 sqlite3_serialize() 将数据库的序列化复制到从sqlite3_malloc64()获得的内存中，并返回指向该内存的指针。调用者负责释放返回值以避免内存泄漏。但是，如果 F 参数包含 SQLITE_SERIALIZE_NOCOPY 位，则不会进行内存分配，并且 sqlite3_serialize() 函数将返回一个指向 SQLite 当前用于该数据库的数据库的连续内存表示的指针，如果没有，则返回 NULL数据库的这种连续内存表示存在。数据库的连续内存表示通常仅在之前调用过sqlite3_deserialize(D,S,...)时才会存在具有相同的 D 和 S 值。即使设置了 SQLITE_SERIALIZE_NOCOPY 位但不存在数据库的连续副本，数据库的大小也会写入 *P。

如果发生内存分配错误，即使从参数 F 中省略了 SQLITE_SERIALIZE_NOCOPY 位，对 sqlite3_serialize(D,S,P,F) 的调用也可能返回 NULL。

如果使用SQLITE_OMIT_DESERIALIZE选项 编译 SQLite，则省略此接口 。

设置上次插入 Rowid 值。

void sqlite3_set_last_insert_rowid(sqlite3*,sqlite3_int64);

sqlite3_set_last_insert_rowid(D, R) 方法允许应用程序将通过调用 sqlite3_last_insert_rowid(D) 返回的值设置为 R，而无需将行插入数据库。

暂停执行一小段时间

int sqlite3_sleep(int);

sqlite3_sleep() 函数使当前线程暂停执行至少在其参数中指定的毫秒数。

如果操作系统不支持毫秒时间分辨率的睡眠请求，则时间将四舍五入到最接近的秒。返回操作系统实际请求的睡眠毫秒数。

SQLite 通过调用默认的sqlite3_vfs对象的 xSleep() 方法来实现这个接口。如果默认 VFS 的 xSleep() 方法没有正确实现，或者根本没有实现，那么 sqlite3_sleep() 的行为可能与前面段落中的描述不同。

比较两个快照句柄的年龄。

int sqlite3_snapshot_cmp(
  sqlite3_snapshot *p1,
  sqlite3_snapshot *p2
);

sqlite3_snapshot_cmp(P1, P2) 接口用于比较两个有效快照句柄的年龄。

如果两个快照句柄不与同一个数据库文件相关联，则比较的结果是未定义的。

此外，仅当自上次删除 wal 文件后通过调用 sqlite3_snapshot_get() 获得两个快照句柄时，比较结果才有效。当数据库改回回滚模式或数据库客户端数量降为零时，wal 文件将被删除。如果在上次删除 wal 文件之前获得了任一快照句柄，则此函数返回的值是未定义的。

否则，如果 P1 引用的快照比 P2 旧，则此 API 返回负值；如果两个句柄引用同一数据库快照，则此 API 返回零；如果 P1 是比 P2 更新的快照，则返回正值。

此接口仅在使用 SQLITE_ENABLE_SNAPSHOT选项编译 SQLite 时可用。

销毁快照

void sqlite3_snapshot_free(sqlite3_snapshot*);

sqlite3_snapshot_free ( P)接口会破坏sqlite3_snapshot P。应用程序必须最终使用此例程释放每个sqlite3_snapshot对象以避免内存泄漏。

sqlite3_snapshot_free()接口仅在使用 SQLITE_ENABLE_SNAPSHOT编译时选项时可用。

记录数据库快照

int sqlite3_snapshot_get(
  sqlite3 *db,
  const char *zSchema,
  sqlite3_snapshot **ppSnapshot
);

sqlite3_snapshot_get(D,S,P)接口尝试创建一个新的sqlite3_snapshot对象， 该对象记录数据库连接 D 中模式 S 的当前状态。成功时， sqlite3_snapshot_get(D,S,P)接口将指针写入新创建的sqlite3_snapshot对象放入 *P 并返回 SQLITE_OK。如果在调用此函数时模式 S 上还没有打开的读取事务，则会自动打开一个。

要使此功能成功，必须满足以下条件。如果调用 sqlite3_snapshot_get() 时以下任何语句为假，则返回 SQLITE_ERROR。在这种情况下，*P 的最终值未定义。

• 数据库句柄不得处于自动提交模式。

• 数据库连接D的模式S必须是WAL模式的数据库。

• 数据库连接 D 的模式 S 上不能有打开的写事务。

• 自从在磁盘上创建（通过任何连接）以来，一个或多个事务必须已写入当前 wal 文件。这意味着第一次打开后不能立即对没有 wal 文件的 wal 模式数据库进行快照。必须首先向其中写入至少一个事务。

该函数也可能返回 SQLITE_NOMEM。如果在自动提交模式下使用数据库句柄调用它但由于某些其他原因而失败，则未定义是否在模式 S 上打开读取事务。

从成功调用 sqlite3_snapshot_get()返回的sqlite3_snapshot对象必须使用sqlite3_snapshot_free()释放 以避免内存泄漏。

sqlite3_snapshot_get()接口仅在使用 SQLITE_ENABLE_SNAPSHOT编译时选项时可用。

在历史快照上启动读取事务

int sqlite3_snapshot_open(
  sqlite3 *db,
  const char *zSchema,
  sqlite3_snapshot *pSnapshot
);

sqlite3_snapshot_open(D,S,P) 接口要么启动一个新的读取事务，要么升级数据库连接D的模式 S 的现有 事务，以便读取事务引用历史快照P，而不是数据库的最新更改。sqlite3_snapshot_open()接口在成功时返回 SQLITE_OK 或在失败时返回适当的错误代码。

为了成功，调用sqlite3_snapshot_open(D,S,P)时数据库连接不能处于 自动提交模式。如果模式 S 上已经有一个读取事务打开，则数据库句柄必须没有活动语句（SELECT 语句已传递给 sqlite3_step() 但不是 sqlite3_reset() 或 sqlite3_finalize()）。如果违反了这些条件中的任何一个，或者模式 S 不存在，或者快照对象无效，则返回 SQLITE_ERROR。

如果指定的快照已被检查点覆盖，则调用 sqlite3_snapshot_open() 将无法打开。在这种情况下，返回 SQLITE_ERROR_SNAPSHOT。

如果在调用此函数时已经有一个读取事务打开，那么如果返回 SQLITE_ERROR、SQLITE_BUSY 或 SQLITE_ERROR_SNAPSHOT，则相同的读取事务将保持打开状态（在同一数据库快照上）。如果返回另一个错误代码（例如 SQLITE_PROTOCOL 或 SQLITE_IOERR 错误代码），则读取事务的最终状态未定义。如果返回 SQLITE_OK，则读取事务现在在数据库快照 P 上打开。

如果数据库连接 D 不知道模式 S 的数据库文件处于WAL 模式，则对sqlite3_snapshot_open(D,S,P)的调用将失败。如果数据库连接上没有先前的 I/O，或者如果数据库 在数据库连接上最近的 I/O 之后进入WAL 模式，则数据库连接可能不知道数据库文件处于WAL 模式。（提示：针对新打开的数据库连接运行“ PRAGMA application_id ”，以使其准备好使用快照。）

sqlite3_snapshot_open()接口仅在使用 SQLITE_ENABLE_SNAPSHOT编译时选项时可用。

从 wal 文件恢复快照

int sqlite3_snapshot_recover(sqlite3 *db, const char *zDb);

如果在所有数据库连接关闭后WAL 文件仍保留在磁盘上（通过使用SQLITE_FCNTL_PERSIST_WAL 文件控制 或因为打开数据库的最后一个进程在没有调用sqlite3_close()的情况下退出）并且随后在该数据库上打开一个新连接并且WAL 文件，sqlite3_snapshot_open()接口将只能打开添加到 WAL 文件的最后一个事务，即使 WAL 文件包含其他有效事务。

此函数尝试扫描与数据库句柄 db 的数据库 zDb 关联的 WAL 文件，并使所有有效的快照对 sqlite3_snapshot_open() 可用。如果数据库上已经打开了读取事务，或者数据库不是 WAL 模式数据库，则会出错。

如果成功则返回 SQLITE_OK，否则返回 SQLite 错误代码。

此接口仅在使用 SQLITE_ENABLE_SNAPSHOT选项编译 SQLite 时可用。

弃用的软堆限制接口

void sqlite3_soft_heap_limit(int N);

这是sqlite3_soft_heap_limit64() 接口的弃用版本。提供此例程只是为了历史兼容性。所有新应用程序都应该使用 sqlite3_soft_heap_limit64()接口而不是这个接口。

评估 SQL 语句

int sqlite3_step(sqlite3_stmt*);

在使用 sqlite3_prepare_v2()、sqlite3_prepare_v3()、sqlite3_prepare16_v2()或sqlite3_prepare16_v3()或遗留接口sqlite3_prepare()或sqlite3_prepare16()之一准备好准备好的语句后，必须调用此函数一次或多次以评估声明。

sqlite3_step() 接口的行为细节取决于语句是使用较新的“vX”接口 sqlite3_prepare_v3()、sqlite3_prepare_v2()、sqlite3_prepare16_v3()、 sqlite3_prepare16_v2()还是旧的遗留接口sqlite3_prepare()和sqlite3_prepare16准备的()。建议新应用程序使用新的“vX”接口，但将继续支持旧接口。

在旧接口中，返回值将是SQLITE_BUSY、 SQLITE_DONE、SQLITE_ROW、SQLITE_ERROR或SQLITE_MISUSE。使用“v2”接口，也可以返回任何其他结果代码或 扩展结果代码。

SQLITE_BUSY意味着数据库引擎无法获取完成其工作所需的数据库锁。如果该语句是COMMIT 或发生在显式事务之外，则您可以重试该语句。如果该语句不是COMMIT并且发生在显式事务中，那么您应该在继续之前回滚该事务。

SQLITE_DONE表示语句已成功执行完毕。如果没有先调用sqlite3_reset()将虚拟机重置回其初始状态，则不应在此虚拟机上再次调用sqlite3_step()。

如果正在执行的 SQL 语句返回任何数据，则 每次新的数据行准备好由调用者处理时，都会返回SQLITE_ROW 。可以使用列访问函数访问这些值。再次调用 sqlite3_step() 以检索下一行数据。

SQLITE_ERROR表示发生了运行时错误（例如违反约束）。不应在 VM 上再次调用 sqlite3_step()。可以通过调用sqlite3_errmsg()找到更多信息。使用旧接口，可以通过在 准备好的语句上调用sqlite3_reset()来获取更具体的错误代码（例如， SQLITE_INTERRUPT、SQLITE_SCHEMA、SQLITE_CORRUPT等）。在“v2”接口中，更具体的错误码由sqlite3_step()直接返回。

SQLITE_MISUSE意味着这个例程被不恰当地调用了。也许它是在一个已经完成的准备好的语句上调用的，或者是在一个之前返回过 SQLITE_ERROR或SQLITE_DONE的语句上调用的。或者可能是两个或多个线程同时使用同一个数据库连接。

对于 3.6.23.1 及之前的所有 SQLite 版本， 在 sqlite3_step() 返回除SQLITE_ROW以外的任何后续调用 sqlite3_step() 之前，需要调用 sqlite3_reset() 。未能使用 sqlite3_reset()重置准备好的语句将导致从 sqlite3_step() 返回SQLITE_MISUSE。但是在版本 3.6.23.1（2010-03-26，sqlite3_step() 开始在这种情况下自动调用sqlite3_reset()而不是返回SQLITE_MISUSE之后。这不被视为兼容性中断，因为任何收到 SQLITE_MISUSE 错误的应用程序都被定义为中断。 这SQLITE_OMIT_AUTORESET编译时选项可用于恢复遗留行为。

愚蠢的接口警报：在旧接口中，sqlite3_step() API 总是返回一个通用错误代码SQLITE_ERROR ，在除SQLITE_BUSY和SQLITE_MISUSE之外的任何错误之后。您必须调用 sqlite3_reset()或sqlite3_finalize()才能找到能够更好地描述错误的特定错误代码之一。我们承认这是一个愚蠢的设计。该问题已通过“v2”界面修复。如果您使用sqlite3_prepare_v3()或sqlite3_prepare_v2() 或sqlite3_prepare16_v2()或sqlite3_prepare16_v3()准备所有 SQL 语句而不是遗留的sqlite3_prepare()和sqlite3_prepare16()接口，然后更具体的错误代码由 sqlite3_step() 直接返回。建议使用“vX”接口。

确定准备好的语句是否已重置

int sqlite3_stmt_busy(sqlite3_stmt*);

sqlite3_stmt_busy(S) 接口返回 true（非零）如果 预处理语句S 已经使用sqlite3_step(S)步进至少一次 但既没有运行完成（ 从sqlite3_step(S)返回SQLITE_DONE）也没有使用sqlite3_reset( S）。如果 S 是 NULL 指针，则 sqlite3_stmt_busy(S) 接口返回 false。如果 S 不是 NULL 指针，也不是指向有效准备语句 对象的指针，则该行为是未定义的并且可能是不需要的。

该接口可以与sqlite3_next_stmt()组合使用， 以定位与需要重置的数据库连接关联的所有准备好的语句。例如，这可以在诊断例程中用于搜索保持事务打开的准备好的语句。

查询准备好的语句的 EXPLAIN 设置

int sqlite3_stmt_isexplain(sqlite3_stmt *pStmt);

如果准备语句 S 是 EXPLAIN 语句，sqlite3_stmt_isexplain(S) 接口返回 1，如果语句 S 是 EXPLAIN QUERY PLAN，则返回 2。如果 S 是普通语句或 NULL 指针，则 sqlite3_stmt_isexplain(S) 接口返回 0。

确定 SQL 语句是否写入数据库

int sqlite3_stmt_readonly(sqlite3_stmt *pStmt);

当且仅当准备好的语句X 不直接更改数据库文件的内容时， sqlite3_stmt_readonly(X) 接口才返回 true（非零） 。

请注意，应用程序定义的 SQL 函数或 虚拟表可能会作为副作用间接更改数据库。例如，如果应用程序定义了一个调用sqlite3_exec()的函数“eval()” ，那么以下 SQL 语句将通过副作用更改数据库文件：

SELECT eval('DELETE FROM t1') FROM t2;

但是因为SELECT语句没有直接改变数据库文件，sqlite3_stmt_readonly() 仍然会返回 true。

诸如BEGIN、COMMIT、ROLLBACK、 SAVEPOINT和RELEASE之类的事务控制语句会导致 sqlite3_stmt_readonly() 返回 true，因为这些语句本身实际上并不修改数据库，而是控制其他语句修改数据库的时间。ATTACH和DETACH语句也会导致 sqlite3_stmt_readonly() 返回 true ，因为当这些语句更改数据库连接的配置时，它们不会更改磁盘上数据库文件的内容。sqlite3_stmt_readonly() 接口从 BEGIN开始为BEGIN返回 true仅设置内部标志，但BEGIN IMMEDIATE和 BEGIN EXCLUSIVE命令确实触及数据库，因此 sqlite3_stmt_readonly() 对这些命令返回 false。

如果该语句有可能更改数据库文件，则此例程返回 false。错误的返回并不能保证该语句会更改数据库文件。例如，UPDATE 语句可能有一个 WHERE 子句使其成为空操作，但 sqlite3_stmt_readonly() 结果仍然为 false。类似地，如果表已经存在，则 CREATE TABLE IF NOT EXISTS 语句是只读的空操作，但 sqlite3_stmt_readonly() 仍会为此类语句返回 false。

如果准备语句 X 是EXPLAIN或EXPLAIN QUERY PLAN 语句，则 sqlite3_stmt_readonly(X) 返回相同的值，就好像省略了 EXPLAIN 或 EXPLAIN QUERY PLAN 前缀一样。

准备好的语句扫描状态

int sqlite3_stmt_scanstatus(
  sqlite3_stmt *pStmt,      /* Prepared statement for which info desired */
  int idx,                  /* Index of loop to report on */
  int iScanStatusOp,        /* Information desired.  SQLITE_SCANSTAT_* */
  void *pOut                /* Result written here */
);

此接口返回有关 pStmt 的预测和测量性能的信息。高级应用程序可以使用此接口来比较预测和测量的性能，并在发现差异时发出警告和/或重新运行ANALYZE 。

由于此接口预计很少使用，因此仅当使用SQLITE_ENABLE_STMT_SCANSTATUS 编译时选项编译 SQLite 时才可用。

“iScanStatusOp”参数决定返回哪些状态信息。“iScanStatusOp”必须是扫描状态选项之一，否则此接口的行为未定义。请求的测量值被写入“pOut”参数指向的变量中。参数“idx”标识要为其检索统计信息的特定循环。循环从零开始编号。如果 idx 超出范围 - 小于零或大于或等于用于实现语句的循环总数 - 返回非零值并且 pOut 指向的变量不变。

统计信息可能不适用于所有语句中的所有循环。在存在没有可用统计信息的循环的情况下，此函数的行为就像循环不存在一样 - 它返回非零值并保持 pOut 指向的变量不变。

另见：sqlite3_stmt_scanstatus_reset()

零扫描状态计数器

void sqlite3_stmt_scanstatus_reset(sqlite3_stmt*);

将所有sqlite3_stmt_scanstatus()相关事件计数器 清零。

此 API 仅在使用定义的预处理器符号SQLITE_ENABLE_STMT_SCANSTATUS构建库时可用。

准备好的声明状态

int sqlite3_stmt_status(sqlite3_stmt*, int op,int resetFlg);

每个准备好的语句都维护着各种 SQLITE_STMTSTATUS 计数器，用于测量它执行特定操作的次数。这些计数器可用于监视准备好的语句的性能特征。例如，如果表步骤的数量大大超过表搜索或结果行的数量，这往往表明准备好的语句正在使用全表扫描而不是索引。

此接口用于从准备好的语句中检索和重置计数器值。第一个参数是要查询的准备好的语句对象。第二个参数是要查询的特定SQLITE_STMTSTATUS 计数器的整数代码 。返回请求的计数器的当前值。如果 resetFlg 为真，则在此接口调用返回后计数器将重置为零。

另见：sqlite3_status()和sqlite3_db_status()。

完成动态字符串

char *sqlite3_str_finish(sqlite3_str*);

sqlite3_str_finish(X)接口销毁 sqlite3_str 对象 X 并返回指向从sqlite3_malloc64()获得的 包含构造字符串的内存缓冲区 的指针。调用应用程序应将返回值传递给sqlite3_free()以避免内存泄漏。如果在构造字符串期间遇到任何错误，sqlite3_str_finish(X) 接口可能会返回 NULL指针。如果sqlite3_str对象 X 中的字符串长度为零字节 ， 则sqlite3_str_finish(X)接口也将返回 NULL 指针。

创建一个新的动态字符串对象

sqlite3_str *sqlite3_str_new(sqlite3*);

sqlite3_str_new(D)接口分配并初始化一个新的 sqlite3_str对象。为避免内存泄漏， sqlite3_str_new()返回的对象必须通过随后调用 sqlite3_str_finish(X)来释放。

sqlite3_str_new(D)接口总是返回一个指向有效sqlite3_str对象的指针，尽管在发生内存不足错误时返回的对象可能是一个特殊的单例，它将默默地拒绝新文本，总是从 sqlite3_str_errcode()返回 SQLITE_NOMEM ，始终为sqlite3_str_length()返回 0 ，并始终从sqlite3_str_finish(X)返回 NULL 。使用sqlite3_str_new(D)返回的值作为任何其他sqlite3_str方法的 sqlite3_str 参数总是安全的。

sqlite3_str_new(D)的 D 参数可能为 NULL。如果sqlite3_str_new(D)中的 D 参数不为 NULL，则sqlite3_str对象中包含的字符串的最大长度将为sqlite3_limit (D, SQLITE_LIMIT_LENGTH ) 设置的值，而不是SQLITE_MAX_LENGTH。

字符串通配

int sqlite3_strglob(const char *zGlob, const char *zStr);

当且仅当字符串 X 匹配GLOB模式P 时，sqlite3_strglob(P,X)接口返回零。sqlite3_strglob (P,X)中使用的GLOB模式匹配 的定义与“X GLOB P”运算符相同SQLite 理解的 SQL 方言。sqlite3_strglob(P,X)函数区分大小写。

请注意，此例程在匹配时返回零，如果字符串不匹配则返回非零，与sqlite3_stricmp()和sqlite3_strnicmp()相同。

另见：sqlite3_strlike()。

字符串 LIKE 匹配

int sqlite3_strlike(const char *zGlob, const char *zStr, unsigned int cEsc);

当且仅当字符串 X 与带有转义字符 E 的LIKE模式 P 匹配时，sqlite3_strlike(P,X,E)接口返回零。sqlite3_strlike( P,X,E)中使用的LIKE模式匹配 的定义与用于SQLite 理解的 SQL 方言中的“X LIKE P ESCAPE E”运算符。对于没有 ESCAPE 子句的“X LIKE P”，将sqlite3_strlike(P,X,E)的 E 参数设置为 0。与 LIKE 运算符一样，sqlite3_strlike(P,X,E)函数不区分大小写 - 等效于大写和小写 ASCII 字符相互匹配。

sqlite3_strlike(P,X,E)函数匹配 Unicode 字符，尽管只有 ASCII 字符是大小写折叠的。

请注意，此例程在匹配时返回零，如果字符串不匹配则返回非零，与sqlite3_stricmp()和sqlite3_strnicmp()相同。

另见：sqlite3_strglob()。

低级系统错误代码

int sqlite3_system_errno(sqlite3*);

尝试返回导致最近 I/O 错误或无法打开文件的底层操作系统错误代码或错误编号。返回值取决于操作系统。例如，在 unix 系统上，在 sqlite3_open_v2()返回SQLITE_CANTOPEN之后，可以调用此接口来取回导致问题的底层“errno”，例如 ENOSPC、EAUTH、EISDIR 等。

提取关于表的列的元数据

int sqlite3_table_column_metadata(
  sqlite3 *db,                /* Connection handle */
  const char *zDbName,        /* Database name or NULL */
  const char *zTableName,     /* Table name */
  const char *zColumnName,    /* Column name */
  char const **pzDataType,    /* OUTPUT: Declared data type */
  char const **pzCollSeq,     /* OUTPUT: Collation sequence name */
  int *pNotNull,              /* OUTPUT: True if NOT NULL constraint exists */
  int *pPrimaryKey,           /* OUTPUT: True if column part of PK */
  int *pAutoinc               /* OUTPUT: True if column is auto-increment */
);

sqlite3_table_column_metadata(X,D,T,C,....)例程在数据库连接X上返回 数据库D中表T的列C的信息。sqlite3_table_column_metadata()接口返回SQLITE_OK并填充非NULL指针在如果指定的列存在，则返回具有适当值的最后五个参数。如果指定的列不存在，sqlite3_table_column_metadata() 接口返回 SQLITE_ERROR。如果 sqlite3_table_column_metadata() 的列名参数是一个 NULL 指针，那么这个例程只是检查表是否存在，如果表存在则返回 SQLITE_OK，如果不存在则返回 SQLITE_ERROR。如果调用 sqlite3_table_column_metadata(X,D,T,C,...) 时表名参数 T 为 NULL，则结果为未定义行为。

该列由该函数的第二个、第三个和第四个参数标识。第二个参数是包含指定表的数据库名称（即“main”、“temp”或附加数据库）或 NULL。如果它为 NULL，则使用数据库引擎使用的相同算法在所有附加的数据库中搜索该表，以解析不合格的表引用。

此函数的第三个和第四个参数分别是所需列的表名和列名。

通过写入作为第 5 个和后续参数传递给此函数的内存位置来返回元数据。这些参数中的任何一个都可以为 NULL，在这种情况下，相应的元数据元素将被省略。

Parameter	Output Type	Description
5th	const char*	Data type
6th	const char*	Name of default collation sequence
7th	int	True if column has a NOT NULL constraint
8th	int	True if column is part of the PRIMARY KEY
9th	int	True if column is AUTOINCREMENT

为声明类型和排序规则序列返回的字符指针指向的内存在下一次​​调用任何 SQLite API 函数之前一直有效。

如果指定的表实际上是一个视图，则返回一个错误代码。

如果指定的列是“rowid”、“oid”或“_rowid_”并且该表不是WITHOUT ROWID表并且已显式声明了 INTEGER PRIMARY KEY列，则为显式声明的列设置输出参数。如果没有 INTEGER PRIMARY KEY列，则rowid的输出设置如下：

data type: "INTEGER"
collation sequence: "BINARY"
not null: 0
primary key: 1
auto increment: 0

此函数会导致从磁盘读取所有数据库模式并进行解析（如果尚未完成），并在加载模式时遇到任何错误时返回错误。

测试界面

int sqlite3_test_control(int op, ...);

sqlite3_test_control() 接口用于读取 SQLite 的内部状态并将故障注入 SQLite 以进行测试。第一个参数是操作码，决定了后面所有参数的个数、含义和操作。

此接口不供应用程序使用。它仅用于验证 SQLite 库的正确操作。根据 SQLite 库的编译方式，此接口可能不存在。

操作代码的详细信息、它们的含义、它们采用的参数以及它们的作用都可能发生变化，恕不另行通知。与大多数 SQLite API 不同，此函数不能保证从一个版本到下一个版本的操作一致。

测试库是否是线程安全的

int sqlite3_threadsafe(void);

当且仅当 SQLite 编译时由于 SQLITE_THREADSAFE编译时选项被设置为 0 而省略了互斥代码，sqlite3_threadsafe() 函数返回零。

SQLite 可以使用或不使用互斥锁进行编译。当SQLITE_THREADSAFE C 预处理器宏为 1 或 2 时，将启用互斥并且 SQLite 是线程安全的。当 SQLITE_THREADSAFE宏为 0 时，互斥量将被忽略。没有互斥体，从多个线程同时使用 SQLite 是不安全的。

启用互斥体会导致可衡量的性能损失。因此，如果速度至关重要，则禁用互斥体是有意义的。但是为了最大程度的安全，应该启用互斥锁。默认行为是启用互斥锁。

应用程序可以使用此接口来确保它所链接的 SQLite 版本是使用SQLITE_THREADSAFE宏的所需设置编译的。

此接口仅报告SQLITE_THREADSAFE标志的编译时互斥设置。如果 SQLite 是用 SQLITE_THREADSAFE=1 或 =2 编译的，则默认情况下启用互斥锁，但可以使用 动词SQLITE_CONFIG_SINGLETHREAD、SQLITE_CONFIG_MULTITHREAD或SQLITE_CONFIG_SERIALIZED调用sqlite3_config()来完全或部分禁用。sqlite3_threadsafe() 函数的返回值仅显示线程安全的编译时设置，而不是 sqlite3_config() 对该设置所做的任何运行时更改。换句话说，sqlite3_threadsafe() 的返回值不会因调用 sqlite3_config() 而改变。

有关其他信息，请参阅线程模式文档。

SQL 跟踪钩子

int sqlite3_trace_v2(
  sqlite3*,
  unsigned uMask,
  int(*xCallback)(unsigned,void*,void*,void*),
  void *pCtx
);

sqlite3_trace_v2(D,M,X,P) 接口使用属性掩码 M 和上下文指针 P 注册针对数据库连接D 的跟踪回调函数 X。如果 X 回调为 NULL 或如果 M 掩码为零，则禁用跟踪. M 参数应该是零个或多个SQLITE_TRACE常量的按位或运算组合。

每次调用 sqlite3_trace() 或 sqlite3_trace_v2() 都会覆盖（取消）之前对 sqlite3_trace() 或 sqlite3_trace_v2() 的任何调用。

只要掩码 M 标识的任何事件发生，就会调用 X 回调。回调的整数返回值目前被忽略，尽管这可能会在未来的版本中改变。回调实现应返回零以确保未来的兼容性。

使用四个参数调用跟踪回调：callback(T,C,P,X)。T 参数是SQLITE_TRACE 常量之一，用于指示调用回调的原因。C 参数是上下文指针的副本。P 和 X 参数是指针，其含义取决于 T。

sqlite3_trace_v2() 接口旨在替换遗留接口sqlite3_trace()和sqlite3_profile()，这两个接口都已弃用。

确定数据库的事务状态

int sqlite3_txn_state(sqlite3*,const char *zSchema);

sqlite3_txn_state(D,S) 接口返回数据库连接D中模式S的当前 事务状态。如果S为NULL，则返回数据库连接D上任何模式的最高事务状态。交易状态是（按从低到高的顺序）：

0. SQLITE_TXN_NONE
1. SQLITE_TXN_READ
2. SQLITE_TXN_WRITE

解锁通知

int sqlite3_unlock_notify(
  sqlite3 *pBlocked,                          /* Waiting connection */
  void (*xNotify)(void **apArg, int nArg),    /* Callback function to invoke */
  void *pNotifyArg                            /* Argument to pass to xNotify */
);

在共享缓存模式下运行时，如果无法获得共享缓存或共享缓存中各个表所需的锁，数据库操作可能会失败并出现SQLITE_LOCKED错误。有关共享缓存锁定的描述，请参阅 SQLite 共享缓存模式。此 API 可用于注册一个回调，当当前持有所需锁的连接放弃它时，SQLite 将调用该回调。仅当使用定义的 SQLITE_ENABLE_UNLOCK_NOTIFY C 预处理器符号编译库时，此 API 才可用。

另请参阅：使用 SQLite 解锁通知功能。

当数据库连接通过提交或回滚结束其当前事务时，将释放共享缓存锁。

当连接（称为阻塞连接）无法获得共享缓存锁并且 SQLITE_LOCKED 返回给调用者时，已锁定所需资源的数据库连接（阻塞连接）的标识将在内部存储。应用程序收到 SQLITE_LOCKED 错误后，它可以调用 sqlite3_unlock_notify() 方法，并将阻塞的连接句柄作为第一个参数来注册回调，当阻塞连接当前事务结束时将调用该回调。回调是从 结束阻塞连接事务的sqlite3_step或sqlite3_close调用中调用的。

如果在多线程应用程序中调用 sqlite3_unlock_notify()，则阻塞连接有可能在调用 sqlite3_unlock_notify() 时已经结束其事务。如果发生这种情况，则会立即调用指定的回调，从对 sqlite3_unlock_notify() 的调用中。

如果被阻塞的连接试图获得共享缓存表上的写锁，并且当前有多个其他连接持有同一张表上的读锁，则 SQLite 会任意选择其他连接之一作为阻塞联系。

阻塞的连接最多可以注册一个解锁通知回调。如果 sqlite3_unlock_notify() 在被阻塞的连接已经注册了解锁通知回调时被调用，那么新的回调会替换旧的。如果使用 NULL 指针作为第二个参数调用 sqlite3_unlock_notify()，则取消任何现有的解锁通知回调。阻塞的连接解锁通知回调也可以通过使用sqlite3_close()关闭阻塞的连接来取消。

解锁通知回调不可重入。如果应用程序从解锁通知回调中调用任何 sqlite3_xxx API 函数，则可能会导致崩溃或死锁。

除非检测到死锁（见下文），sqlite3_unlock_notify() 总是返回 SQLITE_OK。

回调调用详细信息

注册解锁通知回调后，应用程序会提供一个 void* 指针，该指针会在回调被调用时传递给回调。然而，回调函数的签名允许 SQLite 向它传递一个 void* 上下文指针数组。传递给解锁通知回调的第一个参数是指向 void* 指针数组的指针，第二个参数是数组中的条目数。

当阻塞连接的事务结束时，可能有多个阻塞连接注册了解锁通知回调。如果两个或多个这样的阻塞连接指定了相同的回调函数，则不会多次调用回调函数，而是使用捆绑在一起的阻塞连接指定的一组 void* 上下文指针调用一次回调函数。这使应用程序有机会优先考虑与未阻塞的数据库连接集相关的任何操作。

死锁检测

假设在注册解锁通知回调后，数据库在采取任何进一步操作之前等待回调发出（合理的假设），那么使用此 API 可能会导致应用程序死锁。例如，如果连接 X 正在等待连接 Y 的事务结束，类似地，连接 Y 正在等待连接 X 的事务，那么两个连接都不会继续，系统可能会无限期地保持死锁状态。

为了避免这种情况，sqlite3_unlock_notify() 执行死锁检测。如果对 sqlite3_unlock_notify() 的给定调用会使系统处于死锁状态，则返回 SQLITE_LOCKED 并且不会注册解锁通知回调。如果连接 A 在连接 B 的事务结束时注册了解锁通知回调，并且连接 B 本身在连接 A 的事务结束时注册了解锁通知回调，则系统处于死锁状态。还检测到间接死锁，因此如果连接 B 在连接 C 的事务结束时注册了一个解锁通知回调，则系统也被认为是死锁，其中连接 C 正在等待连接 A。任何数量的间接级别都是允许。

“DROP TABLE”异常

当对sqlite3_step()的调用返回 SQLITE_LOCKED 时，调用 sqlite3_unlock_notify() 几乎总是合适的。然而，有一个例外。当执行“DROP TABLE”或“DROP INDEX”语句时，SQLite 检查是否有任何当前正在执行的属于同一连接的 SELECT 语句。如果有，则返回 SQLITE_LOCKED。在这种情况下，没有“阻塞连接”，因此调用 sqlite3_unlock_notify() 会导致立即调用解锁通知回调。如果应用程序随后重新尝试“DROP TABLE”或“DROP INDEX”查询，则结果可能是无限循环。

解决此问题的一种方法是检查 sqlite3_step() 调用返回的扩展错误代码。如果存在阻塞连接，则扩展错误代码设置为 SQLITE_LOCKED_SHAREDCACHE。否则，在特殊的“DROP TABLE/INDEX”情况下，扩展错误代码只是 SQLITE_LOCKED。

数据变更通知回调

void *sqlite3_update_hook(
  sqlite3*,
  void(*)(void *,int ,char const *,char const *,sqlite3_int64),
  void*
);

sqlite3_update_hook() 接口向数据库连接 注册一个回调函数，该回调函数由第一个参数标识，每当在rowid 表中更新、插入或删除行时调用。先前为同一数据库连接调用此函数设置的任何回调都将被覆盖。

第二个参数是指向在 rowid 表中更新、插入或删除行时要调用的函数的指针。回调的第一个参数是 sqlite3_update_hook() 的第三个参数的副本。第二个回调参数是SQLITE_INSERT、SQLITE_DELETE或SQLITE_UPDATE 之一，具体取决于导致调用回调的操作。回调的第三个和第四个参数包含指向包含受影响行的数据库和表名的指针。最后一个回调参数是行的rowid。在更新的情况下，这是更新发生后的rowid 。

修改内部系统表时（即 sqlite_sequence）不会调用更新挂钩。修改WITHOUT ROWID表时，不会调用更新挂钩。

在当前实现中，由于ON CONFLICT REPLACE子句而删除冲突行时，不会调用更新挂钩 。使用截断优化删除行时也不会调用更新挂钩。本段中定义的异常可能会在 SQLite 的未来版本中发生变化。

更新挂钩实现不得做任何会修改调用更新挂钩的数据库连接的事情。任何修改数据库连接的操作都必须推迟到触发更新挂钩的sqlite3_step()调用完成之后。注意，sqlite3_prepare_v2()和sqlite3_step()都针对本段“修改”的意思修改了自己的数据库连接。

sqlite3_update_hook(D,C,P) 函数返回上一次对同一数据库连接D 的调用的 P 参数，或者对于 D 的第一次调用返回 NULL。

另请参阅sqlite3_commit_hook()、sqlite3_rollback_hook()和sqlite3_preupdate_hook()接口。

函数的用户数据

void *sqlite3_user_data(sqlite3_context*);

sqlite3_user_data() 接口返回指针的副本，该指针是最初注册应用程序定义函数的sqlite3_create_function() 和sqlite3_create_function16()例程 的 pUserData 参数（第 5 个参数） 。

必须从运行应用程序定义函数的同一线程调用此例程。

查找 SQL 值的子类型

unsigned int sqlite3_value_subtype(sqlite3_value*);

sqlite3_value_subtype(V) 函数返回应用程序定义的 SQL 函数参数 V 的子类型。子类型信息可用于将有限数量的上下文从一个 SQL 函数传递到另一个。使用sqlite3_result_subtype() 例程为 SQL 函数的返回值设置子类型。

确定虚拟表约束的排序规则

const char *sqlite3_vtab_collation(sqlite3_index_info*,int);

只能从对虚拟表的xBestIndex 方法的调用中调用此函数。此函数返回一个指向字符串的指针，该字符串是适当归类序列的名称，用于对其参数标识的约束进行文本比较。

第一个参数必须是指向sqlite3_index_info对象的指针，它是 xBestIndex() 方法的第一个参数。第二个参数必须是 aConstraint[] 数组的索引，该数组属于传递给 xBestIndex 的 sqlite3_index_info 结构。

重要提示：第​​一个参数必须是传递给 xBestMethod() 方法的同一指针。第一个参数可能不是指向不同sqlite3_index_info对象的指针，即使是精确的副本。