小巧、快速、可靠。
任選三項。

• 首頁
• 選單
• 關於
• 文件
• 下載
• 授權
• 支援
• 購買
• 搜尋

• 關於
• 文件
• 下載
• 支援
• 購買

搜尋文件 搜尋變更日誌

SQLite 的 C 語言介面規格

本頁面旨在提供精確且詳細的規格。如需教學介紹，請改參閱

• 3 分鐘或更短時間認識 SQLite 和/或
• 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 */

下列常數中的一個或多個可以透過 OR 運算組合，作為 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，才能解決某些平台上的編譯器警告。

線上備份物件

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;

如果此全域變數指向一個字串，而該字串是資料夾的名稱（又稱目錄），則 SQLite 在使用內建 Windows VFS 時，所有使用相對路徑名稱指定並建立或存取的資料庫檔案都將假設與該目錄相關。如果此變數是 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 物件在 作業系統介面層 中表示一個開啟的檔案。個別的作業系統介面實作會想要透過附加額外的欄位供自己使用的方式，來建立這個物件的子類別。pMethods 項目是一個指向 sqlite3_io_methods 物件的指標，它定義了在開啟的檔案上執行 I/O 作業的方法。

檔案名稱

typedef const char *sqlite3_filename;

類型 sqlite3_filename 由 SQLite 使用，將檔案名稱傳遞給 VFS 的 xOpen 方法。它可以轉換為 (const char*) 並視為一個包含檔案名稱的正常、以 Null 結尾的 UTF-8 緩衝區，但也可以傳遞給特殊 API，例如

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

虛擬表格索引資訊

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 方法中，並接收其回覆。**輸入**下的欄位是 xBestIndex 的輸入，且為唯讀。xBestIndex 會將其結果插入到 **輸出**欄位中。

aConstraint[] 陣列記錄 WHERE 子句約束，形式為

column OP expr

其中 OP 為 =、<、<=、> 或 >=。特定運算子使用 SQLITE_INDEX_CONSTRAINT_ 值 之一儲存在 aConstraint[].op 中。欄位的索引儲存在 aConstraint[].iColumn 中。如果右手邊的 expr 可以評估（因此約束可以使用），則 aConstraint[].usable 為 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 方法必須使用 aConstraintUsage[] 填入有關傳遞給 xFilter 的參數資訊。如果 argvIndex>0，則會評估對應 aConstraint[] 的右側，並成為 argv 中的第 argvIndex 個項目。如果 aConstraintUsage[].omit 為 true，則假設虛擬表格已完全處理限制條件，且可能不會再由位元組碼檢查。aConstraintUsage[].omit 旗標為最佳化提示。當 omit 旗標保留在預設設定值 false 時，限制條件將始終在位元組碼中個別檢查。如果 omit 旗標變更為 true，則限制條件可能會在位元組碼中檢查，也可能不會。換句話說，當 omit 旗標為 true 時，無法保證不會再使用位元組碼檢查限制條件。

idxNum 和 idxStr 值會被記錄下來並傳遞至 xFilter 方法。僅當 needToFreeIdxStr 為 true 時，才會使用 sqlite3_free() 釋放 idxStr。

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，則 SQLite 會自動回滾 xUpdate 方法所做的任何資料庫變更。

重要：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_collation()、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 的 flags 引數可以是 SQLITE_SYNC_NORMAL 或 SQLITE_SYNC_FULL 之一。第一個選項是正常的 fsync()。第二個選項是 Mac OS X 風格的 fullsync。可以將 SQLITE_SYNC_DATAONLY 旗標按 OR 運算，以表示僅需要同步檔案的資料，而不需要同步其 inode。

傳遞給 xLock() 和 xUnlock() 的整數值之一為

• SQLITE_LOCK_NONE,
• SQLITE_LOCK_SHARED,
• SQLITE_LOCK_RESERVED,
• SQLITE_LOCK_PENDING 或
• 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 測試期間使用，以指定一個替代的記憶體配置器，模擬記憶體耗盡的狀況，以驗證 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 已停用，則其他方法必須執行緒安全，否則必須自行安排序列化。

SQLite 永遠不會在未呼叫 xShutdown() 的情況下呼叫 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 未提供適當實作的系統。在此情況下，應用程式會建立並填入此結構的執行個體，以連同 SQLITE_CONFIG_MUTEX 選項傳遞給 sqlite3_config()。此外，在使用 SQLITE_CONFIG_GETMUTEX 選項查詢系統以取得目前的互斥鎖實作時，此結構的執行個體可用作輸出變數。

此結構定義的 xMutexInit 方法會由 sqlite3_initialize() 函式在系統初始化時呼叫。SQLite 會在每次有效呼叫 sqlite3_initialize() 時呼叫 xMutexInit 常式一次。

此結構定義的 xMutexEnd 方法會由 sqlite3_shutdown() 函式在系統關閉時呼叫。此方法的實作預期會釋出互斥鎖方法實作取得的所有未完成資源，特別是 xMutexInit 方法取得的資源。xMutexEnd() 介面會在每次呼叫 sqlite3_shutdown() 時呼叫一次。

此結構定義的其餘七個方法 (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 記憶體配置。

當呼叫 sqlite3_shutdown() 時，SQLite 會呼叫 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 Runtime (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 Runtime 使用者注意事項：在呼叫 sqlite3_open 或 sqlite3_open_v2 之前，必須先設定暫存目錄。否則，需要使用暫存檔案的各種功能可能會失敗。以下是使用 C++ 搭配 Windows Runtime 執行此操作的範例

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);

OS 介面物件

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*, sqlite3_filename 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 值最初為 1，出現在 2007-09-04 的 SQLite 版本 3.5.0 中，然後在 2010-07-21 的 SQLite 版本 3.7.0 中增加到 2，接著在 2011-04-12 的 SQLite 版本 3.7.6 中增加到 3。未來版本的 SQLite 中可能會附加其他欄位到 sqlite3_vfs 物件，而 iVersion 值也可能會再次增加。請注意，由於疏忽，sqlite3_vfs 物件的結構在從 SQLite 版本 3.5.9 轉換到 2008-07-16 的 版本 3.6.0 時發生變更，但 iVersion 欄位卻沒有增加。

szOsFile 欄位是此 VFS 使用的子類化 sqlite3_file 結構的大小。mxPathname 是此 VFS 中路徑名的最大長度。

已註冊的 sqlite3_vfs 物件會保留在由 pNext 指標形成的連結清單中。 介面會以執行緒安全的方式管理此清單。 SQLite 保證 xOpen 的 zFilename 參數為 NULL 指標或從 xFullPathname() 取得的字串，並加上一個選用的字尾。如果將字尾加到 zFilename 參數，它將包含一個連字符「-」，後接不超過 11 個英數字元和/或「-」字元。SQLite 進一步保證，在呼叫 xClose() 之前，字串將保持有效且不變。由於前一句，sqlite3_file 可以安全地儲存指向檔案名稱的指標，如果它需要記住檔案名稱的原因。如果 xOpen 的 zFilename 參數為 NULL 指標，則 xOpen 必須為檔案發明自己的暫時名稱。每當 xFilename 參數為 NULL 時，flags 參數也會包含 SQLITE_OPEN_DELETEONCLOSE。

xOpen() 的 flags 引數包含 sqlite3_open_v2() 的 flags 引數中設定的所有位元。或者，如果使用 sqlite3_open() 或 sqlite3_open16()，則 flags 至少包含 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 也必須執行此動作。無論 xOpen 呼叫成功或失敗，SQLite 都預期在 xOpen 回傳後 sqlite3_file.pMethods 元素會是有效的。

傳遞給 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() 方法會傳回目前日期和時間的儒略日數，以浮點值表示。xCurrentTimeInt64() 方法會傳回儒略日數乘以 86400000（24 小時一天的毫秒數）的整數。如果 xCurrentTimeInt64() 方法可用（如果 iVersion 是 2 或更大，且函式指標不是 NULL），SQLite 會使用此方法取得目前日期和時間，如果 xCurrentTimeInt64() 不可用，則會改用 xCurrentTime()。

xSetSystemCall()、xGetSystemCall() 和 xNestSystemCall() 介面並未由 SQLite 核心使用。這些選用介面由部分 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() 則會被呼叫一次。在這些情況下，sqlite3_aggregate_context() 可能會在 xFinal() 內部第一次被呼叫。

如果 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。在 xEntryPoint() 傳回後，SQLite 會對 *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()

自動真空壓縮量回呼

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) 的一份拷貝、正在進行自動真空的附加資料庫的結構名稱、資料庫檔案的大小（以頁面為單位）、免費頁面的數量，以及每個頁面的位元組數。回呼應該傳回自動真空應該移除的免費頁面數量。如果回呼傳回零，則不會發生自動真空。如果傳回的值大於或等於免費頁面的數量，則會發生完整的自動真空。

如果有多個附加的資料庫檔案在交易提交時被修改，則會為每個檔案個別呼叫自動真空頁面回呼。

回呼不是可重入的。回呼函數不應嘗試呼叫任何其他 SQLite 介面。如果這樣做，可能會發生不良事件，包括分段錯誤和損毀的資料庫檔案。回呼函數應為一個簡單的函數，對其輸入參數進行一些算術運算並傳回結果。

sqlite3_autovacuum_pages(D,C,P,X) 的 X 參數是 P 參數的選用銷毀器。如果 X 不是 NULL，則每當資料庫連線關閉或當回呼被 sqlite3_autovacuum_pages() 的另一個呼叫覆寫時，就會呼叫 X(P)。

每個資料庫連線只有一個自動真空頁面回呼。對 sqlite3_autovacuum_pages() 介面的每個呼叫都會覆寫該資料庫連線的所有先前呼叫。如果 sqlite3_autovacuum_pages(D,C,P,X) 的回呼引數 (C) 是 NULL 指標，則自動真空步驟回呼會被取消。sqlite3_autovacuum_pages() 的傳回值通常是 SQLITE_OK，但如果發生問題，可能是其他錯誤碼。目前的實作只會傳回 SQLITE_OK 或 SQLITE_MISUSE，但其他傳回碼可能會新增到未來的版本中。

如果未指定自動真空頁面回呼（通常情況）或為回呼提供 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 參數的名稱分別為字串「?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 句柄呼叫此函式會導致未定義的行為。使用 null 指標（例如 sqlite3_blob_open() 呼叫失敗會傳回的指標）呼叫此常式為無害的空操作。否則，如果此函式傳遞有效的開啟 blob 句柄，則會在傳回前設定 sqlite3_errcode() 和 sqlite3_errmsg() 函式傳回的值。

開啟 BLOB 以進行增量 I/O

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

此介面會開啟 句柄 至資料庫 zDb 中的資料表 zTable、欄位 zColumn、列 iRow 所在的 BLOB；換句話說，會選取與下列相同的 BLOB

SELECT zColumn FROM zDb.zTable WHERE rowid = iRow;

參數 zDb 不是包含資料庫的檔案名稱，而是資料庫的符號名稱。對於附加資料庫，這是 ATTACH 陳述式中 AS 關鍵字後出現的名稱。對於主要資料庫檔案，資料庫名稱為「main」。對於 TEMP 資料表，資料庫名稱為「temp」。

如果 flags 參數非零，則 BLOB 會開啟為讀寫存取。如果 flags 參數為零，則 BLOB 會開啟為唯讀存取。

如果成功，會傳回 SQLITE_OK，且新的 BLOB 句柄 會儲存在 *ppBlob 中。否則，會傳回 錯誤碼，且除非錯誤碼為 SQLITE_MISUSE，否則 *ppBlob 會設為 NULL。這表示，只要 API 沒有被誤用，在這個函式傳回後，隨時呼叫 sqlite3_blob_close() 於 *ppBlob 上都是安全的。

如果符合下列任一條件，此函式會傳回 SQLITE_ERROR 失敗：

• 資料庫 zDb 不存在，
• 資料表 zTable 在資料庫 zDb 中不存在，
• 資料表 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 句柄開啟的欄位以外的欄位，此情況仍然成立。sqlite3_blob_read() 和 sqlite3_blob_write() 對已過期 BLOB 句柄的呼叫會失敗，並傳回 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 句柄 讀取到呼叫方提供的緩衝區中。從開啟的 BLOB 中將 N 個位元組的資料複製到緩衝區 Z，從偏移量 iOffset 開始。

如果偏移量 iOffset 小於 BLOB 結尾的 N 個位元組，則會傳回 SQLITE_ERROR，且不會讀取任何資料。如果 N 或 iOffset 小於零，則會傳回 SQLITE_ERROR，且不會讀取任何資料。blob 的大小（因此 N+iOffset 的最大值）可以使用 sqlite3_blob_bytes() 介面來判斷。

嘗試從過期的 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() 的 flags 參數為零），此函式會傳回 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)介面取消註冊初始化常式X，該常式是使用先前呼叫sqlite3_auto_extension(X)註冊的。sqlite3_cancel_auto_extension(X)常式會傳回1，表示已成功取消註冊初始化常式X，如果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() 的第一個引數是一個整數 設定選項，用來決定要設定 SQLite 的哪個屬性。後續引數會根據第一個引數中的 設定選項 而有所不同。

對於大多數設定選項，sqlite3_config() 介面只能在使用 sqlite3_initialize() 進行函式庫初始化之前，或在使用 sqlite3_shutdown() 關閉之後呼叫。可以在任何時間呼叫的例外設定選項稱為「隨時設定選項」。如果在 sqlite3_initialize() 之後和 sqlite3_shutdown() 之前呼叫 sqlite3_config()，而第一個引數不是隨時設定選項，則 sqlite3_config() 呼叫會傳回 SQLITE_MISUSE。不過，請注意，sqlite3_config() 可以作為應用程式定義的 sqlite3_os_init() 實作的一部分來呼叫。

設定設定選項時，sqlite3_config() 會傳回 SQLITE_OK。如果選項不明或 SQLite 無法設定選項，則此常式會傳回非零 錯誤碼。

函式的資料庫連線

sqlite3 *sqlite3_context_db_handle(sqlite3_context*);

sqlite3_context_db_handle() 介面會傳回 資料庫連線 指標的副本（第 1 個參數），而 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 例外，因為多步驟 pragma 的每個步驟都會傳回 0 個資料欄位，所以它總是傳回零。

另請參閱：sqlite3_column_count()

與日誌對應的資料庫檔案

sqlite3_file *sqlite3_database_file_object(const char*);

如果 X 是傳遞到 sqlite3_vfs 的 xOpen 方法的 rollback 或 WAL 模式日誌檔案名稱，則 sqlite3_database_file_object(X) 會傳回指向表示主資料庫檔案的 sqlite3_file 物件的指標。

此常式僅供自訂 VFS 實作使用。它不是一般用途介面。參數 sqlite3_file_object(X) 必須是已傳遞到 sqlite3_vfs.xOpen 方法的檔案名稱指標，其中 xOpen 的 flags 參數包含其中一個位元 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。

如果在將髒頁面沖刷到磁碟時發生任何其他錯誤（例如 I/O 錯誤或記憶體不足狀況），那麼處理會被放棄，而且一個 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，當且僅當呼叫被視為成功時。

傳回資料庫連線的檔案名稱

sqlite3_filename 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() 呼叫（或其變異）的第一個參數相同的 資料庫連線，而該呼叫用於建立陳述式。

擷取資料庫連線的 mutex

sqlite3_mutex *sqlite3_db_mutex(sqlite3*);

當 執行緒模式 為 Serialized 時，此介面傳回一個指向 sqlite3_mutex 物件的指標，該物件會序列化對參數中所提供的 資料庫連線 的存取。如果 執行緒模式 為 Single-thread 或 Multi-thread，那麼此常式會傳回一個 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 的資料庫。

由 SQLite 本身管理用於儲存 sqlite3_db_name() 所傳回字串的空間。任何變更架構的作業都可能會解除配置該字串，包括 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 選項 集合中取得的整數常數，用於決定要查詢的參數。SQLITE_DBSTATUS 選項 集合可能會在 SQLite 的未來版本中增加。

所要求參數的目前值會寫入 *pCur，而最高瞬時值會寫入 *pHiwtr。如果 resetFlg 為 true，則最高瞬時值會重設回目前值。

如果成功，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 中斷連，然後重新開啟 S 為一個基於 P 中所包含序列化資料的記憶體中資料庫。序列化資料庫 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() 來增加緩衝區大小。

應用程式不得在資料庫連線 D 關閉之前修改緩衝區 P 或使它失效。

如果資料庫目前正在執行讀取交易或參與備份作業，則 sqlite3_deserialize() 介面會失敗並顯示 SQLITE_BUSY。

無法解除序列化到 TEMP 資料庫。如果 sqlite3_deserialize(D,S,P,N,M,F) 的 S 引數是「temp」，則函式會傳回 SQLITE_ERROR。

解除序列化的資料庫不應處於 WAL 模式。如果資料庫處於 WAL 模式，則任何嘗試使用資料庫檔案的動作都會導致 SQLITE_CANTOPEN 錯誤。應用程式可以在呼叫 sqlite3_deserialize(D,S,P,N,M,F) 之前將輸入資料庫 P 的 檔案格式版本號碼（位元組 18 和 19）設定為 0x01，以強制資料庫檔案進入回滾模式並解決這個限制。

如果 sqlite3_deserialize(D,S,P,N,M,F) 因任何原因失敗，且在引數 F 中設定了 SQLITE_DESERIALIZE_FREEONCLOSE 位元，則在傳回之前會對引數 P 呼叫 sqlite3_free()。

如果 SQLite 是使用 SQLITE_OMIT_DESERIALIZE 選項編譯，則會略過此介面。

移除不必要的虛擬表格實作

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() 機制。

預設情況下，擴充功能載入是關閉的。呼叫 sqlite3_enable_load_extension() 常式，其中 onoff==1，以開啟擴充功能載入，並呼叫 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);

此常式啟用或停用資料庫快取和架構資料結構在連線到相同資料庫的 連線 之間的共用。如果參數為 true，則啟用共用；如果參數為 false，則停用共用。

如果 SQLite 是使用 -DSQLITE_OMIT_SHARED_CACHE 編譯的，則會略過此介面。-DSQLITE_OMIT_SHARED_CACHE 編譯時期選項是建議使用的，因為 不建議使用共用快取模式。

快取共用會針對整個處理程序啟用和停用。這是 SQLite 版本 3.5.0（2007-09-04）的變更。在先前的 SQLite 版本中，共用會針對每個執行緒個別啟用或停用。

此介面設定的快取共用模式會影響後續所有對 sqlite3_open()、sqlite3_open_v2() 和 sqlite3_open16() 的呼叫。現有的資料庫連線會繼續使用在開啟時生效的共用模式。

如果已成功啟用或停用共用快取，此常式會傳回 SQLITE_OK。否則會傳回 錯誤碼。

共用快取預設為停用。建議維持此狀態。換句話說，請勿使用此常式。此介面持續提供，以維持過往相容性，但建議不要使用。不建議使用任何共用快取。如果必須使用共用快取，建議只使用 sqlite3_open_v2() 介面和 SQLITE_OPEN_SHAREDCACHE 旗標，針對個別資料庫連線啟用共用快取。

注意：此方法在 MacOS X 10.7 和 iOS 版本 5.0 上已停用，且將永遠傳回 SQLITE_MISUSE。在這些系統上，應透過 sqlite3_open_v2() 和 SQLITE_OPEN_SHAREDCACHE，針對每個資料庫連線啟用共用快取模式。

此介面在寫入 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() 的第三個參數的回呼函數不為 NULL，則會針對已評估 SQL 陳述式產生的每一筆結果列呼叫該函數。sqlite3_exec() 的第四個參數會中繼到每個回呼呼叫的第一個參數。如果 sqlite3_exec() 的回呼指標為 NULL，則永遠不會呼叫回呼，且會忽略結果列。

如果在評估傳入 sqlite3_exec() 的 SQL 陳述式時發生錯誤，則目前陳述式的執行會停止，且會略過後續陳述式。如果 sqlite3_exec() 的第五個參數不為 NULL，則任何錯誤訊息都會寫入從 sqlite3_malloc() 取得的記憶體中，並透過第五個參數傳回。為避免記憶體外洩，應用程式應在不再需要錯誤訊息字串後，對透過 sqlite3_exec() 的第五個參數傳回的錯誤訊息字串呼叫 sqlite3_free()。如果 sqlite3_exec() 的第五個參數不為 NULL 且未發生任何錯誤，則 sqlite3_exec() 會在傳回前將其第五個參數中的指標設為 NULL。

如果 sqlite3_exec() 回呼傳回非零值，則 sqlite3_exec() 常式會傳回 SQLITE_ABORT，且不會再呼叫回呼，也不會執行任何後續 SQL 陳述式。

sqlite3_exec() 回呼函式的第 2 個引數是結果中的欄位數目。sqlite3_exec() 回呼函式的第 3 個引數是字串指標陣列，取得的方式如同 sqlite3_column_text()，每個欄位一個。如果結果列的元素為 NULL，則 sqlite3_exec() 回呼函式對應的字串指標為 NULL 指標。sqlite3_exec() 回呼函式的第 4 個引數是字串指標陣列，其中每個項目代表對應結果欄位的名稱，取得的方式如同 sqlite3_column_name()。

如果 sqlite3_exec() 的第 2 個參數為 NULL 指標、空字串指標或僅包含空白和/或 SQL 註解的指標，則不會評估任何 SQL 陳述式，且資料庫不會變更。

限制

• 應用程式必須確保 sqlite3_exec() 的第 1 個參數為有效且開啟的 資料庫連線。
• 應用程式在 sqlite3_exec() 執行期間，不得關閉 sqlite3_exec() 第 1 個參數指定的 資料庫連線。
• 應用程式在 sqlite3_exec() 執行期間，不得修改傳遞給 sqlite3_exec() 第 2 個參數的 SQL 陳述式文字。
• 應用程式在回傳後，不得取消參照傳遞為第 3 個和第 4 個回呼參數的陣列或字串指標。

啟用或停用延伸結果碼

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) 會傳回適當的 錯誤碼 或 延伸錯誤碼。

在 已準備好之陳述式 S 的生命週期中，隨時可以呼叫 sqlite3_finalize(S) 常式：在陳述式 S 評估之前、呼叫 sqlite3_reset() 一次或多次之後，或在呼叫 sqlite3_step() 之後，不論陳述式是否已執行完畢。

對 NULL 指標呼叫 sqlite3_finalize() 是無害的空操作。

應用程式必須完成每個 已準備好之陳述式，以避免資源外洩。應用程式在已準備好之陳述式完成後嘗試使用該陳述式，是一個嚴重的錯誤。在已準備好之陳述式完成後使用該陳述式，可能會導致未定義且不理想的行為，例如區段錯誤和堆損毀。

最後插入的 Rowid

sqlite3_int64 sqlite3_last_insert_rowid(sqlite3*);

大多數 SQLite 表格中的每個項目（WITHOUT ROWID 表格除外）都有稱為 "rowid" 的唯一 64 位元有號整數金鑰。只要這些名稱未被明確宣告的欄位使用，rowid 就會一直以未宣告欄位 ROWID、OID 或 _ROWID_ 的形式存在。如果表格有 INTEGER PRIMARY KEY 類型的欄位，那麼該欄位就是 rowid 的另一個別名。

sqlite3_last_insert_rowid(D) 介面通常會傳回資料庫連線 D 中，最近成功 INSERT 到 rowid 表格或 虛擬表格 的 rowid。插入到 WITHOUT ROWID 表格不會被記錄。如果資料庫連線 D 中從未成功 INSERT 到 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 OR REPLACE 永遠會變更此介面的傳回值。

就此常式而言，即使 INSERT 稍後被還原，也會被視為成功。

此函式可透過 last_insert_rowid() SQL 函式 供 SQL 陳述式存取。

如果在 sqlite3_last_insert_rowid() 函式執行時，另一個執行緒在同一個資料庫連線上執行新的 INSERT，因而變更最後插入的 rowid，則 sqlite3_last_insert_rowid() 傳回的值無法預測，而且可能不等於舊的或新的最後插入 rowid。

執行時間限制

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

此介面允許在連線對連線的基礎上限制各種建構的大小。第一個參數是 資料庫連線，其限制將被設定或查詢。第二個參數是 限制類別 之一，用於定義要限制大小的建構類別。第三個參數是該建構的新限制。

如果新限制為負數，則限制不變。對於每個限制類別 SQLITE_LIMIT_NAME，都有由稱為 SQLITE_MAX_NAME 的 C 預處理器巨集在編譯時設定的 硬上限。（名稱中的「_LIMIT_」已變更為「_MAX_」。）嘗試將限制增加到其硬上限以上時，會在不提示的情況下將其截斷為硬上限。

不論是否變更限制，sqlite3_limit() 介面都會傳回限制的先前值。因此，若要找出限制的目前值而不變更它，只要呼叫此介面，並將第三個參數設定為 -1 即可。

執行時期限制適用於同時管理其自己的內部資料庫和受不受信任的外部來源控制的資料庫的應用程式。範例應用程式可能是網路瀏覽器，它有自己的資料庫來儲存記錄，以及由從網際網路上下載的 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) 介面會在對sqlite3_step()和sqlite3_prepare()進行長時間呼叫期間，以及資料庫連線 D 的類似呼叫期間，定期呼叫回呼函數 X。此介面的範例用途是在大型查詢期間保持 GUI 更新。

參數 P 會作為唯一參數傳遞給回呼函數 X。參數 N 是在回呼 X 的連續呼叫之間評估的虛擬機器指令的近似數量。如果 N 小於 1，則進度處理常式會停用。

每個資料庫連線一次只能定義一個進度處理常式；設定新的進度處理常式會取消舊的進度處理常式。將參數 X 設定為 NULL 會停用進度處理常式。將 N 設定為小於 1 的值也會停用進度處理常式。

如果進度回呼傳回非零值，則會中斷作業。此功能可用於在 GUI 進度對話方塊上實作「取消」按鈕。

進度處理常式回呼不得執行任何會修改呼叫進度處理常式的資料庫連線的動作。請注意，sqlite3_prepare_v2()和sqlite3_step()都會修改其資料庫連線，以符合此段落中「修改」的意義。

進度處理常式回呼原本只會從位元組碼引擎呼叫。它仍然可能在 sqlite3_prepare() 和類似函式中呼叫，因為這些常式可能會強制重新分析架構，這涉及執行位元組碼引擎。然而，從 SQLite 版本 3.41.0 開始，進度處理常式回呼也可能直接從 sqlite3_prepare() 呼叫，同時分析和產生複雜查詢的程式碼。

偽亂數產生器

void sqlite3_randomness(int N, void *P);

SQLite 包含一個高品質的偽亂數產生器 (PRNG)，用於在將新記錄插入到已經使用最大可能 ROWID 的表格中時，選擇隨機 ROWID。PRNG 也用於內建的 random() 和 randomblob() SQL 函式。此介面允許應用程式存取相同的 PRNG 以供其他用途。

呼叫此常式會將 N 位元組的隨機值儲存在緩衝區 P 中。P 參數可以是 NULL 指標。

如果此常式先前未被呼叫，或者先前的呼叫有 N 小於 1 或 P 為 NULL 指標，則 PRNG 會使用從預設 sqlite3_vfs 物件的 xRandomness 方法取得的隨機值來設定種子。如果先前的呼叫有 N 為 1 或更多且 P 非 NULL，則偽亂數會在內部產生，且不求助於 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 重設回其程式的開頭。

sqlite3_reset(S) 的回傳碼會指出準備好的陳述式 S 的前一次評估是否已成功完成。如果從未對 S 呼叫過 sqlite3_step(S)，或如果自上次呼叫 sqlite3_reset(S) 之後尚未呼叫過 sqlite3_step(S)，則 sqlite3_reset(S) 會傳回 SQLITE_OK。

如果 sqlite3_step(S) 對 已準備好的陳述式 S 的最近一次呼叫指出錯誤，則 sqlite3_reset(S) 會傳回適當的 錯誤碼。sqlite3_reset(S) 介面也可能會傳回 錯誤碼，如果先前沒有錯誤，但重設已準備好的陳述式的程序導致新的錯誤。例如，如果 INSERT 陳述式帶有 RETURNING 子句僅執行一次，則對 sqlite3_step(S) 的一次呼叫可能會傳回 SQLITE_ROW，但整體陳述式仍可能失敗，而且 sqlite3_reset(S) 呼叫可能會傳回 SQLITE_BUSY，如果鎖定約束會阻止資料庫變更提交。因此，即使先前對 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 保留的子類型位元組數目可能會增加。

呼叫此介面的每個 應用程式定義的 SQL 函數 都應該在 SQL 函數 註冊 時，在文字編碼引數中包含 SQLITE_RESULT_SUBTYPE 屬性。如果呼叫 sqlite3_result_subtype() 的函數省略 SQLITE_RESULT_SUBTYPE 屬性，則在某些情況下，sqlite3_result_subtype() 可能無法設定結果子類型。

如果 SQLite 編譯時帶有 -DSQLITE_STRICT_SUBTYPE=1，則任何呼叫 sqlite3_result_subtype() 介面且不具備 SQLITE_RESULT_SUBTYPE 屬性的 SQL 函數都會引發錯誤。未來版本的 SQLite 可能會預設啟用 -DSQLITE_STRICT_SUBTYPE=1。

序列化資料庫

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。

在呼叫之後，如果 SQLITE_SERIALIZE_NOCOPY 位元已設定，回傳的緩衝區內容將持續可存取且不變，直到連線上的下一次寫入作業或關閉連線，且應用程式不得修改緩衝區。如果位元已清除，則 SQLite 在呼叫之後將不會存取回傳的緩衝區。

如果發生記憶體配置錯誤，呼叫 sqlite3_serialize(D,S,P,F) 可能會回傳 NULL，即使引數 F 中省略了 SQLITE_SERIALIZE_NOCOPY 位元。

如果 SQLite 是使用 SQLITE_OMIT_DESERIALIZE 選項編譯，則會略過此介面。

設定最後插入列的 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() 的行為可能會偏離前幾段文字中的說明。

如果將負數參數傳遞給 sqlite3_sleep()，結果會因 VFS 和作業系統而異。有些系統將負數參數視為永遠休眠的指令。其他系統則將其理解為完全不休眠。在 SQLite 版本 3.42.0 和更高版本中，傳遞給 sqlite3_sleep() 的負數參數會在傳遞到 VFS 的 xSleep 方法之前變更為零。

比較兩個快照處理序的年齡。

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

sqlite3_snapshot_cmp(P1, P2) 介面用於比較兩個有效快照處理序的年齡。

如果兩個快照處理序未關聯到同一個資料庫檔案，比較結果未定義。

此外，比較結果僅在自從上次刪除 WAL 檔案以來，兩個快照處理序均透過呼叫 sqlite3_snapshot_get() 取得時才有效。當資料庫變更回滾動模式或資料庫用戶端數量降至零時，會刪除 WAL 檔案。如果在上次刪除 WAL 檔案之前取得任一個快照處理序，此函式傳回的值未定義。

否則，如果 P1 參照較舊的快照，此 API 會傳回負值；如果兩個處理序參照同一個資料庫快照，會傳回零；如果 P1 是較新的快照，會傳回正值。

此介面僅在以 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() 時下列任一陳述為 false，則會傳回 SQLITE_ERROR。在此情況下，*P 的最終值未定義。

• 資料庫控制代碼不能處於 自動提交模式。

• 資料庫連線 D 的架構 S 必須是 WAL 模式 資料庫。

• 資料庫連線 D 的架構 S 上不能有開啟的寫入交易。

• 自從在磁碟上建立目前的 wal 檔案以來（透過任何連線），必須已寫入一個或多個交易。這表示無法在 wal 模式資料庫上在首次開啟後立即擷取快照。必須先寫入至少一個交易。

此函式也可能會傳回 SQLITE_NOMEM。如果在資料庫控制代碼處於自動提交模式下呼叫此函式，但因其他原因失敗，則會定義是否在架構 S 上開啟讀取交易。

從成功呼叫 sqlite3_snapshot_get() 傳回的 sqlite3_snapshot 物件必須使用 sqlite3_snapshot_free() 釋放，以避免記憶體外洩。

僅當使用 SQLITE_ENABLE_SNAPSHOT 編譯時期選項時，sqlite3_snapshot_get() 介面才可用。

在歷史快照上開始讀取交易

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 上已開啟讀取交易，則資料庫控制代碼不能有任何作用中的陳述式（已傳遞至 sqlite3_step() 但未傳遞至 sqlite3_reset() 或 sqlite3_finalize() 的 SELECT 陳述式）。如果違反任一條件，或架構 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」，以使其準備好使用快照。）

僅當使用 SQLITE_ENABLE_SNAPSHOT 編譯時期選項時，sqlite3_snapshot_open() 介面才可用。

從 wal 檔案復原快照

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

如果所有資料庫連線關閉後（透過使用 SQLITE_FCNTL_PERSIST_WAL 檔案控制 或因為最後一個開啟資料庫的程序退出而未呼叫 sqlite3_close()），WAL 檔案 仍留在磁碟上，且隨後在該資料庫上開啟新的連線和 WAL 檔案，即使 WAL 檔案包含其他有效的交易，sqlite3_snapshot_open() 介面也只會開啟新增至 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 的陳述式上呼叫。或者，可能是兩個或更多執行緒在同時間使用同一個資料庫連線。

對於所有 SQLite 版本，包括 3.6.23.1，在 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_BUSY 和 SQLITE_MISUSE）後，永遠回傳一般錯誤碼 SQLITE_ERROR。您必須呼叫 sqlite3_reset() 或 sqlite3_finalize()，才能找出更精確描述錯誤的特定 錯誤碼。我們承認這是一個愚蠢的設計。此問題已透過「v2」介面修正。如果您準備所有 SQL 陳述式時，使用 sqlite3_prepare_v3() 或 sqlite3_prepare_v2() 或 sqlite3_prepare16_v2() 或 sqlite3_prepare16_v3()，而不是舊有的 sqlite3_prepare() 和 sqlite3_prepare16() 介面，則 sqlite3_step() 會直接回傳更精確的 錯誤碼。建議使用「vX」介面。

判斷已準備好的陳述式是否已重設

int sqlite3_stmt_busy(sqlite3_stmt*);

如果已透過 sqlite3_step(S) 對 已準備好的陳述式 S 執行過至少一次步驟，但尚未執行完畢（從 sqlite3_step(S) 回傳 SQLITE_DONE），也未透過 sqlite3_reset(S) 重設，則 sqlite3_stmt_busy(S) 介面會回傳 true（非零）。如果 S 是 NULL 指標，則 sqlite3_stmt_busy(S) 介面會回傳 false。如果 S 不是 NULL 指標，也不是指向有效 已準備好的陳述式 物件的指標，則行為未定義，且可能不理想。

此介面可與 sqlite3_next_stmt() 結合使用，以找出與資料庫連線相關的所有已準備好陳述式，這些陳述式需要重設。例如，這可用於診斷例程，以搜尋持有開啟交易的已準備好陳述式。

變更已準備好陳述式的 EXPLAIN 設定

int sqlite3_stmt_explain(sqlite3_stmt *pStmt, int eMode);

sqlite3_stmt_explain(S,E) 介面會變更 已準備好陳述式 S 的 EXPLAIN 設定。如果 E 為零，則 S 會變成正常的已準備好陳述式。如果 E 為 1，則 S 的行為就像其 SQL 文字以「EXPLAIN」開頭。如果 E 為 2，則 S 的行為就像其 SQL 文字以「EXPLAIN QUERY PLAN」開頭。

呼叫 sqlite3_stmt_explain(S,E) 可能會導致 S 被重新準備。SQLite 會嘗試避免重新準備，但第一次轉換到 EXPLAIN 或 EXPLAIN QUERY PLAN 模式時，可能需要重新準備。

由於可能需要重新準備，因此如果無法重新準備 S，則呼叫 sqlite3_stmt_explain(S,E) 會失敗，原因是 S 是使用 sqlite3_prepare() 而不是較新的 sqlite3_prepare_v2() 或 sqlite3_prepare_v3() 介面建立的，因此沒有已儲存的 SQL 文字可供重新準備。

變更已準備好陳述式的說明設定不會變更陳述式的原始 SQL 文字。因此，如果 SQL 文字原本以 EXPLAIN 或 EXPLAIN QUERY PLAN 開頭，但呼叫 sqlite3_stmt_explain(S,0) 將陳述式轉換為一般陳述式，則 EXPLAIN 或 EXPLAIN QUERY PLAN 關鍵字仍會出現在 sqlite3_sql(S) 輸出中，即使陳述式現在的作用就像正常的 SQL 陳述式。

如果成功變更說明模式，此常式會傳回 SQLITE_OK，如果無法變更說明模式，則會傳回錯誤碼。在陳述式處於活動狀態時，無法變更說明模式。因此，建議在呼叫 sqlite3_stmt_explain(S,E) 之前立即呼叫 sqlite3_reset(S)。

查詢已準備陳述式的 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 函式 或 虛擬表格 可能會間接地變更資料庫，作為副作用。例如，如果應用程式定義一個函式「eval()」，用來呼叫 sqlite3_exec()，則下列 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 傳回 true，因為 BEGIN 僅設定內部旗標，但 BEGIN IMMEDIATE 和 BEGIN EXCLUSIVE 命令會接觸資料庫，因此 sqlite3_stmt_readonly() 會為這些命令傳回 false。

如果陳述式有任何可能變更資料庫檔案，此常式會傳回 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 前綴相同的值。

歸零掃描狀態計數器

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 為 true，則在這個介面呼叫傳回後，計數器會重設為零。

另請參閱：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 模式比對的定義與 SQLite 所理解的 SQL 方言中的「X GLOB P」運算子相同。函式 sqlite3_strglob(P,X) 區分大小寫。

請注意，此常式在比對時傳回零，在字串不符時傳回非零，與 sqlite3_stricmp() 和 sqlite3_strnicmp() 相同。

另請參閱：sqlite3_strlike()。

字串 LIKE 比對

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

如果且僅當字串 X 與 LIKE 模式 P（其跳脫字元為 E）相符時，介面 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,....) 傳回資料庫 D 中資料表 T 的欄位 C 的資訊，資料庫連線為 X。如果指定欄位存在，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，如果是這樣，則會略過中繼資料的對應元素。

參數	輸出 類型	說明
第 5 個	const char*	資料類型
第 6 個	const char*	預設排序順序名稱
第 7 個	int	如果欄位具有 NOT NULL 約束，則為 True
第 8 個	int	如果欄位是 PRIMARY KEY 的一部分，則為 True
第 9 個	int	如果欄位是 AUTOINCREMENT，則為 True

宣告類型和排序順序傳回的字元指標所指向的記憶體在下次呼叫任何 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 編譯的，則預設會啟用互斥鎖，但可以使用呼叫 sqlite3_config() 以及動詞 SQLITE_CONFIG_SINGLETHREAD、SQLITE_CONFIG_MULTITHREAD 或 SQLITE_CONFIG_SERIALIZED 來完全或部分停用互斥鎖。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) 介面會針對資料庫連線 D，使用屬性遮罩 M 和內容指標 P，註冊追蹤回呼函式 X。如果 X 回呼為 NULL 或 M 遮罩為零，則會停用追蹤。M 參數應為零或多個SQLITE_TRACE 常數的按位元 OR 組合。

每次呼叫 sqlite3_trace(D,X,P) 或 sqlite3_trace_v2(D,M,X,P) 都會覆寫 (取消)資料庫連線 D 的所有先前 sqlite3_trace(D,X,P) 或 sqlite3_trace_v2(D,M,X,P) 呼叫。每個資料庫連線最多可以有一個追蹤回呼。

當遮罩 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 會呼叫此回呼。此 API 僅在以 SQLITE_ENABLE_UNLOCK_NOTIFY C 預處理器符號定義編譯函式庫時才可用。

另請參閱：使用 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 子句而刪除衝突列時，不會呼叫更新掛鉤。當使用 truncate 最佳化 刪除列時，也不會呼叫更新掛鉤。本段落中定義的例外情況可能會在未來的 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 個參數) 的值，這些常式最初註冊了應用程式定義的函數。

此常式必須從執行應用程式定義函數的相同執行緒中呼叫。

回報 sqlite3_value 物件的內部文字編碼狀態

int sqlite3_value_encoding(sqlite3_value*);

sqlite3_value_encoding(X) 介面會根據 X 值的當前文字編碼，傳回 SQLITE_UTF8、SQLITE_UTF16BE 或 SQLITE_UTF16LE 之一，假設 X 的類型為 TEXT。如果 sqlite3_value_type(X) 傳回的不是 SQLITE_TEXT，則 sqlite3_value_encoding(X) 的傳回值沒有意義。呼叫 sqlite3_value_text(X)、sqlite3_value_text16(X)、sqlite3_value_text16be(X)、sqlite3_value_text16le(X)、sqlite3_value_bytes(X) 或 sqlite3_value_bytes16(X) 可能會變更 X 值的編碼，因此變更後續呼叫 sqlite3_value_encoding(X) 的傳回值。

此常式供測試和驗證 SQLite 執行的應用程式使用。此常式正在查詢 sqlite3_value 物件的不透明內部狀態。一般應用程式不需要知道 sqlite3_value 物件的內部狀態，因此不需要使用此介面。

尋找 SQL 值的子類型

unsigned int sqlite3_value_subtype(sqlite3_value*);

sqlite3_value_subtype(V) 函數傳回 應用程式定義的 SQL 函數 參數 V 的子類型。子類型資訊可用於傳遞有限的內容從一個 SQL 函數傳遞到另一個 SQL 函數。使用 sqlite3_result_subtype() 常式設定 SQL 函數傳回值的子類型。

每個呼叫此介面的 應用程式定義的 SQL 函數 應該在函數 註冊 時包含文字編碼參數中的 SQLITE_SUBTYPE 屬性。如果省略 SQLITE_SUBTYPE 屬性，則在某些特殊情況下，sqlite3_value_subtype() 可能會傳回 0 而不是上游子類型。

決定虛擬表格約束的排序規則

const char *sqlite3_vtab_collation(sqlite3_index_info*,int);

此函數只能在呼叫 xBestIndex 方法的 虛擬表格 中呼叫。此函數傳回指標到字串，該字串是對應排序順序的名稱，用於對其參數識別的約束進行文字比較。

第一個參數必須是指向 sqlite3_index_info 物件的指標，該物件是 xBestIndex() 方法的第一個參數。第二個參數必須是傳遞給 xBestIndex 的 sqlite3_index_info 結構中 aConstraint[] 陣列的索引。

重要：第一個參數必須與傳遞給 xBestMethod() 方法的指標相同。第一個參數不能是指向不同的 sqlite3_index_info 物件的指標，即使是完全的拷貝也不行。

傳回值計算如下

1. 如果約束來自包含 COLLATE 運算子 的 WHERE 子句表達式，則會傳回該 COLLATE 運算子指定的校對名稱。

2. 如果沒有 COLLATE 運算子，但約束的主旨欄位透過 CREATE TABLE 陳述式中欄位定義的 COLLATE 子句 指定了替代校對順序，則會傳回該替代校對順序的名稱，該陳述式已傳遞給 sqlite3_declare_vtab()。

3. 否則，會傳回「BINARY」。

虛擬表格介面組態

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

此函式可以 xConnect 或 xCreate 方法的 虛擬表格 實作呼叫，以組態虛擬表格介面的各種面向。

如果這個介面在 xConnect 或 xCreate 虛擬表格方法的內容之外呼叫，則行為未定義。

在呼叫 sqlite3_vtab_config(D,C,...) 時，D 參數是建立虛擬表格的 資料庫連線，並作為呼叫 sqlite3_vtab_config() 的 xConnect 或 xCreate 方法的第一個引數傳入。C 參數是 虛擬表格組態選項 之一。C 之後參數的存在和意義取決於使用的 虛擬表格組態選項。

判斷虛擬表格查詢是否為 DISTINCT

int sqlite3_vtab_distinct(sqlite3_index_info*);

此 API 只能在 虛擬表格 實作的 xBestIndex 方法 內使用。在 xBestIndex() 外呼叫此介面的結果未定義，而且可能有害。

sqlite3_vtab_distinct() 介面會傳回 0 到 3 之間的整數。sqlite3_vtab_distinct() 傳回的整數會提供虛擬表格關於查詢規劃器希望輸出如何排序的額外資訊。只要虛擬表格可以符合查詢規劃器的排序需求，它就可以設定「orderByConsumed」旗標。

0. 如果 sqlite3_vtab_distinct() 介面傳回 0，表示查詢規劃器需要虛擬表格以 sqlite3_index_info 物件的「nOrderBy」和「aOrderBy」欄位所定義的排序順序傳回所有列。這是預設的期望。如果虛擬表格以排序順序輸出所有列，則無論 sqlite3_vtab_distinct() 的傳回值為何，xBestIndex 方法設定「orderByConsumed」旗標總是安全的。

1. 如果 sqlite3_vtab_distinct() 介面傳回 1，表示查詢規劃器不需要以排序順序傳回列，只要所有在「aOrderBy」欄位所識別的欄位中具有相同值的列相鄰即可。此模式用於查詢規劃器執行 GROUP BY 時。

2. 如果 sqlite3_vtab_distinct() 介面傳回 2，表示查詢規劃器不需要以任何特定順序傳回列，只要在所有「aOrderBy」欄位中具有相同值的列相鄰即可。此外，僅需要傳回「aOrderBy」欄位所識別的欄位中每個特定值組合的一列。傳回兩個或多個在所有「aOrderBy」欄位中具有相同值的列總是沒問題的，只要所有這些列都是相鄰的即可。如果虛擬表格選擇的話，它可以省略在所有由「aOrderBy」所識別的欄位中具有相同值的額外列。但是，省略額外列是可選的。此模式用於 DISTINCT 查詢。

3. 如果 sqlite3_vtab_distinct() 介面傳回 3，表示查詢規劃器僅需要不同的列，但它確實需要這些列進行排序。如果虛擬表格實作想要的話，它可以自由省略在所有 aOrderBy 欄位中相同的列，但它不需要省略任何列。此模式用於同時具有 DISTINCT 和 ORDER BY 子句的查詢。

為了比較虛擬表格輸出值，以查看值是否為排序目的的相同值，兩個 NULL 值被視為相同。換句話說，比較運算子為「IS」（或「IS NOT DISTINCT FROM」），而不是「==」。

如果虛擬表格實作無法符合上述規範，則它不得在 sqlite3_index_info 物件中設定「orderByConsumed」旗標，否則可能會導致不正確的答案。

只要未設定「orderByConsumed」旗標，虛擬表格實作隨時可以依其想要的順序傳回列。當「orderByConsumed」旗標未設定時，查詢規劃器會加入額外的 位元組碼，以確保 SQL 查詢傳回的最終結果正確排序。「orderByConsumed」旗標和 sqlite3_vtab_distinct() 介面的使用僅為最佳化。小心使用 sqlite3_vtab_distinct() 介面和「orderByConsumed」旗標可能有助於針對虛擬表格執行的查詢更快執行。另一方面，過於積極地在不適當的情況下設定「orderByConsumed」旗標，可能會導致 SQLite 傳回不正確的結果。

在 xBestIndex 中識別並處理 IN 約束

int sqlite3_vtab_in(sqlite3_index_info*, int iCons, int bHandle);

這個介面只能在 xBestIndex() 方法 中使用，由 虛擬表格 實作。從任何其他內容呼叫這個介面的結果未定義，而且可能是有害的。

表格限制的型式為「column IN (...)」，會以 SQLITE_INDEX_CONSTRAINT_EQ 限制傳遞至 xBestIndex 方法。如果 xBestIndex 要使用此限制，則必須將對應的 aConstraintUsage[].argvIndex 設為正整數。然後，在處理 IN 運算子的通常模式下，SQLite 會產生 位元組碼，呼叫 xFilter() 方法 一次，以處理 IN 運算子右邊的每個值。因此，虛擬表格一次只會看到 IN 運算子右邊的單一值。

然而，在某些情況下，讓虛擬表格一次看到 IN 運算子右邊的所有值會比較有利。sqlite3_vtab_in() 介面透過兩種方式達成此目的

1. 呼叫 sqlite3_vtab_in(P,N,-1) 會傳回 true (非零)，當且僅當 P->aConstraint[N] 限制是 IN 運算子，可以一次處理完畢。換句話說，第三個引數為 -1 的 sqlite3_vtab_in() 是虛擬表格用來詢問 SQLite 是否可以一次處理 IN 運算子的機制。

2. 呼叫 sqlite3_vtab_in(P,N,F) 其中 F==1 或 F==0 分別表示虛擬表格是否要一次處理 IN 運算子。因此，當第三個參數 (F) 為非負值時，此介面是虛擬表格用來告訴 SQLite 它要如何處理 IN 運算子的機制。

可以在同一個 xBestIndex 方法呼叫中多次呼叫 sqlite3_vtab_in(P,N,F) 介面。對於任何給定的 P,N 配對，sqlite3_vtab_in(P,N,F) 的傳回值在同一個 xBestIndex 呼叫中永遠都是相同的。如果介面傳回 true (非零)，表示限制是 IN 運算子，可以一次處理完畢。如果限制不是 IN 運算子或無法一次處理完畢，則介面會傳回 false。

如果符合下列兩個條件，則會選取 IN 運算子的同時處理

1. P->aConstraintUsage[N].argvIndex 值設定為正整數。這是虛擬表格告訴 SQLite 它想要使用第 N 個約束的方式。

2. 最後一次呼叫 sqlite3_vtab_in(P,N,F)（其中 F 為非負數）的 F>=1。

如果上述條件任一或兩個皆為 false，則 SQLite 會對 IN 約束使用傳統的逐次處理策略。如果兩個條件皆為 true，則 xFilter 方法的 argvIndex 第 n 個參數將會是一個看起來為 NULL 的 sqlite3_value，但可以傳遞給 sqlite3_vtab_in_first() 和 sqlite3_vtab_in_next()，以找出 IN 約束右手邊的所有值。

判斷虛擬表格欄位存取是否用於 UPDATE

int sqlite3_vtab_nochange(sqlite3_context*);

如果 sqlite3_vtab_nochange(X) 常式程式在 xColumn 方法的 虛擬表格 中被呼叫，則如果欄位在 UPDATE 作業中被擷取，且欄位值不會改變，則可能會傳回 true。虛擬表格實作可以使用此提示作為許可，以替換計算成本較低的傳回值，且對應的 xUpdate 方法會將其理解為「無變更」值。

如果 xColumn 方法呼叫 sqlite3_vtab_nochange() 並發現 UPDATE 陳述式未變更欄位，則 xColumn 方法可以選擇在未設定結果、未呼叫任何 sqlite3_result_xxxxx() 介面 的情況下傳回。在這種情況下，sqlite3_value_nochange(X) 會在 xUpdate 方法中傳回 true 給相同的欄位。

sqlite3_vtab_nochange() 常式是一個最佳化。即使 sqlite3_vtab_nochange() 介面總是回傳 false，虛擬表格實作應繼續提供正確的答案。在目前的實作中，sqlite3_vtab_nochange() 介面對於增強的 UPDATE FROM 陳述式總是回傳 false。

決定虛擬表格衝突政策

int sqlite3_vtab_on_conflict(sqlite3 *);

此函式只能在 xUpdate 方法呼叫 虛擬表格 實作的 INSERT 或 UPDATE 動作中呼叫。回傳值之一為 SQLITE_ROLLBACK、SQLITE_IGNORE、SQLITE_FAIL、SQLITE_ABORT 或 SQLITE_REPLACE，根據觸發 xUpdate 方法呼叫 虛擬表格 的 SQL 陳述式的 ON CONFLICT 模式。

xBestIndex() 中的約束值

int sqlite3_vtab_rhs_value(sqlite3_index_info*, int, sqlite3_value **ppVal);

此 API 只能在 虛擬表格 實作的 xBestIndex 方法 中使用。在 xBestIndex 方法外呼叫此介面的結果未定義，且可能造成損害。

當 sqlite3_vtab_rhs_value(P,J,V) 介面從 虛擬表格 實作的 xBestIndex 方法中呼叫，其中 P 是傳遞至 xBestIndex 的 sqlite3_index_info 物件指標的拷貝，而 J 是 P->aConstraint[] 中的 0 為基礎的索引，則此常式嘗試將 *V 設定為該約束的右手運算元的數值（如果已知右手運算元）。如果未知右手運算元，則 *V 會設定為 NULL 指標。唯當 *V 設定為數值時，sqlite3_vtab_rhs_value(P,J,V) 介面才會回傳 SQLITE_OK。如果第 J 個約束的右手邊不可用，則 sqlite3_vtab_rhs_value(P,J,V) 介面會回傳 SQLITE_NOTFOUND。如果發生問題，sqlite3_vtab_rhs_value() 介面可能會回傳除了 SQLITE_OK 或 SQLITE_NOTFOUND 之外的結果碼。

sqlite3_vtab_rhs_value() 介面通常只有在約束的右手運算元是原始 SQL 陳述式中的文字值時才會成功。如果右手運算元是表達式或對其他欄位或 主機參數 的參照，則 sqlite3_vtab_rhs_value() 可能會傳回 SQLITE_NOTFOUND。

有些約束，例如 SQLITE_INDEX_CONSTRAINT_ISNULL 和 SQLITE_INDEX_CONSTRAINT_ISNOTNULL，沒有右手運算元。對於此類約束，sqlite3_vtab_rhs_value() 永遠傳回 SQLITE_NOTFOUND。

在 *V 中傳回的 sqlite3_value 物件是受保護的 sqlite3_value，且在 xBestIndex 方法呼叫期間保持有效。當 xBestIndex 傳回時，由 sqlite3_vtab_rhs_value() 傳回的 sqlite3_value 物件會自動解除配置。

此例程名稱中的「_rhs_」是「右手邊」的縮寫。

設定自動檢查點

int sqlite3_wal_autocheckpoint(sqlite3 *db, int N);

sqlite3_wal_autocheckpoint(D,N) 是 sqlite3_wal_hook() 的包裝器，它會導致 資料庫連線 D 上的任何資料庫在提交交易後自動 檢查點，如果 寫入前記錄 檔案中有 N 個或更多個框架。將零或負值傳遞為 nFrame 參數會完全停用自動檢查點。

此函數註冊的回呼會取代使用 sqlite3_wal_hook() 註冊的任何現有回呼。同樣地，使用 sqlite3_wal_hook() 註冊回呼會停用此函數設定的自動檢查點機制。

可以使用 wal_autocheckpoint pragma 從 SQL 呼叫此介面。

由此機制啟動的檢查點是 PASSIVE。

每個新的 資料庫連線 預設啟用自動檢查點，閾值為 1000 或 SQLITE_DEFAULT_WAL_AUTOCHECKPOINT 頁面。只有在發現預設設定對於特定應用程式而言並非最佳設定時，才需要使用此介面。

檢查點資料庫

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

sqlite3_wal_checkpoint(D,X) 等同於 sqlite3_wal_checkpoint_v2(D,X,SQLITE_CHECKPOINT_PASSIVE,0,0)。

簡而言之，sqlite3_wal_checkpoint(D,X) 會導致 預寫式記錄檔 中的內容傳輸到 資料庫連線 D 上資料庫 X 的資料庫檔案，並重設預寫式記錄檔。有關更多資訊，請參閱 檢查點 文件。

此介面過去是觸發檢查點的唯一方法。但後來新增了較新且功能更強大的 sqlite3_wal_checkpoint_v2() 介面。此介面保留下來以維持向後相容性，並作為應用程式手動啟動回呼，但不需要 sqlite3_wal_checkpoint_v2() 的全部功能（及對應的複雜性）的便利方式。

檢查點資料庫

int sqlite3_wal_checkpoint_v2(
  sqlite3 *db,                    /* Database handle */
  const char *zDb,                /* Name of attached database (or NULL) */
  int eMode,                      /* SQLITE_CHECKPOINT_* value */
  int *pnLog,                     /* OUT: Size of WAL log in frames */
  int *pnCkpt                     /* OUT: Total number of frames checkpointed */
);

sqlite3_wal_checkpoint_v2(D,X,M,L,C) 介面在 資料庫連線 D 的資料庫 X 上執行檢查點作業，模式為 M。狀態資訊會寫回 L 和 C 所指的整數。M 參數必須是有效的 檢查點模式

SQLITE_CHECKPOINT_PASSIVE

在不等待任何資料庫讀取器或寫入器完成的情況下，檢查點盡可能多的畫面，然後如果記錄檔中的所有畫面都已檢查點，則同步資料庫檔案。在 SQLITE_CHECKPOINT_PASSIVE 模式中，絕不會呼叫 忙碌處理常式。另一方面，如果存在同時讀取器或寫入器，則被動模式可能會讓檢查點未完成。

SQLITE_CHECKPOINT_FULL

此模式會封鎖（它會呼叫 忙碌處理常式），直到沒有資料庫寫入器，且所有讀取器都從最新的資料庫快照讀取。然後，它會檢查點記錄檔中的所有畫面，並同步資料庫檔案。此模式會封鎖新的資料庫寫入器，直到它掛起，但允許新的資料庫讀取器繼續不受阻礙。

SQLITE_CHECKPOINT_RESTART

此模式與 SQLITE_CHECKPOINT_FULL 的運作方式相同，但增加了一項功能，在檢查點處理日誌檔案後，會封鎖（呼叫 忙碌處理常式），直到所有讀取器都只從資料庫檔案讀取。這可確保下一個寫入器會從日誌檔案的開頭重新開始。與 SQLITE_CHECKPOINT_FULL 相同，此模式會在處理期間封鎖新的資料庫寫入嘗試，但不會阻礙讀取器。

SQLITE_CHECKPOINT_TRUNCATE

此模式與 SQLITE_CHECKPOINT_RESTART 的運作方式相同，但增加了一項功能，在成功傳回之前，也會將日誌檔案截斷為 0 位元組。

如果 pnLog 不為 NULL，則 *pnLog 會設定為日誌檔案中的總畫面數，或如果檢查點無法執行（因為發生錯誤或資料庫未處於 WAL 模式），則設定為 -1。如果 pnCkpt 不為 NULL，則 *pnCkpt 會設定為日誌檔案中已檢查點的總畫面數（包括在呼叫函式之前已檢查點的畫面），或如果檢查點無法執行（因為發生錯誤或資料庫未處於 WAL 模式），則設定為 -1。請注意，在成功完成 SQLITE_CHECKPOINT_TRUNCATE 後，日誌檔案將被截斷為 0 位元組，因此 *pnLog 和 *pnCkpt 都會設定為 0。

所有呼叫都會取得資料庫檔案上的獨佔「檢查點」鎖定。如果任何其他處理同時執行檢查點操作，則無法取得鎖定，且會傳回 SQLITE_BUSY。即使已設定忙碌處理常式，在此情況下也不會呼叫它。

SQLITE_CHECKPOINT_FULL、RESTART 和 TRUNCATE 模式也會取得資料庫檔案上的獨佔「寫入器」鎖定。如果無法立即取得寫入器鎖定，且已設定忙碌處理常式，則會呼叫它並重試寫入器鎖定，直到忙碌處理常式傳回 0 或成功取得鎖定為止。在等待資料庫讀取器時，也會呼叫忙碌處理常式，如上所述。如果忙碌處理常式在取得寫入器鎖定之前或在等待資料庫讀取器時傳回 0，則檢查點作業會從該點開始，其方式與 SQLITE_CHECKPOINT_PASSIVE 相同，也就是在不進一步封鎖的情況下檢查點盡可能多的框架。這種情況會傳回 SQLITE_BUSY。

如果參數 zDb 為 NULL 或指向長度為零的字串，則會嘗試對所有 附加 至 資料庫連線 db 的 WAL 資料庫執行指定作業。在此情況下，寫入至輸出參數 *pnLog 和 *pnCkpt 的值未定義。如果在處理一個或多個附加 WAL 資料庫時遇到 SQLITE_BUSY 錯誤，則作業仍會嘗試在任何剩餘的附加資料庫上執行，並在最後傳回 SQLITE_BUSY。如果在處理附加資料庫時發生任何其他錯誤，則會放棄處理，並立即將錯誤碼傳回給呼叫者。如果在處理附加資料庫時未遇到任何錯誤（SQLITE_BUSY 或其他），則會傳回 SQLITE_OK。

如果資料庫 zDb 是未處於 WAL 模式的附加資料庫名稱，則會傳回 SQLITE_OK，且 *pnLog 和 *pnCkpt 都設定為 -1。如果 zDb 不為 NULL（或長度為零的字串），且不是任何附加資料庫的名稱，則會傳回 SQLITE_ERROR 給呼叫者。

除非它傳回 SQLITE_MISUSE，否則 sqlite3_wal_checkpoint_v2() 介面會設定由 sqlite3_errcode() 和 sqlite3_errmsg() 查詢的錯誤資訊。

可以使用 PRAGMA wal_checkpoint 指令從 SQL 呼叫此介面。

寫入前記錄提交掛勾

void *sqlite3_wal_hook(
  sqlite3*,
  int(*)(void *,sqlite3*,const char*,int),
  void*
);

函數 sqlite3_wal_hook() 用於註冊一個回呼，每次資料提交到 wal 模式的資料庫時，就會呼叫此回呼。

在提交發生且資料庫上的相關寫入鎖定釋放後，SQLite 會呼叫回呼，因此實作可以視需要讀取、寫入或 檢查點 資料庫。

呼叫回呼函數時傳遞給它的第一個參數是註冊回呼時傳遞給 sqlite3_wal_hook() 的第三個參數的拷貝。第二個是資料庫控制代碼的拷貝。第三個參數是已寫入資料庫的名稱 - 「main」或 ATTACH 資料庫的名稱。第四個參數是寫入前記錄檔中目前頁面的數量，包括剛剛提交的那些。

回呼函數通常應傳回 SQLITE_OK。如果傳回錯誤碼，該錯誤會傳播回 SQLite 程式碼庫，導致引發回呼的陳述報告錯誤，但提交仍會發生。如果回呼傳回 SQLITE_ROW 或 SQLITE_DONE，或如果它傳回的值不對應於任何有效的 SQLite 錯誤碼，則結果未定義。

單一資料庫處理程序一次最多只能註冊一個寫入前記錄回呼。呼叫 sqlite3_wal_hook() 會取代任何先前註冊的寫入前記錄回呼。回傳值是先前呼叫的第三個參數的副本（如果有的話），或 0。請注意，sqlite3_wal_autocheckpoint() 介面和 wal_autocheckpoint pragma 都會呼叫 sqlite3_wal_hook()，並會覆寫任何先前的 sqlite3_wal_hook() 設定。

結果代碼

#define SQLITE_OK           0   /* Successful result */
/* beginning-of-error-codes */
#define SQLITE_ERROR        1   /* Generic error */
#define SQLITE_INTERNAL     2   /* Internal logic error in SQLite */
#define SQLITE_PERM         3   /* Access permission denied */
#define SQLITE_ABORT        4   /* Callback routine requested an abort */
#define SQLITE_BUSY         5   /* The database file is locked */
#define SQLITE_LOCKED       6   /* A table in the database is locked */
#define SQLITE_NOMEM        7   /* A malloc() failed */
#define SQLITE_READONLY     8   /* Attempt to write a readonly database */
#define SQLITE_INTERRUPT    9   /* Operation terminated by sqlite3_interrupt()*/
#define SQLITE_IOERR       10   /* Some kind of disk I/O error occurred */
#define SQLITE_CORRUPT     11   /* The database disk image is malformed */
#define SQLITE_NOTFOUND    12   /* Unknown opcode in sqlite3_file_control() */
#define SQLITE_FULL        13   /* Insertion failed because database is full */
#define SQLITE_CANTOPEN    14   /* Unable to open the database file */
#define SQLITE_PROTOCOL    15   /* Database lock protocol error */
#define SQLITE_EMPTY       16   /* Internal use only */
#define SQLITE_SCHEMA      17   /* The database schema changed */
#define SQLITE_TOOBIG      18   /* String or BLOB exceeds size limit */
#define SQLITE_CONSTRAINT  19   /* Abort due to constraint violation */
#define SQLITE_MISMATCH    20   /* Data type mismatch */
#define SQLITE_MISUSE      21   /* Library used incorrectly */
#define SQLITE_NOLFS       22   /* Uses OS features not supported on host */
#define SQLITE_AUTH        23   /* Authorization denied */
#define SQLITE_FORMAT      24   /* Not used */
#define SQLITE_RANGE       25   /* 2nd parameter to sqlite3_bind out of range */
#define SQLITE_NOTADB      26   /* File opened that is not a database file */
#define SQLITE_NOTICE      27   /* Notifications from sqlite3_log() */
#define SQLITE_WARNING     28   /* Warnings from sqlite3_log() */
#define SQLITE_ROW         100  /* sqlite3_step() has another row ready */
#define SQLITE_DONE        101  /* sqlite3_step() has finished executing */
/* end-of-error-codes */

許多 SQLite 函式會從此處顯示的集合中回傳一個整數結果代碼，以表示成功或失敗。

未來版本的 SQLite 中可能會新增新的錯誤代碼。

另請參閱：延伸結果代碼定義

延伸結果代碼

#define SQLITE_ERROR_MISSING_COLLSEQ   (SQLITE_ERROR | (1<<8))
#define SQLITE_ERROR_RETRY             (SQLITE_ERROR | (2<<8))
#define SQLITE_ERROR_SNAPSHOT          (SQLITE_ERROR | (3<<8))
#define SQLITE_IOERR_READ              (SQLITE_IOERR | (1<<8))
#define SQLITE_IOERR_SHORT_READ        (SQLITE_IOERR | (2<<8))
#define SQLITE_IOERR_WRITE             (SQLITE_IOERR | (3<<8))
#define SQLITE_IOERR_FSYNC             (SQLITE_IOERR | (4<<8))
#define SQLITE_IOERR_DIR_FSYNC         (SQLITE_IOERR | (5<<8))
#define SQLITE_IOERR_TRUNCATE          (SQLITE_IOERR | (6<<8))
#define SQLITE_IOERR_FSTAT             (SQLITE_IOERR | (7<<8))
#define SQLITE_IOERR_UNLOCK            (SQLITE_IOERR | (8<<8))
#define SQLITE_IOERR_RDLOCK            (SQLITE_IOERR | (9<<8))
#define SQLITE_IOERR_DELETE            (SQLITE_IOERR | (10<<8))
#define SQLITE_IOERR_BLOCKED           (SQLITE_IOERR | (11<<8))
#define SQLITE_IOERR_NOMEM             (SQLITE_IOERR | (12<<8))
#define SQLITE_IOERR_ACCESS            (SQLITE_IOERR | (13<<8))
#define SQLITE_IOERR_CHECKRESERVEDLOCK (SQLITE_IOERR | (14<<8))
#define SQLITE_IOERR_LOCK              (SQLITE_IOERR | (15<<8))
#define SQLITE_IOERR_CLOSE             (SQLITE_IOERR | (16<<8))
#define SQLITE_IOERR_DIR_CLOSE         (SQLITE_IOERR | (17<<8))
#define SQLITE_IOERR_SHMOPEN           (SQLITE_IOERR | (18<<8))
#define SQLITE_IOERR_SHMSIZE           (SQLITE_IOERR | (19<<8))
#define SQLITE_IOERR_SHMLOCK           (SQLITE_IOERR | (20<<8))
#define SQLITE_IOERR_SHMMAP            (SQLITE_IOERR | (21<<8))
#define SQLITE_IOERR_SEEK              (SQLITE_IOERR | (22<<8))
#define SQLITE_IOERR_DELETE_NOENT      (SQLITE_IOERR | (23<<8))
#define SQLITE_IOERR_MMAP              (SQLITE_IOERR | (24<<8))
#define SQLITE_IOERR_GETTEMPPATH       (SQLITE_IOERR | (25<<8))
#define SQLITE_IOERR_CONVPATH          (SQLITE_IOERR | (26<<8))
#define SQLITE_IOERR_VNODE             (SQLITE_IOERR | (27<<8))
#define SQLITE_IOERR_AUTH              (SQLITE_IOERR | (28<<8))
#define SQLITE_IOERR_BEGIN_ATOMIC      (SQLITE_IOERR | (29<<8))
#define SQLITE_IOERR_COMMIT_ATOMIC     (SQLITE_IOERR | (30<<8))
#define SQLITE_IOERR_ROLLBACK_ATOMIC   (SQLITE_IOERR | (31<<8))
#define SQLITE_IOERR_DATA              (SQLITE_IOERR | (32<<8))
#define SQLITE_IOERR_CORRUPTFS         (SQLITE_IOERR | (33<<8))
#define SQLITE_IOERR_IN_PAGE           (SQLITE_IOERR | (34<<8))
#define SQLITE_LOCKED_SHAREDCACHE      (SQLITE_LOCKED |  (1<<8))
#define SQLITE_LOCKED_VTAB             (SQLITE_LOCKED |  (2<<8))
#define SQLITE_BUSY_RECOVERY           (SQLITE_BUSY   |  (1<<8))
#define SQLITE_BUSY_SNAPSHOT           (SQLITE_BUSY   |  (2<<8))
#define SQLITE_BUSY_TIMEOUT            (SQLITE_BUSY   |  (3<<8))
#define SQLITE_CANTOPEN_NOTEMPDIR      (SQLITE_CANTOPEN | (1<<8))
#define SQLITE_CANTOPEN_ISDIR          (SQLITE_CANTOPEN | (2<<8))
#define SQLITE_CANTOPEN_FULLPATH       (SQLITE_CANTOPEN | (3<<8))
#define SQLITE_CANTOPEN_CONVPATH       (SQLITE_CANTOPEN | (4<<8))
#define SQLITE_CANTOPEN_DIRTYWAL       (SQLITE_CANTOPEN | (5<<8)) /* Not Used */
#define SQLITE_CANTOPEN_SYMLINK        (SQLITE_CANTOPEN | (6<<8))
#define SQLITE_CORRUPT_VTAB            (SQLITE_CORRUPT | (1<<8))
#define SQLITE_CORRUPT_SEQUENCE        (SQLITE_CORRUPT | (2<<8))
#define SQLITE_CORRUPT_INDEX           (SQLITE_CORRUPT | (3<<8))
#define SQLITE_READONLY_RECOVERY       (SQLITE_READONLY | (1<<8))
#define SQLITE_READONLY_CANTLOCK       (SQLITE_READONLY | (2<<8))
#define SQLITE_READONLY_ROLLBACK       (SQLITE_READONLY | (3<<8))
#define SQLITE_READONLY_DBMOVED        (SQLITE_READONLY | (4<<8))
#define SQLITE_READONLY_CANTINIT       (SQLITE_READONLY | (5<<8))
#define SQLITE_READONLY_DIRECTORY      (SQLITE_READONLY | (6<<8))
#define SQLITE_ABORT_ROLLBACK          (SQLITE_ABORT | (2<<8))
#define SQLITE_CONSTRAINT_CHECK        (SQLITE_CONSTRAINT | (1<<8))
#define SQLITE_CONSTRAINT_COMMITHOOK   (SQLITE_CONSTRAINT | (2<<8))
#define SQLITE_CONSTRAINT_FOREIGNKEY   (SQLITE_CONSTRAINT | (3<<8))
#define SQLITE_CONSTRAINT_FUNCTION     (SQLITE_CONSTRAINT | (4<<8))
#define SQLITE_CONSTRAINT_NOTNULL      (SQLITE_CONSTRAINT | (5<<8))
#define SQLITE_CONSTRAINT_PRIMARYKEY   (SQLITE_CONSTRAINT | (6<<8))
#define SQLITE_CONSTRAINT_TRIGGER      (SQLITE_CONSTRAINT | (7<<8))
#define SQLITE_CONSTRAINT_UNIQUE       (SQLITE_CONSTRAINT | (8<<8))
#define SQLITE_CONSTRAINT_VTAB         (SQLITE_CONSTRAINT | (9<<8))
#define SQLITE_CONSTRAINT_ROWID        (SQLITE_CONSTRAINT |(10<<8))
#define SQLITE_CONSTRAINT_PINNED       (SQLITE_CONSTRAINT |(11<<8))
#define SQLITE_CONSTRAINT_DATATYPE     (SQLITE_CONSTRAINT |(12<<8))
#define SQLITE_NOTICE_RECOVER_WAL      (SQLITE_NOTICE | (1<<8))
#define SQLITE_NOTICE_RECOVER_ROLLBACK (SQLITE_NOTICE | (2<<8))
#define SQLITE_NOTICE_RBU              (SQLITE_NOTICE | (3<<8))
#define SQLITE_WARNING_AUTOINDEX       (SQLITE_WARNING | (1<<8))
#define SQLITE_AUTH_USER               (SQLITE_AUTH | (1<<8))
#define SQLITE_OK_LOAD_PERMANENTLY     (SQLITE_OK | (1<<8))
#define SQLITE_OK_SYMLINK              (SQLITE_OK | (2<<8)) /* internal use only */

在預設組態中，SQLite API 常式會回傳 30 個整數 結果代碼 中的一個。然而，經驗顯示其中許多結果代碼過於粗略。它們無法提供程式設計人員想要的關於問題的資訊。為了解決這個問題，較新的 SQLite 版本（3.3.8 版 2006-10-09 及更新版本）包含支援其他結果代碼的功能，這些代碼會提供關於錯誤的更詳細資訊。這些 延伸結果代碼 會使用 sqlite3_extended_result_codes() API 在每個資料庫連線的基礎上啟用或停用。或者，可以使用 sqlite3_extended_errcode() 取得最近一次錯誤的延伸代碼。

xAccess VFS 方法的旗標

#define SQLITE_ACCESS_EXISTS    0
#define SQLITE_ACCESS_READWRITE 1   /* Used by PRAGMA temp_store_directory */
#define SQLITE_ACCESS_READ      2   /* Unused */

這些整數常數可用作 sqlite3_vfs 物件的 xAccess 方法的第三個參數。它們決定 xAccess 方法尋找哪種類型的權限。使用 SQLITE_ACCESS_EXISTS 時，xAccess 方法僅檢查檔案是否存在。使用 SQLITE_ACCESS_READWRITE 時，xAccess 方法檢查指定的目錄是否可讀寫（換句話說，是否可以在目錄中新增、移除和重新命名檔案）。目前僅 temp_store_directory pragma 使用 SQLITE_ACCESS_READWRITE 常數，儘管這可能會在未來的 SQLite 版本中變更。使用 SQLITE_ACCESS_READ 時，xAccess 方法檢查檔案是否可讀。目前未使用 SQLITE_ACCESS_READ 常數，儘管它可能會在未來的 SQLite 版本中使用。

授權動作代碼

/******************************************* 3rd ************ 4th ***********/
#define SQLITE_CREATE_INDEX          1   /* Index Name      Table Name      */
#define SQLITE_CREATE_TABLE          2   /* Table Name      NULL            */
#define SQLITE_CREATE_TEMP_INDEX     3   /* Index Name      Table Name      */
#define SQLITE_CREATE_TEMP_TABLE     4   /* Table Name      NULL            */
#define SQLITE_CREATE_TEMP_TRIGGER   5   /* Trigger Name    Table Name      */
#define SQLITE_CREATE_TEMP_VIEW      6   /* View Name       NULL            */
#define SQLITE_CREATE_TRIGGER        7   /* Trigger Name    Table Name      */
#define SQLITE_CREATE_VIEW           8   /* View Name       NULL            */
#define SQLITE_DELETE                9   /* Table Name      NULL            */
#define SQLITE_DROP_INDEX           10   /* Index Name      Table Name      */
#define SQLITE_DROP_TABLE           11   /* Table Name      NULL            */
#define SQLITE_DROP_TEMP_INDEX      12   /* Index Name      Table Name      */
#define SQLITE_DROP_TEMP_TABLE      13   /* Table Name      NULL            */
#define SQLITE_DROP_TEMP_TRIGGER    14   /* Trigger Name    Table Name      */
#define SQLITE_DROP_TEMP_VIEW       15   /* View Name       NULL            */
#define SQLITE_DROP_TRIGGER         16   /* Trigger Name    Table Name      */
#define SQLITE_DROP_VIEW            17   /* View Name       NULL            */
#define SQLITE_INSERT               18   /* Table Name      NULL            */
#define SQLITE_PRAGMA               19   /* Pragma Name     1st arg or NULL */
#define SQLITE_READ                 20   /* Table Name      Column Name     */
#define SQLITE_SELECT               21   /* NULL            NULL            */
#define SQLITE_TRANSACTION          22   /* Operation       NULL            */
#define SQLITE_UPDATE               23   /* Table Name      Column Name     */
#define SQLITE_ATTACH               24   /* Filename        NULL            */
#define SQLITE_DETACH               25   /* Database Name   NULL            */
#define SQLITE_ALTER_TABLE          26   /* Database Name   Table Name      */
#define SQLITE_REINDEX              27   /* Index Name      NULL            */
#define SQLITE_ANALYZE              28   /* Table Name      NULL            */
#define SQLITE_CREATE_VTABLE        29   /* Table Name      Module Name     */
#define SQLITE_DROP_VTABLE          30   /* Table Name      Module Name     */
#define SQLITE_FUNCTION             31   /* NULL            Function Name   */
#define SQLITE_SAVEPOINT            32   /* Operation       Savepoint Name  */
#define SQLITE_COPY                  0   /* No longer used */
#define SQLITE_RECURSIVE            33   /* NULL            NULL            */

sqlite3_set_authorizer() 介面註冊一個回呼函式，用於授權某些 SQL 陳述動作。回呼函式的第二個參數是一個整數代碼，用於指定正在授權的動作。以下是授權回呼函式可能會傳遞的整數動作代碼。

這些動作代碼值表示要授權的作業類型。授權回呼函式的第 3 和第 4 個參數將是參數或 NULL，具體取決於哪一個代碼用作第二個參數。如果適用，授權回呼函式的第 5 個參數是資料庫名稱（「main」、「temp」等）。如果此存取嘗試直接來自頂層 SQL 程式碼，授權回呼函式的第 6 個參數是負責存取嘗試的最內層觸發器或檢視的名稱，否則為 NULL。

文字編碼

#define SQLITE_UTF8           1    /* IMP: R-37514-35566 */
#define SQLITE_UTF16LE        2    /* IMP: R-03371-37637 */
#define SQLITE_UTF16BE        3    /* IMP: R-51971-34154 */
#define SQLITE_UTF16          4    /* Use native byte order */
#define SQLITE_ANY            5    /* Deprecated */
#define SQLITE_UTF16_ALIGNED  8    /* sqlite3_create_collation only */

這些常數定義整數代碼，表示 SQLite 支援的各種文字編碼。

基本資料類型

#define SQLITE_INTEGER  1
#define SQLITE_FLOAT    2
#define SQLITE_BLOB     4
#define SQLITE_NULL     5
#ifdef SQLITE_TEXT
# undef SQLITE_TEXT
#else
# define SQLITE_TEXT     3
#endif
#define SQLITE3_TEXT     3

SQLite 中的每個值都具有五種基本資料類型之一

• 64 位元有號整數
• 64 位元 IEEE 浮點數
• 字串
• BLOB
• NULL

這些常數是這些類型中每種類型的代碼。

請注意，SQLITE_TEXT 常數也用於 SQLite 版本 2，但意義完全不同。同時連結到 SQLite 版本 2 和 SQLite 版本 3 的軟體應使用 SQLITE3_TEXT，而非 SQLITE_TEXT。

檢查點模式值

#define SQLITE_CHECKPOINT_PASSIVE  0  /* Do as much as possible w/o blocking */
#define SQLITE_CHECKPOINT_FULL     1  /* Wait for writers, then checkpoint */
#define SQLITE_CHECKPOINT_RESTART  2  /* Like FULL but wait for readers */
#define SQLITE_CHECKPOINT_TRUNCATE 3  /* Like RESTART but also truncate WAL */

這些常數定義傳遞給 sqlite3_wal_checkpoint_v2() 介面作為第三個參數的「檢查點模式」的所有有效值。有關這些檢查點模式中每一個的意義的詳細資訊，請參閱 sqlite3_wal_checkpoint_v2() 文件。

設定選項

#define SQLITE_CONFIG_SINGLETHREAD         1  /* nil */
#define SQLITE_CONFIG_MULTITHREAD          2  /* nil */
#define SQLITE_CONFIG_SERIALIZED           3  /* nil */
#define SQLITE_CONFIG_MALLOC               4  /* sqlite3_mem_methods* */
#define SQLITE_CONFIG_GETMALLOC            5  /* sqlite3_mem_methods* */
#define SQLITE_CONFIG_SCRATCH              6  /* No longer used */
#define SQLITE_CONFIG_PAGECACHE            7  /* void*, int sz, int N */
#define SQLITE_CONFIG_HEAP                 8  /* void*, int nByte, int min */
#define SQLITE_CONFIG_MEMSTATUS            9  /* boolean */
#define SQLITE_CONFIG_MUTEX               10  /* sqlite3_mutex_methods* */
#define SQLITE_CONFIG_GETMUTEX            11  /* sqlite3_mutex_methods* */
/* previously SQLITE_CONFIG_CHUNKALLOC    12 which is now unused. */
#define SQLITE_CONFIG_LOOKASIDE           13  /* int int */
#define SQLITE_CONFIG_PCACHE              14  /* no-op */
#define SQLITE_CONFIG_GETPCACHE           15  /* no-op */
#define SQLITE_CONFIG_LOG                 16  /* xFunc, void* */
#define SQLITE_CONFIG_URI                 17  /* int */
#define SQLITE_CONFIG_PCACHE2             18  /* sqlite3_pcache_methods2* */
#define SQLITE_CONFIG_GETPCACHE2          19  /* sqlite3_pcache_methods2* */
#define SQLITE_CONFIG_COVERING_INDEX_SCAN 20  /* int */
#define SQLITE_CONFIG_SQLLOG              21  /* xSqllog, void* */
#define SQLITE_CONFIG_MMAP_SIZE           22  /* sqlite3_int64, sqlite3_int64 */
#define SQLITE_CONFIG_WIN32_HEAPSIZE      23  /* int nByte */
#define SQLITE_CONFIG_PCACHE_HDRSZ        24  /* int *psz */
#define SQLITE_CONFIG_PMASZ               25  /* unsigned int szPma */
#define SQLITE_CONFIG_STMTJRNL_SPILL      26  /* int nByte */
#define SQLITE_CONFIG_SMALL_MALLOC        27  /* boolean */
#define SQLITE_CONFIG_SORTERREF_SIZE      28  /* int nByte */
#define SQLITE_CONFIG_MEMDB_MAXSIZE       29  /* sqlite3_int64 */

這些常數是可以傳遞給 sqlite3_config() 介面作為第一個參數的可用整數設定選項。

sqlite3_config() 的大多數設定選項只有在 sqlite3_initialize() 之前或 sqlite3_shutdown() 之後呼叫時才會運作。此規則的少數例外稱為「隨時設定選項」。在 sqlite3_initialize() 和 sqlite3_shutdown() 的呼叫之間，使用第一個參數不是隨時設定選項來呼叫 sqlite3_config() 是不會執行任何操作，並會傳回 SQLITE_MISUSE。

隨時設定選項的集合可能會在 SQLite 的一個版本變更到下一個版本時變更（透過插入和/或刪除）。截至 SQLite 版本 3.42.0，隨時設定選項的完整集合為

• SQLITE_CONFIG_LOG
• SQLITE_CONFIG_PCACHE_HDRSZ

未來 SQLite 版本中可能會新增新的組態選項。現有的組態選項可能會停用。應用程式應檢查 sqlite3_config() 的回傳碼，以確保呼叫正常運作。sqlite3_config() 介面會回傳非零 錯誤碼，如果呼叫已停用或不支援的組態選項。

SQLITE_CONFIG_SINGLETHREAD

此選項沒有參數。此選項將 執行緒模式 設定為單一執行緒。換句話說，它會停用所有 mutex，並將 SQLite 設定為只能由單一執行緒使用的模式。如果 SQLite 是使用 SQLITE_THREADSAFE=0 編譯時間選項編譯的，則無法將 執行緒模式 從其預設值 (單一執行緒) 變更，因此如果呼叫具有 SQLITE_CONFIG_SINGLETHREAD 組態選項的 sqlite3_config()，它會回傳 SQLITE_ERROR。

SQLITE_CONFIG_MULTITHREAD

此選項沒有參數。此選項將 執行緒模式 設定為多執行緒。換句話說，它會停用 資料庫連線 和 已準備好的陳述式 物件上的 mutex。應用程式負責序列化對 資料庫連線 和 已準備好的陳述式 的存取。但其他 mutex 會啟用，因此只要沒有兩個執行緒嘗試同時使用同一個 資料庫連線，SQLite 就會安全地用於多執行緒環境。如果 SQLite 是使用 SQLITE_THREADSAFE=0 編譯時間選項編譯的，則無法設定多執行緒 執行緒模式，而且如果呼叫具有 SQLITE_CONFIG_MULTITHREAD 組態選項的 sqlite3_config()，它會回傳 SQLITE_ERROR。

SQLITE_CONFIG_SERIALIZED

此選項沒有參數。此選項將執行緒模式設定為序列化。換句話說，此選項會啟用所有互斥鎖，包括資料庫連線和已準備好的陳述式物件上的遞迴互斥鎖。在此模式中（當 SQLite 使用SQLITE_THREADSAFE=1編譯時為預設值），SQLite 函式庫本身會序列化對資料庫連線和已準備好的陳述式的存取，以便應用程式可以同時在不同的執行緒中使用相同的資料庫連線或相同的已準備好的陳述式。如果 SQLite 使用SQLITE_THREADSAFE=0編譯時間選項編譯，則無法設定序列化執行緒模式，而且如果使用 SQLITE_CONFIG_SERIALIZED 組態選項呼叫sqlite3_config()，則會傳回SQLITE_ERROR。

SQLITE_CONFIG_MALLOC

SQLITE_CONFIG_MALLOC 選項只有一個參數，為指向sqlite3_mem_methods結構體實例的指標。此參數指定要使用的替代低階記憶體配置常式，以取代 SQLite 內建的記憶體配置常式。在sqlite3_config()呼叫傳回之前，SQLite 會建立sqlite3_mem_methods結構體內容的私人副本。

SQLITE_CONFIG_GETMALLOC

SQLITE_CONFIG_GETMALLOC 選項只有一個參數，為指向sqlite3_mem_methods結構體實例的指標。sqlite3_mem_methods結構體會填入目前定義的記憶體配置常式。此選項可用於以模擬記憶體配置失敗或追蹤記憶體使用情況的包裝函式，來覆寫預設的記憶體配置常式。

SQLITE_CONFIG_SMALL_MALLOC

SQLITE_CONFIG_SMALL_MALLOC 選項採用單一 int 類型的引數，解釋為布林值，如果為 true 則向 SQLite 提供提示，表示如果可能應避免大型記憶體配置。如果 SQLite 可以自由進行大型記憶體配置，它將執行得更快，但某些應用程式可能寧願以較慢的速度執行，以換取避免大型配置時可能獲得的記憶體碎片保證。此提示通常關閉。

SQLITE_CONFIG_MEMSTATUS

SQLITE_CONFIG_MEMSTATUS 選項採用單一 int 類型的引數，解釋為布林值，用於啟用或停用記憶體配置統計資訊的收集。當停用記憶體配置統計資訊時，下列 SQLite 介面將停止運作

• sqlite3_hard_heap_limit64()
• sqlite3_memory_used()
• sqlite3_memory_highwater()
• sqlite3_soft_heap_limit64()
• sqlite3_status64()

除非 SQLite 是使用 SQLITE_DEFAULT_MEMSTATUS=0 編譯的，否則記憶體配置統計資訊會預設啟用，這種情況下記憶體配置統計資訊會預設停用。

SQLITE_CONFIG_SCRATCH

SQLITE_CONFIG_SCRATCH 選項不再使用。

SQLITE_CONFIG_PAGECACHE

SQLITE_CONFIG_PAGECACHE 選項指定 SQLite 可使用於資料庫頁面快取的記憶體池，並使用預設的頁面快取實作。如果使用 SQLITE_CONFIG_PCACHE2 載入應用程式定義的頁面快取實作，則此組態選項為無作用。SQLITE_CONFIG_PAGECACHE 有三個參數：8 位元組對齊記憶體的指標 (pMem)、每個頁面快取行的大小 (sz) 和快取行的數量 (N)。sz 參數應該是最大資料庫頁面大小 (512 至 65536 之間的 2 的次方) 加上每個頁面標頭的額外位元組。可以使用 SQLITE_CONFIG_PCACHE_HDRSZ 來確定頁面標頭所需的額外位元組數。除了浪費記憶體之外，sz 參數大於必要值是無害的。pMem 參數必須是 NULL 指標或指向至少 sz*N 位元組的 8 位元組對齊記憶體區塊的指標，否則後續行為未定義。當 pMem 不為 NULL 時，SQLite 會盡力使用提供的記憶體來滿足頁面快取需求，如果頁面快取行大於 sz 位元組或 pMem 緩衝區已耗盡，則會改用 sqlite3_malloc()。如果 pMem 為 NULL 且 N 不為零，則每個資料庫連線都會從 sqlite3_malloc() 進行一次頁面快取記憶體的初始大量配置，如果 N 為正數，則足以容納 N 個快取行，如果 N 為負數，則為 -1024*N 位元組。如果除了初始配置提供的記憶體之外，需要額外的頁面快取記憶體，則 SQLite 會個別為每個額外的快取行轉到 sqlite3_malloc()。

SQLITE_CONFIG_HEAP

SQLITE_CONFIG_HEAP 選項會指定一個靜態記憶體緩衝區，SQLite 會使用它來滿足所有動態記憶體配置需求，除了 SQLITE_CONFIG_PAGECACHE 所提供的需求。只有在 SQLite 以 SQLITE_ENABLE_MEMSYS3 或 SQLITE_ENABLE_MEMSYS5 編譯，才會提供 SQLITE_CONFIG_HEAP 選項，否則呼叫時會傳回 SQLITE_ERROR。SQLITE_CONFIG_HEAP 有三個引數：指向記憶體的 8 位元組對齊指標、記憶體緩衝區中的位元組數，以及最小配置大小。如果第一個指標 (記憶體指標) 為 NULL，則 SQLite 會改用其預設記憶體配置器 (系統 malloc() 實作)，取消之前呼叫 SQLITE_CONFIG_MALLOC 的任何動作。如果記憶體指標不為 NULL，則會使用替代記憶體配置器來處理所有 SQLite 的記憶體配置需求。第一個指標 (記憶體指標) 必須對齊到 8 位元組邊界，否則 SQLite 的後續行為將未定義。最小配置大小上限為 2**12。最小配置大小的合理值為 2**5 到 2**8。

SQLITE_CONFIG_MUTEX

SQLITE_CONFIG_MUTEX 選項會接收一個引數，該引數是指向 sqlite3_mutex_methods 結構實例的指標。該引數會指定要使用的替代低階 mutex 常式，以取代 SQLite 內建的 mutex 常式。在呼叫 sqlite3_config() 傳回之前，SQLite 會複製 sqlite3_mutex_methods 結構的內容。如果 SQLite 以 SQLITE_THREADSAFE=0 編譯時期選項編譯，則整個 mutex 子系統會從建置中省略，因此呼叫具有 SQLITE_CONFIG_MUTEX 組態選項的 sqlite3_config() 會傳回 SQLITE_ERROR。

SQLITE_CONFIG_GETMUTEX

SQLITE_CONFIG_GETMUTEX 選項會接收一個單一參數，為指向 sqlite3_mutex_methods 結構實例的指標。 sqlite3_mutex_methods 結構會填入目前已定義的 mutex 常式。此選項可用於覆寫預設 mutex 配置常式，例如使用包裝器來追蹤 mutex 使用狀況以進行效能剖析或測試。如果 SQLite 是使用 SQLITE_THREADSAFE=0 編譯時期選項編譯，則整個 mutex 子系統會從建置中省略，因此呼叫具有 SQLITE_CONFIG_GETMUTEX 組態選項的 sqlite3_config() 會傳回 SQLITE_ERROR。

SQLITE_CONFIG_LOOKASIDE

SQLITE_CONFIG_LOOKASIDE 選項會接收兩個參數，用於決定每個 資料庫連線 上的預設 lookaside 記憶體大小。第一個參數是每個 lookaside 緩衝區槽的大小，第二個參數是配置給每個資料庫連線的槽數。SQLITE_CONFIG_LOOKASIDE 會設定 預設 lookaside 大小。 SQLITE_DBCONFIG_LOOKASIDE 選項至 sqlite3_db_config() 可用於變更個別連線上的 lookaside 組態。

SQLITE_CONFIG_PCACHE2

SQLITE_CONFIG_PCACHE2 選項會接收一個單一參數，為指向 sqlite3_pcache_methods2 物件的指標。此物件會指定自訂頁面快取實作的介面。SQLite 會複製 sqlite3_pcache_methods2 物件。

SQLITE_CONFIG_GETPCACHE2

SQLITE_CONFIG_GETPCACHE2 選項會接收一個單一參數，為指向 sqlite3_pcache_methods2 物件的指標。SQLite 會將目前的頁面快取實作複製到該物件中。

SQLITE_CONFIG_LOG

SQLITE_CONFIG_LOG 選項用於設定 SQLite 全域 錯誤記錄。（SQLITE_CONFIG_LOG 選項需要兩個引數：指向呼叫簽章為 void(*)(void*,int,const char*) 的函式的指標，以及指向 void 的指標。如果函式指標不是 NULL，sqlite3_log() 會呼叫它來處理每個記錄事件。如果函式指標是 NULL，sqlite3_log() 介面會變成空操作。作為 SQLITE_CONFIG_LOG 第二個引數的 void 指標會在呼叫應用程式定義的記錄器函式時傳遞為第一個參數。記錄器函式的第二個參數是對應 sqlite3_log() 呼叫的第一個參數的副本，並預計為 結果代碼 或 延伸結果代碼。傳遞給記錄器的第三個參數是透過 sqlite3_snprintf() 格式化的記錄訊息。SQLite 記錄介面不是可重入的；應用程式提供的記錄器函式不能呼叫任何 SQLite 介面。在多執行緒應用程式中，應用程式定義的記錄器函式必須是執行緒安全的。

SQLITE_CONFIG_URI

SQLITE_CONFIG_URI 選項需要一個 int 型別的單一引數。如果是非零值，則 URI 處理會在全域啟用。如果參數為零，則 URI 處理會在全域停用。如果 URI 處理在全域啟用，傳遞給 sqlite3_open()、sqlite3_open_v2()、sqlite3_open16() 的所有檔案名稱，或指定為 ATTACH 指令的一部分，都會被解釋為 URI，而不管在開啟資料庫連線時是否設定 SQLITE_OPEN_URI 旗標。如果在全域停用，只有在開啟資料庫連線時設定 SQLITE_OPEN_URI 旗標時，檔案名稱才會被解釋為 URI。預設情況下，URI 處理在全域停用。可以透過使用定義 SQLITE_USE_URI 符號來編譯來變更預設值。

SQLITE_CONFIG_COVERING_INDEX_SCAN

SQLITE_CONFIG_COVERING_INDEX_SCAN 選項採用單一整數引數，該引數會被解釋為布林值，以啟用或停用查詢最佳化器中全表掃描的覆蓋索引使用。預設設定由 SQLITE_ALLOW_COVERING_INDEX_SCAN 編譯時間選項決定，或是在省略該編譯時間選項時為「開啟」。停用全表掃描覆蓋索引使用的功能是因為某些編碼錯誤的舊式應用程式在啟用最佳化時可能會發生故障。提供停用最佳化的功能可讓較舊的錯誤應用程式代碼在較新版本的 SQLite 中運作，而無需變更。

SQLITE_CONFIG_PCACHE 和 SQLITE_CONFIG_GETPCACHE

這些選項已過時，不應由新程式碼使用。它們保留下來以維持向後相容性，但現在是無作用的。

SQLITE_CONFIG_SQLLOG

此選項僅在使用 SQLITE_ENABLE_SQLLOG 預處理器巨集編譯 SQLite 時才可用。第一個引數應該是 void(*)(void*,sqlite3*,const char*, int) 類型的函式的指標。第二個應該是 (void*) 類型。函式庫會在三種不同情況下呼叫回呼，由傳遞為第四個參數的值識別。如果第四個參數為 0，則傳遞為第二個引數的資料庫連線剛剛開啟。第三個引數指向包含主資料庫檔案名稱的緩衝區。如果第四個參數為 1，則第三個參數指向的 SQL 陳述式剛剛執行。或者，如果第四個參數為 2，則傳遞為第二個參數的連線正在關閉。第三個參數在此情況下傳遞 NULL。可以在正規 SQLite 原始碼樹中的「test_sqllog.c」原始碼檔案中看到此組態選項的使用範例。

SQLITE_CONFIG_MMAP_SIZE

SQLITE_CONFIG_MMAP_SIZE 採用兩個 64 位元整數 (sqlite3_int64) 值，分別為預設的 mmap 大小限制 (PRAGMA mmap_size 的預設設定) 和允許的最大 mmap 大小限制。預設設定可以使用 PRAGMA mmap_size 指令或 SQLITE_FCNTL_MMAP_SIZE 檔案控制，由每個資料庫連線覆寫。允許的最大 mmap 大小會在必要時靜默地截斷，以不超過由 SQLITE_MAX_MMAP_SIZE 編譯時間選項設定的編譯時間最大 mmap 大小。如果此選項的任一參數為負值，則該參數會變更為其編譯時間預設值。

SQLITE_CONFIG_WIN32_HEAPSIZE

SQLITE_CONFIG_WIN32_HEAPSIZE 選項僅在使用 SQLITE_WIN32_MALLOC 預處理器巨集為 Windows 編譯 SQLite 時可用。SQLITE_CONFIG_WIN32_HEAPSIZE 採用一個 32 位元無號整數值，用於指定建立的堆疊大小上限。

SQLITE_CONFIG_PCACHE_HDRSZ

SQLITE_CONFIG_PCACHE_HDRSZ 選項採用一個單一參數，該參數是一個指向整數的指標，並將 SQLITE_CONFIG_PAGECACHE 中每個頁面所需的額外位元組數寫入該整數。所需的額外空間量會根據編譯器、目標平台和 SQLite 版本而有所不同。

SQLITE_CONFIG_PMASZ

SQLITE_CONFIG_PMASZ 選項採用一個單一參數，該參數是一個無號整數，並將多執行緒排序器的「最小 PMA 大小」設定為該整數。預設的最小 PMA 大小由 SQLITE_SORTER_PMASZ 編譯時間選項設定。當啟用多執行緒排序 (使用 PRAGMA threads 指令) 且要排序的內容量超過頁面大小乘以 PRAGMA cache_size 設定和此值的最小值時，會啟動新的執行緒來協助排序作業。

SQLITE_CONFIG_STMTJRNL_SPILL

SQLITE_CONFIG_STMTJRNL_SPILL 選項會採用一個參數，成為 陳述式日誌 溢出到磁碟的臨界值。 陳述式日誌 會保留在記憶體中，直到其大小 (以位元組為單位) 超過此臨界值，此時會將其寫入磁碟。或者，如果臨界值為 -1，則陳述式日誌會始終專門保留在記憶體中。由於許多陳述式日誌永遠不會變大，因此將溢出臨界值設定為 64KiB 等值可以大幅減少支援陳述式回滾所需的 I/O 量。此設定的預設值由 SQLITE_STMTJRNL_SPILL 編譯時間選項控制。

SQLITE_CONFIG_SORTERREF_SIZE

SQLITE_CONFIG_SORTERREF_SIZE 選項會接受一個 (int) 類型的參數，也就是分類參考大小臨界值的新值。通常，當 SQLite 使用外部排序根據 ORDER BY 子句排序記錄時，呼叫者所需的所有欄位都會出現在已排序的記錄中。但是，如果 SQLite 根據資料表欄位的宣告類型判斷其值可能會非常大 (大於已設定的分類參考大小臨界值)，則會在每個已排序的記錄中儲存一個參考，並在已排序順序中傳回記錄時，從資料庫載入所需的欄位值。此選項的預設值是永遠不使用此最佳化。為此選項指定負值會還原預設行為。此選項僅在使用 SQLITE_ENABLE_SORTER_REFERENCES 編譯時間選項編譯 SQLite 時才可用。

SQLITE_CONFIG_MEMDB_MAXSIZE

SQLITE_CONFIG_MEMDB_MAXSIZE 選項會接受一個 sqlite3_int64 參數，也就是使用 sqlite3_deserialize() 建立的記憶體中資料庫的預設最大大小。此預設最大大小可以使用 SQLITE_FCNTL_SIZE_LIMIT 檔案控制 對個別資料庫進行調整。如果從未使用此設定，則預設最大值由 SQLITE_MEMDB_DEFAULT_MAXSIZE 編譯時間選項決定。如果未設定該編譯時間選項，則預設最大值為 1073741824。

資料庫連線組態選項

#define SQLITE_DBCONFIG_MAINDBNAME            1000 /* const char* */
#define SQLITE_DBCONFIG_LOOKASIDE             1001 /* void* int int */
#define SQLITE_DBCONFIG_ENABLE_FKEY           1002 /* int int* */
#define SQLITE_DBCONFIG_ENABLE_TRIGGER        1003 /* int int* */
#define SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER 1004 /* int int* */
#define SQLITE_DBCONFIG_ENABLE_LOAD_EXTENSION 1005 /* int int* */
#define SQLITE_DBCONFIG_NO_CKPT_ON_CLOSE      1006 /* int int* */
#define SQLITE_DBCONFIG_ENABLE_QPSG           1007 /* int int* */
#define SQLITE_DBCONFIG_TRIGGER_EQP           1008 /* int int* */
#define SQLITE_DBCONFIG_RESET_DATABASE        1009 /* int int* */
#define SQLITE_DBCONFIG_DEFENSIVE             1010 /* int int* */
#define SQLITE_DBCONFIG_WRITABLE_SCHEMA       1011 /* int int* */
#define SQLITE_DBCONFIG_LEGACY_ALTER_TABLE    1012 /* int int* */
#define SQLITE_DBCONFIG_DQS_DML               1013 /* int int* */
#define SQLITE_DBCONFIG_DQS_DDL               1014 /* int int* */
#define SQLITE_DBCONFIG_ENABLE_VIEW           1015 /* int int* */
#define SQLITE_DBCONFIG_LEGACY_FILE_FORMAT    1016 /* int int* */
#define SQLITE_DBCONFIG_TRUSTED_SCHEMA        1017 /* int int* */
#define SQLITE_DBCONFIG_STMT_SCANSTATUS       1018 /* int int* */
#define SQLITE_DBCONFIG_REVERSE_SCANORDER     1019 /* int int* */
#define SQLITE_DBCONFIG_MAX                   1019 /* Largest DBCONFIG */

這些常數是可用的整數組態選項，可傳遞為 sqlite3_db_config() 介面的第二個參數。

在 SQLite 的未來版本中可能會新增組態選項。現有的組態選項可能會終止。應用程式應檢查 sqlite3_db_config() 的回傳碼，以確保呼叫正常運作。sqlite3_db_config() 介面會回傳非零的 錯誤碼，如果呼叫終止或不支援的組態選項。

SQLITE_DBCONFIG_LOOKASIDE

此選項需要三個額外的參數，以決定 lookaside 記憶體配置器 的組態，用於 資料庫連線。第一個參數（sqlite3_db_config() 的第三個參數）是指向要使用的 lookaside 記憶體的記憶體緩衝區。如果 SQLITE_DBCONFIG_LOOKASIDE 動詞後的第一個參數為 NULL，則 SQLite 會使用 sqlite3_malloc() 自行配置 lookaside 緩衝區。第二個參數是每個 lookaside 緩衝區槽的大小。第三個參數是槽的數量。第一個參數中緩衝區的大小必須大於或等於第二個和第三個參數的乘積。緩衝區必須與 8 位元組邊界對齊。如果 SQLITE_DBCONFIG_LOOKASIDE 的第二個參數不是 8 的倍數，則會在內部向下捨入到下一個較小的 8 的倍數。資料庫連線的 lookaside 記憶體組態只能在該連線目前未使用 lookaside 記憶體時變更，或者換句話說，當 sqlite3_db_status(D,SQLITE_DBSTATUS_LOOKASIDE_USED,...) 回傳的「目前值」為零時。當 lookaside 記憶體正在使用時，任何變更 lookaside 記憶體組態的嘗試都會讓組態保持不變，並回傳 SQLITE_BUSY。

SQLITE_DBCONFIG_ENABLE_FKEY

此選項用於啟用或停用外來金鑰約束的執行。應該有兩個額外的參數。第一個參數是一個整數，為 0 表示停用 FK 執行，正數表示啟用 FK 執行，負數表示不變更 FK 執行。第二個參數是一個指標，指向一個整數，其中寫入 0 或 1，以指示在此呼叫之後 FK 執行是否關閉或開啟。第二個參數可以是 NULL 指標，這種情況下不會回報 FK 執行設定。

SQLITE_DBCONFIG_ENABLE_TRIGGER

此選項用於啟用或停用觸發器。應該有兩個額外的參數。第一個參數是一個整數，為 0 表示停用觸發器，正數表示啟用觸發器，負數表示不變更設定。第二個參數是一個指標，指向一個整數，其中寫入 0 或 1，以指示在此呼叫之後觸發器是否停用或啟用。第二個參數可以是 NULL 指標，這種情況下不會回報觸發器設定。

最初此選項停用所有觸發器。然而，自 SQLite 版本 3.35.0 起，即使此選項關閉，仍允許 TEMP 觸發器。因此，換句話說，此選項現在只停用主資料庫架構或 ATTACH-ed 資料庫架構中的觸發器。

SQLITE_DBCONFIG_ENABLE_VIEW

此選項用於啟用或停用檢視。應該有兩個額外的參數。第一個參數是一個整數，為 0 表示停用檢視，正數表示啟用檢視，或負數表示不變更設定。第二個參數是一個指標，指向一個整數，其中會寫入 0 或 1，以表示在呼叫之後檢視是否已停用或啟用。第二個參數可以是 NULL 指標，這種情況下檢視設定不會回報。

最初此選項停用所有檢視。然而，自 SQLite 版本 3.35.0 起，即使此選項關閉，TEMP 檢視仍被允許。所以，換句話說，此選項現在只停用主資料庫結構或 ATTACH 資料庫結構中的檢視。

SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER

此選項用於啟用或停用fts3_tokenizer()函數，它是FTS3全文檢索引擎擴充功能的一部分。應該有兩個額外的參數。第一個參數是一個整數，為 0 表示停用 fts3_tokenizer()，正數表示啟用 fts3_tokenizer()，或負數表示不變更設定。第二個參數是一個指標，指向一個整數，其中會寫入 0 或 1，以表示在呼叫之後 fts3_tokenizer 是否已停用或啟用。第二個參數可以是 NULL 指標，這種情況下新的設定不會回報。

SQLITE_DBCONFIG_ENABLE_LOAD_EXTENSION

此選項用於啟用或停用 sqlite3_load_extension() 介面，與 load_extension() SQL 函數無關。 sqlite3_enable_load_extension() API 會啟用或停用 C-API sqlite3_load_extension() 和 SQL 函數 load_extension()。應該有兩個額外的引數。當此介面的第一個引數為 1 時，則僅啟用 C-API，而 SQL 函數仍停用。如果此介面的第一個引數為 0，則 C-API 和 SQL 函數都會停用。如果第一個引數為 -1，則不會對 C-API 或 SQL 函數的狀態進行任何變更。第二個參數是指向整數的指標，其中會寫入 0 或 1 以指示在呼叫之後 sqlite3_load_extension() 介面是否已停用或啟用。第二個參數可以是 NULL 指標，在此情況下不會回報新的設定。

SQLITE_DBCONFIG_MAINDBNAME

此選項用於變更「主」資料庫架構的名稱。唯一的引數是指向常數 UTF8 字串的指標，它將取代「主」而成為新的架構名稱。SQLite 不會複製新的主架構名稱字串，因此應用程式必須確保傳遞給此 DBCONFIG 選項的引數在資料庫連線關閉之前保持不變。

SQLITE_DBCONFIG_NO_CKPT_ON_CLOSE

通常，當 wal 模式中的資料庫關閉或從資料庫處理中分離時，SQLite 會檢查這是否表示現在完全沒有連線到資料庫。如果是，它會在關閉連線前執行檢查點操作。此選項可用於覆寫此行為。傳遞給此操作的第一個參數是一個整數 - 正數表示停用關閉時檢查點，或零（預設值）表示啟用，負數表示不變更設定。第二個參數是一個指向整數的指標，其中會寫入 0 或 1 以表示是否已停用關閉時檢查點 - 如果未停用，則為 0，如果已停用，則為 1。

SQLITE_DBCONFIG_ENABLE_QPSG

SQLITE_DBCONFIG_ENABLE_QPSG 選項會啟用或停用查詢規劃器穩定性保證 (QPSG)。當 QPSG 處於活動狀態時，單一 SQL 查詢陳述式將始終使用相同的演算法，而不論繫結參數的值為何。QPSG 會停用某些查詢最佳化，這些最佳化會檢視繫結參數的值，這可能會使某些查詢變慢。但 QPSG 的優點是行為更可預測。在 QPSG 處於活動狀態時，SQLite 將始終在現場使用與實驗室測試期間相同的查詢計畫。此設定的第一個參數是一個整數，為 0 表示停用 QPSG，正數表示啟用 QPSG，負數表示不變更設定。第二個參數是一個指向整數的指標，其中會寫入 0 或 1 以表示在呼叫後 QPSG 是否已停用或啟用。

SQLITE_DBCONFIG_TRIGGER_EQP

預設情況下，EXPLAIN QUERY PLAN 指令的輸出不包括觸發程式執行任何操作的輸出。此選項用於設定或清除（預設值）控制此行為的旗標。傳遞給此操作的第一個參數是一個整數 - 正數表示啟用觸發程式的輸出，或零表示停用，或負數表示不變更設定。第二個參數是一個指向整數的指標，其中會寫入 0 或 1 以表示是否已停用觸發程式的輸出 - 如果未停用，則為 0，如果已停用，則為 1。

SQLITE_DBCONFIG_RESET_DATABASE

設定 SQLITE_DBCONFIG_RESET_DATABASE 旗標，然後執行VACUUM，以將資料庫重設回沒有架構和沒有內容的空資料庫。下列程序甚至適用於嚴重損毀的資料庫檔案

1. 如果資料庫連線是新開啟的，請確保它已讀取資料庫架構，方法是準備查詢後捨棄對資料庫的查詢，或呼叫 sqlite3_table_column_metadata()，忽略任何錯誤。如果資料庫在重設前處於 WAL 模式，則只有在應用程式希望在重設後將資料庫保留在 WAL 模式時，才需要執行此步驟。
2. sqlite3_db_config(db, SQLITE_DBCONFIG_RESET_DATABASE, 1, 0);
3. sqlite3_exec(db, "VACUUM", 0, 0, 0);
4. sqlite3_db_config(db, SQLITE_DBCONFIG_RESET_DATABASE, 0, 0);

由於重設資料庫具有破壞性且不可逆，因此此程序需要使用這個模糊的 API 和多個步驟，以確保不會意外發生。由於此功能必須能夠重設損毀的資料庫，而關閉虛擬表格可能需要存取該損毀的儲存空間，因此函式庫必須放棄任何已安裝的虛擬表格，而不會呼叫其 xDestroy() 方法。

SQLITE_DBCONFIG_DEFENSIVE

SQLITE_DBCONFIG_DEFENSIVE 選項會啟用或停用資料庫連線的「防禦性」旗標。當啟用防禦性旗標時，允許一般 SQL 蓄意損毀資料庫檔案的語言功能會被停用。停用的功能包括但不限於下列項目：

• PRAGMA writable_schema=ON 陳述式。
• PRAGMA journal_mode=OFF 陳述式。
• PRAGMA schema_version=N 陳述式。
• 寫入 sqlite_dbpage 虛擬表格。
• 直接寫入 影子表格。

SQLITE_DBCONFIG_WRITABLE_SCHEMA

SQLITE_DBCONFIG_WRITABLE_SCHEMA 選項會啟用或停用「writable_schema」旗標。這具有相同的效用，在邏輯上等同於設定 PRAGMA writable_schema=ON 或 PRAGMA writable_schema=OFF。此設定的第一個引數是一個整數，0 表示停用 writable_schema，正數表示啟用 writable_schema，或負數表示不變更設定。第二個參數是一個指向整數的指標，會寫入 0 或 1，以表示在此呼叫後 writable_schema 是啟用或停用。

SQLITE_DBCONFIG_LEGACY_ALTER_TABLE

SQLITE_DBCONFIG_LEGACY_ALTER_TABLE 選項會啟用或停用 ALTER TABLE RENAME 指令的舊有行為，使其行為如同在 3.24.0 版（2018-06-04）之前一樣。請參閱 ALTER TABLE RENAME 文件 中的「相容性公告」，以取得更多資訊。此功能也可以使用 PRAGMA legacy_alter_table 陳述式開啟和關閉。

SQLITE_DBCONFIG_DQS_DML

SQLITE_DBCONFIG_DQS_DML 選項會啟用或停用 DML 陳述式（也就是 DELETE、INSERT、SELECT 和 UPDATE 陳述式）的舊有 雙引號字串文字 錯誤功能。此設定的預設值是由 -DSQLITE_DQS 編譯時間選項決定的。

SQLITE_DBCONFIG_DQS_DDL

SQLITE_DBCONFIG_DQS 選項會啟用或停用 DDL 陳述式（例如 CREATE TABLE 和 CREATE INDEX）的舊有 雙引號字串文字 錯誤功能。此設定的預設值是由 -DSQLITE_DQS 編譯時間選項決定的。

SQLITE_DBCONFIG_TRUSTED_SCHEMA

SQLITE_DBCONFIG_TRUSTED_SCHEMA 選項會指示 SQLite 假設資料庫架構未受到惡意內容的污染。當 SQLITE_DBCONFIG_TRUSTED_SCHEMA 選項停用時，SQLite 會採取額外的防禦措施來保護應用程式免於受到傷害，包括

• 禁止在觸發器、檢視、CHECK 約束、DEFAULT 子句、表達式索引、部分索引或產生式欄位中使用 SQL 函數，除非這些函數標記為 SQLITE_INNOCUOUS。
• 禁止在觸發器或檢視中使用虛擬表格，除非這些虛擬表格標記為 SQLITE_VTAB_INNOCUOUS。

此設定預設為「開啟」，以維持舊版相容性，但建議所有應用程式在可能的情況下關閉它。此設定也可以使用 PRAGMA trusted_schema 陳述式來控制。

SQLITE_DBCONFIG_LEGACY_FILE_FORMAT

SQLITE_DBCONFIG_LEGACY_FILE_FORMAT 選項會啟用或停用舊版檔案格式旗標。啟用時，此旗標會讓所有新建立的資料庫檔案的架構格式版本號碼（資料庫標頭中偏移量 44 處的 4 位元組整數）為 1。這表示產生的資料庫檔案將可以由任何 SQLite 版本（回溯至 3.0.0（2004-06-18））讀取和寫入。沒有此設定，新建立的資料庫通常無法被 3.3.0（2006-01-11）之前的 SQLite 版本理解。撰寫這些文字時，幾乎沒有必要產生與 3.0.0 版本相容的資料庫檔案，因此此設定的實用性很低，但提供此設定讓 SQLite 可以繼續宣稱有能力產生與 3.0.0 版本相容的新資料庫檔案。

請注意，當 SQLITE_DBCONFIG_LEGACY_FILE_FORMAT 設定為開啟時，VACUUM 指令會在嘗試處理有產生欄位和遞減索引的表格時，傳回不明確的錯誤而失敗。這不被視為錯誤，因為 SQLite 版本 3.3.0 和更早的版本不支援產生欄位或遞減索引。

SQLITE_DBCONFIG_STMT_SCANSTATUS

SQLITE_DBCONFIG_STMT_SCANSTATUS 選項僅在 SQLITE_ENABLE_STMT_SCANSTATUS 建置中才有用。在這種情況下，它會設定或清除一個旗標，以啟用收集 sqlite3_stmt_scanstatus_v2() 統計資料。若要收集統計資料，必須在準備 SQL 陳述式和執行步驟時，在資料庫控制代碼上設定旗標。旗標預設為設定（啟用統計資料收集）。此選項需要兩個引數：一個整數和一個指向整數的指標。第一個引數為 1、0 或 -1，用於啟用、停用或不變更陳述式掃描狀態選項。如果第二個引數不為 NULL，則在處理第一個引數後，陳述式掃描狀態設定的值會寫入第二個引數所指的整數中。

SQLITE_DBCONFIG_REVERSE_SCANORDER

SQLITE_DBCONFIG_REVERSE_SCANORDER 選項會變更掃描資料表和索引的預設順序，讓掃描從結尾開始朝向開頭進行，而非從開頭開始朝向結尾進行。設定 SQLITE_DBCONFIG_REVERSE_SCANORDER 等同於設定 PRAGMA reverse_unordered_selects。此選項會接收兩個引數，分別為一個整數和一個指向整數的指標。第一個引數為 1、0 或 -1，分別用於啟用、停用或不變更反向掃描順序旗標。如果第二個引數不為 NULL，則會根據第一個引數處理後反向掃描順序旗標是否設定，將 0 或 1 寫入第二個引數所指向的整數。

授權者回傳碼

#define SQLITE_DENY   1   /* Abort the SQL statement with an error */
#define SQLITE_IGNORE 2   /* Don't allow access, but don't generate an error */

授權者回呼函式 必須回傳 SQLITE_OK 或下列兩個常數之一，以向 SQLite 標示動作是否允許。請參閱 授權者文件 以取得更多資訊。

請注意，SQLITE_IGNORE 也會用作 衝突解決模式，由 sqlite3_vtab_on_conflict() 介面回傳。

sqlite3_deserialize() 的旗標

#define SQLITE_DESERIALIZE_FREEONCLOSE 1 /* Call sqlite3_free() on close */
#define SQLITE_DESERIALIZE_RESIZEABLE  2 /* Resize using sqlite3_realloc64() */
#define SQLITE_DESERIALIZE_READONLY    4 /* Database is read-only */

以下是 sqlite3_deserialize(D,S,P,N,M,F) 介面的第 6 個引數 (F 引數) 所允許的值。

SQLITE_DESERIALIZE_FREEONCLOSE 表示 P 引數中的資料庫序列化會保存在從 sqlite3_malloc64() 取得的記憶體中，且 SQLite 應取得此記憶體的所有權，並在完成使用後自動釋放它。沒有此旗標，呼叫者有責任釋放任何動態配置的記憶體。

SQLITE_DESERIALIZE_RESIZEABLE 旗標表示 SQLite 可以使用對 sqlite3_realloc64() 的呼叫來增加資料庫大小。此旗標僅應與 SQLITE_DESERIALIZE_FREEONCLOSE 搭配使用。沒有此旗標，反序列化的資料庫大小無法超過 M 參數指定的位元組數。

SQLITE_DESERIALIZE_READONLY 旗標表示反序列化的資料庫應視為唯讀。

函式旗標

#define SQLITE_DETERMINISTIC    0x000000800
#define SQLITE_DIRECTONLY       0x000080000
#define SQLITE_SUBTYPE          0x000100000
#define SQLITE_INNOCUOUS        0x000200000
#define SQLITE_RESULT_SUBTYPE   0x001000000

這些常數可以與 偏好的文字編碼 以 OR 運算，作為 sqlite3_create_function()、sqlite3_create_function16() 或 sqlite3_create_function_v2() 的第四個參數。

SQLITE_DETERMINISTIC

SQLITE_DETERMINISTIC 旗標表示當輸入參數相同時，新函式總是會提供相同的輸出。例如，abs() 函式 是確定性的，但 randomblob() 則不是。函式必須是確定性的，才能用於特定情況，例如 部分索引 的 WHERE 子句或 產生的欄位。SQLite 也可能透過將確定性函式從內部迴圈中取出，來最佳化這些函式。

SQLITE_DIRECTONLY

SQLITE_DIRECTONLY 旗標表示函式只能從頂層 SQL 呼叫，不能用於 VIEW 或 TRIGGER，也不能用於架構結構，例如 CHECK 約束、DEFAULT 子句、運算式索引、部分索引 或 產生的欄位。

建議對任何具有副作用或可能洩漏敏感資訊的 應用程式定義的 SQL 函式 使用 SQLITE_DIRECTONLY 旗標。這將防止攻擊，其中應用程式被誘騙使用資料庫檔案，而其架構已偷偷修改，以有害的方式呼叫應用程式定義的函式。

有些人說，不論是否與安全性有關，在所有 應用程式定義的 SQL 函式 上設定 SQLITE_DIRECTONLY 都是個好習慣，這麼做可以防止這些函式在資料庫架構中使用，並因此確保資料庫可以使用沒有存取應用程式定義函式的一般工具（例如 CLI）來檢查和修改。

SQLITE_INNOCUOUS

SQLITE_INNOCUOUS 旗標表示即使函式被錯誤使用，也不太會造成問題。一個無害的函式不應該有任何副作用，也不應該依賴其輸入參數以外的任何值。abs() 函式 是無害函式的範例。load_extension() SQL 函式 由於其副作用而並非無害。

SQLITE_INNOCUOUS 類似於 SQLITE_DETERMINISTIC，但並不完全相同。random() 函式 是無害但非確定性函式的範例。

某些高度安全性設定（SQLITE_DBCONFIG_TRUSTED_SCHEMA 和 PRAGMA trusted_schema=OFF）會停用在檢視和觸發器以及架構結構（例如 CHECK 約束、DEFAULT 子句、運算式索引、部分索引 和 已產生欄位）中使用 SQL 函數，除非該函數標記為 SQLITE_INNOCUOUS。大多數內建函數都是無害的。建議開發人員避免對應用程式定義的函數使用 SQLITE_INNOCUOUS 旗標，除非函數經過仔細稽核，且發現沒有潛在的安全不利副作用和資訊外洩。

SQLITE_SUBTYPE

SQLITE_SUBTYPE 旗標會指示 SQLite 函數可能會呼叫 sqlite3_value_subtype() 來檢查其引數的子類型。此旗標指示 SQLite 省略一些可能會中斷 sqlite3_value_subtype() 函數運作的特殊情況最佳化，導致它傳回 0 而不是正確的子類型。呼叫 sqlite3_value_subtype() 的 SQL 函數應具有此屬性。如果省略 SQLITE_SUBTYPE 屬性，則 sqlite3_value_subtype() 的傳回值有時可能是 0，即使函數引數運算式指定了非 0 子類型。

SQLITE_RESULT_SUBTYPE

SQLITE_RESULT_SUBTYPE 旗標用於指示 SQLite，函式可能會呼叫 sqlite3_result_subtype()，以使子類型與其結果關聯。每個呼叫 sqlite3_result_subtype() 的函式都應該有這個屬性。如果沒有，則如果函式用作 表達式索引 中的術語，呼叫 sqlite3_result_subtype() 可能會成為空操作。另一方面，從不呼叫 sqlite3_result_subtype() 的 SQL 函式應避免設定這個屬性，因為這個屬性的目的是停用與子類型不相容的特定最佳化。

衝突解決模式

#define SQLITE_ROLLBACK 1
/* #define SQLITE_IGNORE 2 // Also used by sqlite3_authorizer() callback */
#define SQLITE_FAIL     3
/* #define SQLITE_ABORT 4  // Also an error code */
#define SQLITE_REPLACE  5

這些常數由 sqlite3_vtab_on_conflict() 傳回，以告知 虛擬表格 實作，正在評估的 SQL 陳述式的 ON CONFLICT 模式為何。

請注意，SQLITE_IGNORE 常數也用作 sqlite3_set_authorizer() 回呼的潛在傳回值，而 SQLITE_ABORT 也是 結果代碼。

標準檔案控制操作碼

#define SQLITE_FCNTL_LOCKSTATE               1
#define SQLITE_FCNTL_GET_LOCKPROXYFILE       2
#define SQLITE_FCNTL_SET_LOCKPROXYFILE       3
#define SQLITE_FCNTL_LAST_ERRNO              4
#define SQLITE_FCNTL_SIZE_HINT               5
#define SQLITE_FCNTL_CHUNK_SIZE              6
#define SQLITE_FCNTL_FILE_POINTER            7
#define SQLITE_FCNTL_SYNC_OMITTED            8
#define SQLITE_FCNTL_WIN32_AV_RETRY          9
#define SQLITE_FCNTL_PERSIST_WAL            10
#define SQLITE_FCNTL_OVERWRITE              11
#define SQLITE_FCNTL_VFSNAME                12
#define SQLITE_FCNTL_POWERSAFE_OVERWRITE    13
#define SQLITE_FCNTL_PRAGMA                 14
#define SQLITE_FCNTL_BUSYHANDLER            15
#define SQLITE_FCNTL_TEMPFILENAME           16
#define SQLITE_FCNTL_MMAP_SIZE              18
#define SQLITE_FCNTL_TRACE                  19
#define SQLITE_FCNTL_HAS_MOVED              20
#define SQLITE_FCNTL_SYNC                   21
#define SQLITE_FCNTL_COMMIT_PHASETWO        22
#define SQLITE_FCNTL_WIN32_SET_HANDLE       23
#define SQLITE_FCNTL_WAL_BLOCK              24
#define SQLITE_FCNTL_ZIPVFS                 25
#define SQLITE_FCNTL_RBU                    26
#define SQLITE_FCNTL_VFS_POINTER            27
#define SQLITE_FCNTL_JOURNAL_POINTER        28
#define SQLITE_FCNTL_WIN32_GET_HANDLE       29
#define SQLITE_FCNTL_PDB                    30
#define SQLITE_FCNTL_BEGIN_ATOMIC_WRITE     31
#define SQLITE_FCNTL_COMMIT_ATOMIC_WRITE    32
#define SQLITE_FCNTL_ROLLBACK_ATOMIC_WRITE  33
#define SQLITE_FCNTL_LOCK_TIMEOUT           34
#define SQLITE_FCNTL_DATA_VERSION           35
#define SQLITE_FCNTL_SIZE_LIMIT             36
#define SQLITE_FCNTL_CKPT_DONE              37
#define SQLITE_FCNTL_RESERVE_BYTES          38
#define SQLITE_FCNTL_CKPT_START             39
#define SQLITE_FCNTL_EXTERNAL_READER        40
#define SQLITE_FCNTL_CKSM_FILE              41
#define SQLITE_FCNTL_RESET_CACHE            42

這些整數常數是 sqlite3_io_methods 物件的 xFileControl 方法和 sqlite3_file_control() 介面的操作碼。

• SQLITE_FCNTL_LOCKSTATE 操作碼用於偵錯。這個操作碼會導致 xFileControl 方法將鎖的目前狀態（SQLITE_LOCK_NONE、SQLITE_LOCK_SHARED、SQLITE_LOCK_RESERVED、SQLITE_LOCK_PENDING 或 SQLITE_LOCK_EXCLUSIVE 之一）寫入 pArg 引數所指向的整數。只有在 SQLite 以 SQLITE_DEBUG 編譯時，這個功能才可用。

• SQLITE_FCNTL_SIZE_HINT opcode 由 SQLite 使用，以向 VFS 層提供提示，資料庫檔案在目前的交易期間將成長多大。此提示並非保證準確，但通常接近。基礎的 VFS 可能選擇根據此提示預先配置資料庫檔案空間，以協助寫入資料庫檔案執行得更快。

• SQLITE_FCNTL_SIZE_LIMIT opcode 由實作 sqlite3_deserialize() 的記憶體內 VFS 使用，以設定記憶體內資料庫大小的上限。引數是指向 sqlite3_int64 的指標。如果指標指向的整數為負數，則會填入目前的限制。否則，限制會設定為指標指向的整數值或目前資料庫大小中較大的值。指標指向的整數會設定為新的限制。

• SQLITE_FCNTL_CHUNK_SIZE opcode 用於要求 VFS 以使用者指定的區塊大小延伸和截斷資料庫檔案。sqlite3_file_control() 的第四個引數應指向包含要針對指定的資料庫使用的新的區塊大小的整數 (int 類型)。以大區塊 (例如一次 1MB) 配置資料庫檔案空間，可能會減少檔案系統的碎片化，並改善某些系統的效能。

• SQLITE_FCNTL_FILE_POINTER opcode 用於取得與特定資料庫連線關聯的 sqlite3_file 物件的指標。另請參閱 SQLITE_FCNTL_JOURNAL_POINTER。

• SQLITE_FCNTL_JOURNAL_POINTER opcode 用於取得與特定資料庫連線的記錄檔檔案 (無論是 回滾記錄檔 或 先行寫入記錄檔) 關聯的 sqlite3_file 物件的指標。另請參閱 SQLITE_FCNTL_FILE_POINTER。

• 不再使用。

• SQLITE_FCNTL_SYNC 操作碼是由 SQLite 內部產生，並在 xSync 方法呼叫資料庫檔案描述子之前立即傳送給 VFS。或者，如果未呼叫 xSync 方法，因為使用者已使用 PRAGMA synchronous=OFF 設定 SQLite，它會取代 xSync 方法呼叫。在多數情況下，此檔案控制傳遞的指標引數為 NULL。不過，如果資料庫檔案正在同步為多資料庫提交的一部分，引數會指向包含交易超級日誌檔名的以 Null 結尾的字串。不需要此訊號的 VFS 應靜默略過此操作碼。應用程式不應使用此操作碼呼叫 sqlite3_file_control()，因為這樣可能會中斷需要此操作碼的特殊 VFS 的運作。

• SQLITE_FCNTL_COMMIT_PHASETWO 操作碼是由 SQLite 內部產生，並在交易提交後立即傳送給 VFS，但在資料庫解鎖之前。不需要此訊號的 VFS 應靜默略過此操作碼。應用程式不應使用此操作碼呼叫 sqlite3_file_control()，因為這樣可能會中斷需要此操作碼的特殊 VFS 的運作。

• SQLITE_FCNTL_WIN32_AV_RETRY opcode 用於設定 Windows VFS 中某些磁碟 I/O 作業的自動重試次數和間隔，以在防毒程式存在的情況下提供穩健性。預設情況下，Windows VFS 會對檔案讀取、檔案寫入和檔案刪除作業重試最多 10 次，第一次重試前延遲 25 毫秒，後續每次重試延遲時間再增加 25 毫秒。此 opcode 允許調整這兩個值（10 次重試和 25 毫秒延遲）。這些值會變更為同一個處理程序中所有資料庫連線。引數是指向兩個整數陣列的指標，其中第一個整數是新的重試次數，第二個整數是延遲時間。如果任一個整數為負值，則不會變更設定，但會將該設定的先前值寫入陣列項目，允許查詢目前的重試設定。zDbName 參數會被忽略。

• SQLITE_FCNTL_PERSIST_WAL opcode 用於設定或查詢持續性 預寫式記錄 設定。預設情況下，當與資料庫的最新連線關閉時，會自動刪除用於交易控制的輔助預寫式記錄（WAL 檔案）和共用記憶體檔案。設定持續性 WAL 模式會讓這些檔案在關閉後持續存在。當其他沒有資料庫檔案所在目錄寫入權限的處理程序想要讀取資料庫檔案時，持續檔案很有用，因為資料庫可讀取的前提是 WAL 和共用記憶體檔案必須存在。此 opcode 的 sqlite3_file_control() 第四個參數應該是指向整數的指標。該整數為 0 表示停用持續性 WAL 模式，為 1 表示啟用持續性 WAL 模式。如果整數為 -1，則會以目前的 WAL 持續性設定覆寫它。

• SQLITE_FCNTL_POWERSAFE_OVERWRITE opcode 用於設定或查詢持續性「powersafe-overwrite」或「PSOW」設定。PSOW 設定會決定 SQLITE_IOCAP_POWERSAFE_OVERWRITE 位元組的方法 xDeviceCharacteristics。對於此 opcode，sqlite3_file_control() 的第四個參數應為指向整數的指標。該整數為 0 表示停用零損害模式，或 1 表示啟用零損害模式。如果整數為 -1，則會以目前的零損害模式設定覆寫該整數。

• 在開啟寫入交易後，SQLite 會呼叫 SQLITE_FCNTL_OVERWRITE opcode，以表示除非因為某些原因而回滾，否則整個資料庫檔案將會被目前的交易覆寫。這是 VACUUM 作業所使用的。

• SQLITE_FCNTL_VFSNAME opcode 可用於取得 VFS 堆疊中所有 VFS 的名稱。所有 VFS shim 和最後的底層 VFS 的名稱都會寫入從 sqlite3_malloc() 取得的記憶體中，而結果會儲存在 sqlite3_file_control() 的第四個參數所指向的 char* 變數中。呼叫者負責在完成時釋放記憶體。與所有檔案控制動作一樣，無法保證這實際上會執行任何動作。如果未實作此檔案控制，呼叫者應將 char* 變數初始化為 NULL 指標。此檔案控制僅供診斷使用。

• SQLITE_FCNTL_VFS_POINTER opcode 會尋找目前使用中的頂層 VFS 指標。sqlite3_file_control(db,SQLITE_FCNTL_VFS_POINTER,X) 中的引數 X 必須為類型「sqlite3_vfs **」。此 opcode 會將 *X 設定為指向頂層 VFS 的指標。當堆疊中有多個 VFS shim 時，此 opcode 僅會尋找最上層的 shim。

• Whenever a PRAGMA statement is parsed, an SQLITE_FCNTL_PRAGMA file control is sent to the open sqlite3_file object corresponding to the database file to which the pragma statement refers. The argument to the SQLITE_FCNTL_PRAGMA file control is an array of pointers to strings (char**) in which the second element of the array is the name of the pragma and the third element is the argument to the pragma or NULL if the pragma has no argument. The handler for an SQLITE_FCNTL_PRAGMA file control can optionally make the first element of the char** argument point to a string obtained from sqlite3_mprintf() or the equivalent and that string will become the result of the pragma or the error message if the pragma fails. If the SQLITE_FCNTL_PRAGMA file control returns SQLITE_NOTFOUND, then normal PRAGMA processing continues. If the SQLITE_FCNTL_PRAGMA file control returns SQLITE_OK, then the parser assumes that the VFS has handled the PRAGMA itself and the parser generates a no-op prepared statement if result string is NULL, or that returns a copy of the result string if the string is non-NULL. If the SQLITE_FCNTL_PRAGMA file control returns any result code other than SQLITE_OK or SQLITE_NOTFOUND, that means that the VFS encountered an error while handling the PRAGMA and the compilation of the PRAGMA fails with an error. The SQLITE_FCNTL_PRAGMA file control occurs at the beginning of pragma statement analysis and so it is able to override built-in PRAGMA statements.

• SQLite 在開啟資料庫檔案處理序後不久，可能會在檔案控制中呼叫 SQLITE_FCNTL_BUSYHANDLER，以提供自訂 VFS 存取連線的忙碌處理常式回呼。引數為 (void**) 型別 - 一個包含兩個 (void *) 值的陣列。第一個 (void *) 實際上指向 (int (*)(void *)) 型別的函式。為了呼叫連線的忙碌處理常式，此函式應以陣列中的第二個 (void *) 作為唯一引數呼叫。如果它傳回非零值，則應重試操作。如果它傳回零值，則自訂 VFS 應放棄目前的作業。

• 應用程式可以呼叫 SQLITE_FCNTL_TEMPFILENAME 檔案控制，讓 SQLite 使用與為 TEMP 資料表和其他內部用途產生暫時檔名相同的演算法產生暫時檔名。引數應為 char**，其中會填入從 sqlite3_malloc() 取得的記憶體中寫入的檔名。呼叫者應在結果上呼叫 sqlite3_free()，以避免記憶體外洩。

• SQLITE_FCNTL_MMAP_SIZE 檔案控制用於查詢或設定用於記憶體對映 I/O 的最大位元組數。引數是指向 sqlite3_int64 型別值的指標，該值是檔案中建議的最大記憶體對映位元組數。指標會覆寫為舊值。如果原本指向的值為負值，則不會變更限制，因此可以透過傳入指向負數的指標來查詢目前的限制。此檔案控制在內部用於實作 PRAGMA mmap_size。

• SQLITE_FCNTL_TRACE 檔案控制會提供建議資訊給 VFS，說明 SQLite 堆疊的高階層正在執行什麼。此檔案控制由一些 VFS 活動追蹤 shim 使用。引數為以零終止的字串。如果啟用 SQLITE_USE_FCNTL_TRACE 編譯時期選項，SQLite 堆疊中的高階層可能會產生此檔案控制的執行個體。

• SQLITE_FCNTL_HAS_MOVED 檔案控制將其參數解釋為指標，指向一個整數，並根據檔案自首次開啟後是否已重新命名、移動或刪除，將布林值寫入該整數。

• SQLITE_FCNTL_WIN32_GET_HANDLE opcode 可用於取得與檔案控制代碼關聯的底層原生檔案控制代碼。此檔案控制將其參數解釋為指標，指向原生檔案控制代碼，並將結果值寫入其中。

• SQLITE_FCNTL_WIN32_SET_HANDLE opcode 用於偵錯。此 opcode 會導致 xFileControl 方法將檔案控制代碼與 pArg 參數所指的檔案控制代碼交換。此功能會在測試期間使用，且僅在定義 SQLITE_TEST 時才需要支援。

• SQLITE_FCNTL_WAL_BLOCK 是傳送給 VFS 層的訊號，表示如果鎖定無法立即取得，則在下一道 WAL 鎖定時進行鎖定可能會很有利。WAL 子系統會在罕見的情況下發出此訊號，以解決優先順序反轉的問題。應用程式不應使用此檔案控制。

• SQLITE_FCNTL_ZIPVFS opcode 僅由 zipvfs 實作。所有其他 VFS 都應針對此 opcode 傳回 SQLITE_NOTFOUND。

• SQLITE_FCNTL_RBU opcode 僅由 RBU 擴充功能所使用的特殊 VFS 實作。所有其他 VFS 都應針對此 opcode 傳回 SQLITE_NOTFOUND。

• 如果 SQLITE_FCNTL_BEGIN_ATOMIC_WRITE 操作碼傳回 SQLITE_OK，則檔案描述符會置於「批次寫入模式」，表示所有後續的寫入操作都將延後，並在下次 SQLITE_FCNTL_COMMIT_ATOMIC_WRITE 時以原子方式執行。不支援批次原子寫入的系統會傳回 SQLITE_NOTFOUND。在成功的 SQLITE_FCNTL_BEGIN_ATOMIC_WRITE 之後，且在關閉 SQLITE_FCNTL_COMMIT_ATOMIC_WRITE 或 SQLITE_FCNTL_ROLLBACK_ATOMIC_WRITE 之前，SQLite 對於同一個 sqlite3_file 檔案描述符，不會呼叫任何 VFS 介面，除了呼叫 xWrite 方法和 xFileControl 方法加上 SQLITE_FCNTL_SIZE_HINT。

• SQLITE_FCNTL_COMMIT_ATOMIC_WRITE 操作碼會導致自上次成功呼叫 SQLITE_FCNTL_BEGIN_ATOMIC_WRITE 以來的所有寫入操作以原子方式執行。此檔案控制僅在所有寫入都成功執行且已提交至永久儲存時，才會傳回 SQLITE_OK。不論是否成功，此檔案控制都會讓檔案描述符離開批次寫入模式，讓後續的所有寫入操作都獨立。SQLite 絕不會在未先成功呼叫 SQLITE_FCNTL_BEGIN_ATOMIC_WRITE 的情況下，呼叫 SQLITE_FCNTL_COMMIT_ATOMIC_WRITE。

• SQLITE_FCNTL_ROLLBACK_ATOMIC_WRITE opcode 會導致自上次成功呼叫 SQLITE_FCNTL_BEGIN_ATOMIC_WRITE 以來的所有寫入作業回滾。此檔案控制將檔案描述符從批次寫入模式中移除，以便後續的所有寫入作業獨立進行。在未成功呼叫 SQLITE_FCNTL_BEGIN_ATOMIC_WRITE 之前，SQLite 永遠不會呼叫 SQLITE_FCNTL_ROLLBACK_ATOMIC_WRITE。

• SQLITE_FCNTL_LOCK_TIMEOUT opcode 用於設定 VFS，以便在使用 VFS 的 xLock 或 xShmLock 方法取得檔案鎖定時，在失敗前最多封鎖 M 毫秒。參數是指向 32 位元有號整數的指標，其中包含 M 要設定成的值。在傳回之前，32 位元有號整數會覆寫為 M 的前一個值。

• SQLITE_FCNTL_DATA_VERSION opcode 用於偵測資料庫檔案的變更。引數是指向 32 位元無號整數的指標。分頁器的「資料版本」會寫入指標中。每當對應的資料庫檔案有任何變更時，「資料版本」就會變更，不論是透過同一個資料庫連線上的 SQL 陳述式，還是透過其他程序中不同資料庫連線提交的交易。可以使用 sqlite3_total_changes() 介面來找出連線上的任何資料庫是否已變更，但該介面會回應 TEMP 和 MAIN 上的變更，而且不提供偵測僅 MAIN 變更的機制。此外，sqlite3_total_changes() 介面只會回應內部變更，而忽略其他資料庫連線所做的變更。PRAGMA data_version 指令提供一種機制來偵測單一附加資料庫的變更，這些變更是由其他資料庫連線所造成，但會忽略由呼叫它的資料庫連線所實作的變更。此檔案控制是偵測內部或外部變更，且與特定附加資料庫相關聯的唯一機制。

• SQLITE_FCNTL_CKPT_START opcode 會在 wal 模式的檢查點中呼叫，在用戶端開始從 wal 檔案複製頁面到資料庫檔案之前。

• SQLITE_FCNTL_CKPT_DONE opcode 會在 wal 模式的檢查點中呼叫，在用戶端完成從 wal 檔案複製頁面到資料庫檔案之後，但在 *-shm 檔案更新為記錄頁面已檢查點之前。

• 實驗性的 SQLITE_FCNTL_EXTERNAL_READER opcode 用於偵測在另一個程序中是否有資料庫用戶端在資料庫上開啟了 wal 模式交易。它僅在 unix 上可用。使用此檔案控制傳遞的 (void*) 參數應指向類型為 (int) 的值。如果資料庫是 wal 模式資料庫，且在另一個程序中至少有一個用戶端目前在資料庫上開啟了 SQL 交易，則整數值會設為 1。如果資料庫不是 wal 模式資料庫，或在任何其他程序中都沒有此類連線，則會設為 0。此 opcode 無法用於偵測當前程序中用戶端開啟的交易，只能偵測其他程序中的交易。

• SQLITE_FCNTL_CKSM_FILE opcode 僅供 檢查總和 VFS shim 內部使用。

• 如果目前資料庫上沒有開啟任何交易，且資料庫不是暫存資料庫，則 SQLITE_FCNTL_RESET_CACHE 檔案控制會清除記憶體中頁面快取的內容。如果有開啟的交易，或如果資料庫是暫存資料庫，則此 opcode 會是無作用，而不是錯誤。

虛擬表格約束運算子代碼

#define SQLITE_INDEX_CONSTRAINT_EQ          2
#define SQLITE_INDEX_CONSTRAINT_GT          4
#define SQLITE_INDEX_CONSTRAINT_LE          8
#define SQLITE_INDEX_CONSTRAINT_LT         16
#define SQLITE_INDEX_CONSTRAINT_GE         32
#define SQLITE_INDEX_CONSTRAINT_MATCH      64
#define SQLITE_INDEX_CONSTRAINT_LIKE       65
#define SQLITE_INDEX_CONSTRAINT_GLOB       66
#define SQLITE_INDEX_CONSTRAINT_REGEXP     67
#define SQLITE_INDEX_CONSTRAINT_NE         68
#define SQLITE_INDEX_CONSTRAINT_ISNOT      69
#define SQLITE_INDEX_CONSTRAINT_ISNOTNULL  70
#define SQLITE_INDEX_CONSTRAINT_ISNULL     71
#define SQLITE_INDEX_CONSTRAINT_IS         72
#define SQLITE_INDEX_CONSTRAINT_LIMIT      73
#define SQLITE_INDEX_CONSTRAINT_OFFSET     74
#define SQLITE_INDEX_CONSTRAINT_FUNCTION  150

這些巨集定義 sqlite3_index_info.aConstraint[].op 欄位的允許值。每個值都代表一個運算子，該運算子是使用 虛擬表格 的查詢 WHERE 子句中約束項目的其中一部分。

運算子的左運算元由對應的 aConstraint[].iColumn 欄位給出。-1 的 iColumn 表示左運算元是 rowid。SQLITE_INDEX_CONSTRAINT_LIMIT 和 SQLITE_INDEX_CONSTRAINT_OFFSET 運算子沒有左運算元，因此對於這些運算子，對應的 aConstraint[].iColumn 沒有意義，不應使用。

從 SQLITE_INDEX_CONSTRAINT_FUNCTION 到值 255 的所有運算子值都保留為表示由虛擬表格實作的 xFindFunction 方法 超載的函數。

每個約束的右手運算元可以使用 sqlite3_vtab_rhs_value() 介面存取。通常，右手運算元只有在輸入 SQL 中顯示為單一常數文字時才會可用。如果右手運算元是另一個欄位、表達式（甚至是常數表達式）或參數，則 sqlite3_vtab_rhs_value() 可能無法提取它。SQLITE_INDEX_CONSTRAINT_ISNULL 和 SQLITE_INDEX_CONSTRAINT_ISNOTNULL 算子沒有右手運算元，因此對這些算子呼叫 sqlite3_vtab_rhs_value() 永遠會傳回 SQLITE_NOTFOUND。

可使用 sqlite3_vtab_collation() 介面找到用於比較的排序規則。對於大多數實際的虛擬表格，約束的排序規則並不重要（例如，因為約束是數字），因此通常不需要 sqlite3_vtab_collation() 介面。

裝置特徵

#define SQLITE_IOCAP_ATOMIC                 0x00000001
#define SQLITE_IOCAP_ATOMIC512              0x00000002
#define SQLITE_IOCAP_ATOMIC1K               0x00000004
#define SQLITE_IOCAP_ATOMIC2K               0x00000008
#define SQLITE_IOCAP_ATOMIC4K               0x00000010
#define SQLITE_IOCAP_ATOMIC8K               0x00000020
#define SQLITE_IOCAP_ATOMIC16K              0x00000040
#define SQLITE_IOCAP_ATOMIC32K              0x00000080
#define SQLITE_IOCAP_ATOMIC64K              0x00000100
#define SQLITE_IOCAP_SAFE_APPEND            0x00000200
#define SQLITE_IOCAP_SEQUENTIAL             0x00000400
#define SQLITE_IOCAP_UNDELETABLE_WHEN_OPEN  0x00000800
#define SQLITE_IOCAP_POWERSAFE_OVERWRITE    0x00001000
#define SQLITE_IOCAP_IMMUTABLE              0x00002000
#define SQLITE_IOCAP_BATCH_ATOMIC           0x00004000

sqlite3_io_methods 物件的 xDeviceCharacteristics 方法傳回一個整數，它是這些位元值的一個向量，表示 sqlite3_io_methods 所指檔案的大量儲存裝置的 I/O 特徵。

SQLITE_IOCAP_ATOMIC 屬性表示任何大小的寫入都是原子的。SQLITE_IOCAP_ATOMICnnn 值表示大小為 nnn 位元組且與位址對齊（位址為 nnn 的整數倍數）的區塊寫入是原子的。SQLITE_IOCAP_SAFE_APPEND 值表示當資料附加到檔案時，會先附加資料，然後再延伸檔案大小，絕不會相反。SQLITE_IOCAP_SEQUENTIAL 屬性表示資訊會按照 xWrite() 的呼叫順序寫入磁碟。SQLITE_IOCAP_POWERSAFE_OVERWRITE 屬性表示在崩潰或斷電後重新開機，檔案中唯一可能變更的位元組是應用程式層級寫入的位元組，而相鄰的位元組（甚至同一個區段中的位元組）保證不會變更。SQLITE_IOCAP_UNDELETABLE_WHEN_OPEN 旗標表示檔案在開啟時無法刪除。SQLITE_IOCAP_IMMUTABLE 旗標表示檔案位於唯讀媒體上，即使是具有提升權限的程序也無法變更。

SQLITE_IOCAP_BATCH_ATOMIC 屬性表示基礎檔案系統支援在 SQLITE_FCNTL_BEGIN_ATOMIC_WRITE 和 SQLITE_FCNTL_COMMIT_ATOMIC_WRITE 將多個寫入作業括起來時，以原子方式執行這些寫入作業。

檔案鎖定層級

#define SQLITE_LOCK_NONE          0       /* xUnlock() only */
#define SQLITE_LOCK_SHARED        1       /* xLock() or xUnlock() */
#define SQLITE_LOCK_RESERVED      2       /* xLock() only */
#define SQLITE_LOCK_PENDING       3       /* xLock() only */
#define SQLITE_LOCK_EXCLUSIVE     4       /* xLock() only */

SQLite 會使用其中一個整數值作為第二個引數，呼叫 sqlite3_io_methods 物件的 xLock() 和 xUnlock() 方法。這些值從限制最少到限制最多排序。

xLock() 的引數永遠是 SHARED 或更高。xUnlock 的引數是 SHARED 或 NONE。

Mutex 類型

#define SQLITE_MUTEX_FAST             0
#define SQLITE_MUTEX_RECURSIVE        1
#define SQLITE_MUTEX_STATIC_MAIN      2
#define SQLITE_MUTEX_STATIC_MEM       3  /* sqlite3_malloc() */
#define SQLITE_MUTEX_STATIC_MEM2      4  /* NOT USED */
#define SQLITE_MUTEX_STATIC_OPEN      4  /* sqlite3BtreeOpen() */
#define SQLITE_MUTEX_STATIC_PRNG      5  /* sqlite3_randomness() */
#define SQLITE_MUTEX_STATIC_LRU       6  /* lru page list */
#define SQLITE_MUTEX_STATIC_LRU2      7  /* NOT USED */
#define SQLITE_MUTEX_STATIC_PMEM      7  /* sqlite3PageMalloc() */
#define SQLITE_MUTEX_STATIC_APP1      8  /* For use by application */
#define SQLITE_MUTEX_STATIC_APP2      9  /* For use by application */
#define SQLITE_MUTEX_STATIC_APP3     10  /* For use by application */
#define SQLITE_MUTEX_STATIC_VFS1     11  /* For use by built-in VFS */
#define SQLITE_MUTEX_STATIC_VFS2     12  /* For use by extension VFS */
#define SQLITE_MUTEX_STATIC_VFS3     13  /* For use by application VFS */

sqlite3_mutex_alloc() 介面會接收一個單一引數，這個引數是下列整數常數之一。

靜態互斥鎖的集合可能會在不同的 SQLite 版本中有所變更。覆寫內建互斥鎖邏輯的應用程式必須做好因應其他靜態互斥鎖的準備。

檔案開啟操作的旗標

#define SQLITE_OPEN_READONLY         0x00000001  /* Ok for sqlite3_open_v2() */
#define SQLITE_OPEN_READWRITE        0x00000002  /* Ok for sqlite3_open_v2() */
#define SQLITE_OPEN_CREATE           0x00000004  /* Ok for sqlite3_open_v2() */
#define SQLITE_OPEN_DELETEONCLOSE    0x00000008  /* VFS only */
#define SQLITE_OPEN_EXCLUSIVE        0x00000010  /* VFS only */
#define SQLITE_OPEN_AUTOPROXY        0x00000020  /* VFS only */
#define SQLITE_OPEN_URI              0x00000040  /* Ok for sqlite3_open_v2() */
#define SQLITE_OPEN_MEMORY           0x00000080  /* Ok for sqlite3_open_v2() */
#define SQLITE_OPEN_MAIN_DB          0x00000100  /* VFS only */
#define SQLITE_OPEN_TEMP_DB          0x00000200  /* VFS only */
#define SQLITE_OPEN_TRANSIENT_DB     0x00000400  /* VFS only */
#define SQLITE_OPEN_MAIN_JOURNAL     0x00000800  /* VFS only */
#define SQLITE_OPEN_TEMP_JOURNAL     0x00001000  /* VFS only */
#define SQLITE_OPEN_SUBJOURNAL       0x00002000  /* VFS only */
#define SQLITE_OPEN_SUPER_JOURNAL    0x00004000  /* VFS only */
#define SQLITE_OPEN_NOMUTEX          0x00008000  /* Ok for sqlite3_open_v2() */
#define SQLITE_OPEN_FULLMUTEX        0x00010000  /* Ok for sqlite3_open_v2() */
#define SQLITE_OPEN_SHAREDCACHE      0x00020000  /* Ok for sqlite3_open_v2() */
#define SQLITE_OPEN_PRIVATECACHE     0x00040000  /* Ok for sqlite3_open_v2() */
#define SQLITE_OPEN_WAL              0x00080000  /* VFS only */
#define SQLITE_OPEN_NOFOLLOW         0x01000000  /* Ok for sqlite3_open_v2() */
#define SQLITE_OPEN_EXRESCODE        0x02000000  /* Extended result codes */

這些位元值預計會用於 sqlite3_open_v2() 介面的第 3 個參數，以及 sqlite3_vfs.xOpen 方法的第 4 個參數。

只有標記為「適用於 sqlite3_open_v2()」的旗標才能用作 sqlite3_open_v2() 介面的第三個參數。其他旗標在過去一直被 sqlite3_open_v2() 忽略，不過未來的 SQLite 版本可能會有所變更，導致傳遞任何不允許的位元給 sqlite3_open_v2() 時會產生錯誤。應用程式不應依賴過去的行為。

特別注意，將 SQLITE_OPEN_EXCLUSIVE 旗標傳遞給 sqlite3_open_v2() *並不會* 導致底層資料庫檔案使用 O_EXCL 開啟。過去將 SQLITE_OPEN_EXCLUSIVE 傳遞給 sqlite3_open_v2() 一直都是無效操作，而且在未來的 SQLite 版本中可能會變成錯誤。

準備旗標

#define SQLITE_PREPARE_PERSISTENT              0x01
#define SQLITE_PREPARE_NORMALIZE               0x02
#define SQLITE_PREPARE_NO_VTAB                 0x04

這些常數定義了各種旗標，可以傳遞給 sqlite3_prepare_v3() 和 sqlite3_prepare16_v3() 介面的「prepFlags」參數。

在未來的 SQLite 版本中可能會新增新的旗標。

SQLITE_PREPARE_PERSISTENT

SQLITE_PREPARE_PERSISTENT 旗標是提示查詢規劃器，已準備好的陳述式會保留很長一段時間，而且可能會重複使用很多次。沒有這個旗標，sqlite3_prepare_v3() 和 sqlite3_prepare16_v3() 會假設已準備好的陳述式只會使用一次，或最多使用幾次，然後很快就會使用 sqlite3_finalize() 銷毀。目前的實作會透過避免使用 lookaside 記憶體 來處理這個提示，以免耗盡有限的 lookaside 記憶體儲存。未來的 SQLite 版本可能會以不同的方式處理這個提示。

SQLITE_PREPARE_NORMALIZE

SQLITE_PREPARE_NORMALIZE 旗標不會執行任何操作。任何想要使用 sqlite3_normalized_sql() 介面的準備陳述式過去都需要這個旗標。不過，sqlite3_normalized_sql() 介面現在對所有準備陳述式都可用，不論它們是否使用這個旗標。

SQLITE_PREPARE_NO_VTAB

SQLITE_PREPARE_NO_VTAB 旗標會讓 SQL 編譯器在陳述式使用任何虛擬表格時傳回錯誤 (錯誤代碼 SQLITE_ERROR)。

準備陳述式掃描狀態

#define SQLITE_SCANSTAT_COMPLEX 0x0001

準備陳述式掃描狀態操作碼

#define SQLITE_SCANSTAT_NLOOP    0
#define SQLITE_SCANSTAT_NVISIT   1
#define SQLITE_SCANSTAT_EST      2
#define SQLITE_SCANSTAT_NAME     3
#define SQLITE_SCANSTAT_EXPLAIN  4
#define SQLITE_SCANSTAT_SELECTID 5
#define SQLITE_SCANSTAT_PARENTID 6
#define SQLITE_SCANSTAT_NCYCLE   7

下列常數可用於 sqlite3_stmt_scanstatus(S,X,T,V) 介面的 T 參數。每個常數指定 sqlite3_stmt_scanstatus() 要傳回的不同指標。

當傳回 V 的值為字串時，儲存該字串的空間由準備陳述式 S 管理，且會在 S 完成時自動釋放。

並非所有值都可用於所有查詢元素。當值不可用時，如果值是數字，輸出變數會設為 -1；如果是字串 (SQLITE_SCANSTAT_NAME)，則會設為 NULL。

SQLITE_SCANSTAT_NLOOP

sqlite3_int64 變數由 V 參數指向，會設為第 X 個迴圈執行的總次數。

SQLITE_SCANSTAT_NVISIT

sqlite3_int64 變數由 V 參數指向，會設為第 X 個迴圈的所有反覆運算所檢查的總列數。

SQLITE_SCANSTAT_EST

「double」變數由 V 參數指向，會設為查詢規劃器估計第 X 個迴圈每次反覆運算輸出的平均列數。如果查詢規劃器的估計準確，這個值會近似於 NVISIT/NLOOP，且這個值與所有先前迴圈 (SELECTID 相同) 的乘積會是目前迴圈的 NLOOP 值。

SQLITE_SCANSTAT_NAME

「const char *」變數由 V 參數指向，會設為零終止 UTF-8 字串，包含用於第 X 個迴圈的索引或表格名稱。

SQLITE_SCANSTAT_EXPLAIN

V 參數所指向的「const char *」變數會設定為包含 X 第 n 個迴圈的 EXPLAIN QUERY PLAN 說明的零終止 UTF-8 字串。

SQLITE_SCANSTAT_SELECTID

V 參數所指向的「int」變數會設定為 X 第 n 個查詢計畫元素的 id。id 值在陳述式中是唯一的。select-id 與 EXPLAIN QUERY PLAN 查詢第一欄中輸出的值相同。

SQLITE_SCANSTAT_PARENTID

V 參數所指向的「int」變數會設定為目前查詢元素父項目的 id（如果適用），或如果查詢元素沒有父項目，則設定為零。這與 EXPLAIN QUERY PLAN 查詢第二欄中傳回的值相同。

SQLITE_SCANSTAT_NCYCLE

sqlite3_int64 輸出值會設定為處理查詢元素時經過的週期數，根據處理器時間戳記計數器。並非所有查詢元素都有這個值 - 如果沒有這個值，輸出變數會設定為 -1。

xShmLock VFS 方法的旗標

#define SQLITE_SHM_UNLOCK       1
#define SQLITE_SHM_LOCK         2
#define SQLITE_SHM_SHARED       4
#define SQLITE_SHM_EXCLUSIVE    8

這些整數常數定義 sqlite3_io_methods 的 xShmLock 方法允許的各種鎖定操作。以下是 xShmLock 方法唯一合法的旗標組合

• SQLITE_SHM_LOCK | SQLITE_SHM_SHARED
• SQLITE_SHM_LOCK | SQLITE_SHM_EXCLUSIVE
• SQLITE_SHM_UNLOCK | SQLITE_SHM_SHARED
• SQLITE_SHM_UNLOCK | SQLITE_SHM_EXCLUSIVE

解鎖時，必須提供與對應鎖定相同的 SHARED 或 EXCLUSIVE 旗標。

xShmLock 方法可以在未鎖定和 SHARED 之間，或在未鎖定和 EXCLUSIVE 之間轉換。它無法在 SHARED 和 EXCLUSIVE 之間轉換。

編譯時期函式庫版本號碼

#define SQLITE_VERSION        "3.45.2"
#define SQLITE_VERSION_NUMBER 3045002
#define SQLITE_SOURCE_ID      "2024-03-12 11:06:23 d8cd6d49b46a395b13955387d05e9e1a2a47e54fb99f3c9b59835bbefad6af77"

sqlite3.h 標頭中的 SQLITE_VERSION C 預處理器巨集會評估為字串文字，其為 SQLite 版本，格式為「X.Y.Z」，其中 X 為主要版本號碼（對於 SQLite3 而言永遠為 3），Y 為次要版本號碼，而 Z 為發行版本號碼。 SQLITE_VERSION_NUMBER C 預處理器巨集會解析為整數，其值為 (X*1000000 + Y*1000 + Z)，其中 X、Y 和 Z 為 SQLITE_VERSION 中使用的相同數字。任何特定 SQLite 發行版本的 SQLITE_VERSION_NUMBER 也會大於其衍生的發行版本。Y 將保持不變，而 Z 將會遞增，或者 Y 將會遞增，而 Z 將會重設為零。

自 3.6.18 版本（2009-09-11）起，SQLite 原始碼已儲存在 Fossil 組態管理系統 中。SQLITE_SOURCE_ID 巨集會評估為字串，其識別 SQLite 在其組態管理系統中的特定簽入。SQLITE_SOURCE_ID 字串包含簽入的日期和時間（UTC）以及整個原始碼樹的 SHA1 或 SHA3-256 哈希。如果原始碼自上次簽入後以任何方式編輯，則哈希的最後四個十六進位數字可能會被修改。

另請參閱：sqlite3_libversion()、sqlite3_libversion_number()、sqlite3_sourceid()、sqlite_version() 和 sqlite_source_id()。

定義特殊解構函式行為的常數

typedef void (*sqlite3_destructor_type)(void*);
#define SQLITE_STATIC      ((sqlite3_destructor_type)0)
#define SQLITE_TRANSIENT   ((sqlite3_destructor_type)-1)

這些是傳遞給 sqlite3_result_blob() 等常式的最後一個引數的解構函式的特殊值。如果解構函式引數為 SQLITE_STATIC，表示內容指標為常數，且永遠不會改變。它不需要被銷毀。SQLITE_TRANSIENT 值表示內容可能會在不久的將來改變，且 SQLite 應該在傳回之前建立自己的內容私人副本。

typedef 是為了解決特定 C++ 編譯器中的問題而必要的。

狀態參數

#define SQLITE_STATUS_MEMORY_USED          0
#define SQLITE_STATUS_PAGECACHE_USED       1
#define SQLITE_STATUS_PAGECACHE_OVERFLOW   2
#define SQLITE_STATUS_SCRATCH_USED         3  /* NOT USED */
#define SQLITE_STATUS_SCRATCH_OVERFLOW     4  /* NOT USED */
#define SQLITE_STATUS_MALLOC_SIZE          5
#define SQLITE_STATUS_PARSER_STACK         6
#define SQLITE_STATUS_PAGECACHE_SIZE       7
#define SQLITE_STATUS_SCRATCH_SIZE         8  /* NOT USED */
#define SQLITE_STATUS_MALLOC_COUNT         9

這些整數常數指定各種執行時間狀態參數，可由 sqlite3_status() 傳回。

SQLITE_STATUS_MEMORY_USED

此參數是目前使用 sqlite3_malloc() 簽出的記憶體量，直接或間接。此數字包含應用程式對 sqlite3_malloc() 的呼叫，以及 SQLite 函式庫的內部記憶體使用量。由 SQLITE_CONFIG_PAGECACHE 控制的輔助頁快取記憶體未包含在此參數中。傳回的量是 sqlite3_mem_methods 中的 xSize 方法所報告的配置大小總和。

SQLITE_STATUS_MALLOC_SIZE

此參數記錄傳遞給 sqlite3_malloc() 或 sqlite3_realloc()（或其內部等效項）的最大記憶體配置請求。只有傳回給 sqlite3_status() 的 *pHighwater 參數中的值是有意義的。寫入 *pCurrent 參數中的值未定義。

SQLITE_STATUS_MALLOC_COUNT

此參數記錄目前簽出的個別記憶體配置數目。

SQLITE_STATUS_PAGECACHE_USED

此參數傳回使用 頁快取記憶體配置器（已使用 SQLITE_CONFIG_PAGECACHE 設定）的頁面數目。傳回的值以頁面為單位，而非位元組。

SQLITE_STATUS_PAGECACHE_OVERFLOW

此參數傳回 SQLITE_CONFIG_PAGECACHE 緩衝區無法滿足的頁快取配置位元組數目，以及被迫溢位到 sqlite3_malloc() 的位元組數目。傳回的值包含溢位的配置，因為它們太大（大於 SQLITE_CONFIG_PAGECACHE 的「sz」參數），以及因為頁快取中沒有剩餘空間而溢位的配置。

SQLITE_STATUS_PAGECACHE_SIZE

此參數記錄傳遞給 頁快取記憶體配置器 的最大記憶體配置請求。只有傳回給 sqlite3_status() 的 *pHighwater 參數中的值是有意義的。寫入 *pCurrent 參數中的值未定義。

SQLITE_STATUS_SCRATCH_USED

不再使用。

SQLITE_STATUS_SCRATCH_OVERFLOW

不再使用。

SQLITE_STATUS_SCRATCH_SIZE

不再使用。

SQLITE_STATUS_PARSER_STACK

*pHighwater 參數記錄最深的剖析器堆疊。*pCurrent 值未定義。*pHighwater 值僅在 SQLite 編譯時使用 YYTRACKMAXSTACKDEPTH 時才有意義。

新的狀態參數可能會不時新增。

同步類型旗標

#define SQLITE_SYNC_NORMAL        0x00002
#define SQLITE_SYNC_FULL          0x00003
#define SQLITE_SYNC_DATAONLY      0x00010

當 SQLite 呼叫 sqlite3_io_methods 物件的 xSync() 方法時，它會使用這些整數值的組合作為第二個引數。

當使用 SQLITE_SYNC_DATAONLY 旗標時，表示同步作業只需要將資料沖至大量儲存裝置。不需要沖 inode 資訊。如果旗標的低四位元等於 SQLITE_SYNC_NORMAL，表示使用正常的 fsync() 語意。如果低四位元等於 SQLITE_SYNC_FULL，表示使用 Mac OS X 風格的 fullsync，而非 fsync()。

不要將 SQLITE_SYNC_NORMAL 和 SQLITE_SYNC_FULL 旗標與 PRAGMA synchronous=NORMAL 和 PRAGMA synchronous=FULL 設定混淆。synchronous pragma 決定何時呼叫 xSync VFS 方法，並一致套用於所有平台。SQLITE_SYNC_NORMAL 和 SQLITE_SYNC_FULL 旗標決定同步作業的積極、嚴謹或強而有力程度，並且只會在 Mac OSX 上對預設的 SQLite 程式碼產生影響。（第三方 VFS 實作也可能區分 SQLITE_SYNC_NORMAL 和 SQLITE_SYNC_FULL，但在 SQLite 原生支援的操作系統中，只有 Mac OSX 在乎兩者的差異。）

測試介面作業碼

#define SQLITE_TESTCTRL_FIRST                    5
#define SQLITE_TESTCTRL_PRNG_SAVE                5
#define SQLITE_TESTCTRL_PRNG_RESTORE             6
#define SQLITE_TESTCTRL_PRNG_RESET               7  /* NOT USED */
#define SQLITE_TESTCTRL_FK_NO_ACTION             7
#define SQLITE_TESTCTRL_BITVEC_TEST              8
#define SQLITE_TESTCTRL_FAULT_INSTALL            9
#define SQLITE_TESTCTRL_BENIGN_MALLOC_HOOKS     10
#define SQLITE_TESTCTRL_PENDING_BYTE            11
#define SQLITE_TESTCTRL_ASSERT                  12
#define SQLITE_TESTCTRL_ALWAYS                  13
#define SQLITE_TESTCTRL_RESERVE                 14  /* NOT USED */
#define SQLITE_TESTCTRL_JSON_SELFCHECK          14
#define SQLITE_TESTCTRL_OPTIMIZATIONS           15
#define SQLITE_TESTCTRL_ISKEYWORD               16  /* NOT USED */
#define SQLITE_TESTCTRL_SCRATCHMALLOC           17  /* NOT USED */
#define SQLITE_TESTCTRL_INTERNAL_FUNCTIONS      17
#define SQLITE_TESTCTRL_LOCALTIME_FAULT         18
#define SQLITE_TESTCTRL_EXPLAIN_STMT            19  /* NOT USED */
#define SQLITE_TESTCTRL_ONCE_RESET_THRESHOLD    19
#define SQLITE_TESTCTRL_NEVER_CORRUPT           20
#define SQLITE_TESTCTRL_VDBE_COVERAGE           21
#define SQLITE_TESTCTRL_BYTEORDER               22
#define SQLITE_TESTCTRL_ISINIT                  23
#define SQLITE_TESTCTRL_SORTER_MMAP             24
#define SQLITE_TESTCTRL_IMPOSTER                25
#define SQLITE_TESTCTRL_PARSER_COVERAGE         26
#define SQLITE_TESTCTRL_RESULT_INTREAL          27
#define SQLITE_TESTCTRL_PRNG_SEED               28
#define SQLITE_TESTCTRL_EXTRA_SCHEMA_CHECKS     29
#define SQLITE_TESTCTRL_SEEK_COUNT              30
#define SQLITE_TESTCTRL_TRACEFLAGS              31
#define SQLITE_TESTCTRL_TUNE                    32
#define SQLITE_TESTCTRL_LOGEST                  33
#define SQLITE_TESTCTRL_USELONGDOUBLE           34
#define SQLITE_TESTCTRL_LAST                    34  /* Largest TESTCTRL */

這些常數是作為 sqlite3_test_control() 的第一個引數使用的有效作業碼參數。

這些參數及其含義如有變更，恕不另行通知。這些值僅供測試使用。應用程式不應使用任何這些參數或 sqlite3_test_control() 介面。

SQL 追蹤事件代碼

#define SQLITE_TRACE_STMT       0x01
#define SQLITE_TRACE_PROFILE    0x02
#define SQLITE_TRACE_ROW        0x04
#define SQLITE_TRACE_CLOSE      0x08

這些常數識別可使用 sqlite3_trace_v2() 追蹤邏輯監控的事件類別。傳遞給 sqlite3_trace_v2(D,M,X,P) 的 M 引數是下列一個或多個常數的 OR 組合。傳遞給追蹤回呼的第一個引數是下列常數之一。

未來版本可能會新增追蹤常數。

追蹤回呼有四個引數：xCallback(T,C,P,X)。T 引數是上述整數型別代碼之一。C 引數是傳遞給 sqlite3_trace_v2() 的第四個引數的內容指標副本。P 和 X 引數是指標，其含義取決於 T。

SQLITE_TRACE_STMT

當準備好的陳述式開始執行時，以及在準備好的陳述式執行期間的其他時間（例如在每個觸發器子程式開始時），會呼叫 SQLITE_TRACE_STMT 回呼。P 引數是指向 準備好的陳述式 的指標。X 引數是指向字串的指標，該字串是準備好的陳述式的未展開 SQL 文字，或表示觸發器呼叫的 SQL 註解。當 X 以「--」開頭時，回呼可以使用 X 引數計算舊版 sqlite3_trace() 介面會傳回的相同文字，否則呼叫 sqlite3_expanded_sql(P)。

SQLITE_TRACE_PROFILE

SQLITE_TRACE_PROFILE 回呼提供與 sqlite3_profile() 回呼提供的資訊大致相同。P 引數是指向 準備好的陳述式 的指標，而 X 引數指向 64 位元整數，該整數約等於準備好的陳述式執行的奈秒數。SQLITE_TRACE_PROFILE 回呼會在陳述式完成時呼叫。

SQLITE_TRACE_ROW

當準備好的陳述式產生單一結果列時，會呼叫 SQLITE_TRACE_ROW 回呼。P 參數是指向 準備好陳述式 的指標，而 X 參數未使用。

SQLITE_TRACE_CLOSE

當資料庫連線關閉時，會呼叫 SQLITE_TRACE_CLOSE 回呼。P 參數是指向 資料庫連線 物件的指標，而 X 參數未使用。

sqlite3_txn_state() 允許的回傳值

#define SQLITE_TXN_NONE  0
#define SQLITE_TXN_READ  1
#define SQLITE_TXN_WRITE 2

這些常數定義資料庫檔案的目前交易狀態。 sqlite3_txn_state(D,S) 介面會回傳這些常數之一，以描述 資料庫連線 D 中架構 S 的交易狀態。

SQLITE_TXN_NONE

SQLITE_TXN_NONE 狀態表示目前沒有任何交易待處理。

SQLITE_TXN_READ

SQLITE_TXN_READ 狀態表示資料庫目前處於讀取交易中。已從資料庫檔案讀取內容，但資料庫檔案中的內容並未變更。如果發生任何變更且沒有其他衝突的並行寫入交易，則交易狀態將進階至 SQLITE_TXN_WRITE。在 ROLLBACK 或 COMMIT 之後，交易狀態將回復至 SQLITE_TXN_NONE。

SQLITE_TXN_WRITE

SQLITE_TXN_WRITE 狀態表示資料庫目前處於寫入交易中。已將內容寫入資料庫檔案，但尚未提交。交易狀態將在下一個 ROLLBACK 或 COMMIT 時變更為 SQLITE_TXN_NONE。

---

虛擬表格組態選項

#define SQLITE_VTAB_CONSTRAINT_SUPPORT 1
#define SQLITE_VTAB_INNOCUOUS          2
#define SQLITE_VTAB_DIRECTONLY         3
#define SQLITE_VTAB_USES_ALL_SCHEMAS   4

這些巨集定義 sqlite3_vtab_config() 介面的各種選項，虛擬表格 實作可以使用這些選項來自訂和最佳化其行為。

SQLITE_VTAB_CONSTRAINT_SUPPORT

支援 sqlite3_vtab_config(db,SQLITE_VTAB_CONSTRAINT_SUPPORT,X) 形式的呼叫，其中 X 為整數。如果 X 為零，則呼叫 sqlite3_vtab_config() 的 虛擬表格（其 xCreate 或 xConnect 方法呼叫）不支援約束。在此組態（這是預設值）中，如果呼叫 xUpdate 方法回傳 SQLITE_CONSTRAINT，則整個陳述式會回復，就像使用者 SQL 陳述式中指定 OR ABORT 一樣，而不論實際指定的 ON CONFLICT 模式為何。

如果 X 非零，則虛擬表格實作保證，如果 xUpdate 傳回 SQLITE_CONSTRAINT，它會在對內部或持續資料結構進行任何修改之前執行。如果 ON CONFLICT 模式為 ABORT、FAIL、IGNORE 或 ROLLBACK，SQLite 能夠回滾陳述式或資料庫交易，並放棄或繼續處理目前的 SQL 陳述式（視情況而定）。如果 ON CONFLICT 模式為 REPLACE，且 xUpdate 方法傳回 SQLITE_CONSTRAINT，SQLite 會處理它，就像 ON CONFLICT 模式為 ABORT 一樣。

必須處理 OR REPLACE 的虛擬表格實作必須在 xUpdate 方法中執行。如果呼叫 sqlite3_vtab_on_conflict() 函式指出目前的 ON CONFLICT 政策為 REPLACE，虛擬表格實作應在 xUpdate 回呼中靜默取代適當列並傳回 SQLITE_OK。或者，如果無法執行，它可以傳回 SQLITE_CONSTRAINT，在這種情況下，SQLite 會回歸 OR ABORT 約束處理。

SQLITE_VTAB_DIRECTONLY

在 虛擬表格 實作的 xConnect 或 xCreate 方法中，呼叫 sqlite3_vtab_config(db,SQLITE_VTAB_DIRECTONLY) 的形式禁止從觸發器和檢視中使用該虛擬表格。

SQLITE_VTAB_INNOCUOUS

在 虛擬表格 實作的 xConnect 或 xCreate 方法中呼叫 sqlite3_vtab_config(db,SQLITE_VTAB_INNOCUOUS) 表明該虛擬表格在觸發器和檢視中使用時是安全的。概念上，SQLITE_VTAB_INNOCUOUS 標籤表示即使虛擬表格受到惡意駭客控制，它也不會造成嚴重損害。開發人員應避免設定 SQLITE_VTAB_INNOCUOUS 旗標，除非絕對必要。

SQLITE_VTAB_USES_ALL_SCHEMAS

在 虛擬表格 實作的 xConnect 或 xCreate 方法中呼叫 sqlite3_vtab_config(db,SQLITE_VTAB_USES_ALL_SCHEMA) 指示查詢規劃器在使用虛擬表格時，至少在所有架構（「main」、「temp」和任何 ATTACH 的資料庫）上開始讀取交易。

---

Win32 目錄類型

#define SQLITE_WIN32_DATA_DIRECTORY_TYPE  1
#define SQLITE_WIN32_TEMP_DIRECTORY_TYPE  2

這些巨集僅在 Windows 上可用。它們定義 sqlite3_win32_set_directory 介面的型別參數的允許值。

---

執行時間限制類別

#define SQLITE_LIMIT_LENGTH                    0
#define SQLITE_LIMIT_SQL_LENGTH                1
#define SQLITE_LIMIT_COLUMN                    2
#define SQLITE_LIMIT_EXPR_DEPTH                3
#define SQLITE_LIMIT_COMPOUND_SELECT           4
#define SQLITE_LIMIT_VDBE_OP                   5
#define SQLITE_LIMIT_FUNCTION_ARG              6
#define SQLITE_LIMIT_ATTACHED                  7
#define SQLITE_LIMIT_LIKE_PATTERN_LENGTH       8
#define SQLITE_LIMIT_VARIABLE_NUMBER           9
#define SQLITE_LIMIT_TRIGGER_DEPTH            10
#define SQLITE_LIMIT_WORKER_THREADS           11

這些常數定義可以使用 sqlite3_limit() 在執行時間降低的各種效能限制。各種限制的意義摘要如下所示。可以在 SQLite 中的限制 找到更多資訊。

SQLITE_LIMIT_LENGTH

任何字串或 BLOB 或表格列的最大大小（以位元組為單位）。

SQLITE_LIMIT_SQL_LENGTH

SQL 陳述的最大長度（以位元組為單位）。

SQLITE_LIMIT_COLUMN

表格定義或 SELECT 結果集中欄位的最大數目，或索引或 ORDER BY 或 GROUP BY 子句中欄位的最大數目。

SQLITE_LIMIT_EXPR_DEPTH

任何表達式的解析樹的最大深度。

SQLITE_LIMIT_COMPOUND_SELECT

複合 SELECT 陳述中項目的最大數目。

SQLITE_LIMIT_VDBE_OP

用於實作 SQL 陳述的虛擬機器程式中指令的最大數目。如果 sqlite3_prepare_v2() 或等效程式嘗試在單一已準備陳述中為超過這個數目的操作碼分配空間，則會傳回 SQLITE_NOMEM 錯誤。

SQLITE_LIMIT_FUNCTION_ARG

函數上參數的最大數量。

SQLITE_LIMIT_ATTACHED

附加資料庫 的最大數量。

SQLITE_LIMIT_LIKE_PATTERN_LENGTH

LIKE 或 GLOB 運算子對 pattern 參數的最大長度。

SQLITE_LIMIT_VARIABLE_NUMBER

SQL 陳述式中任何 參數 的最大索引編號。

SQLITE_LIMIT_TRIGGER_DEPTH

觸發器的最大遞迴深度。

SQLITE_LIMIT_WORKER_THREADS

單一 準備好的陳述式 可能啟動的輔助工作執行緒的最大數量。

---

資料庫連線的狀態參數

#define SQLITE_DBSTATUS_LOOKASIDE_USED       0
#define SQLITE_DBSTATUS_CACHE_USED           1
#define SQLITE_DBSTATUS_SCHEMA_USED          2
#define SQLITE_DBSTATUS_STMT_USED            3
#define SQLITE_DBSTATUS_LOOKASIDE_HIT        4
#define SQLITE_DBSTATUS_LOOKASIDE_MISS_SIZE  5
#define SQLITE_DBSTATUS_LOOKASIDE_MISS_FULL  6
#define SQLITE_DBSTATUS_CACHE_HIT            7
#define SQLITE_DBSTATUS_CACHE_MISS           8
#define SQLITE_DBSTATUS_CACHE_WRITE          9
#define SQLITE_DBSTATUS_DEFERRED_FKS        10
#define SQLITE_DBSTATUS_CACHE_USED_SHARED   11
#define SQLITE_DBSTATUS_CACHE_SPILL         12
#define SQLITE_DBSTATUS_MAX                 12   /* Largest defined DBSTATUS */

這些常數是可以傳遞為 sqlite3_db_status() 介面的第二個參數的可用整數「動詞」。

在 SQLite 的未來版本中可能會新增動詞。現有的動詞可能會停止使用。應用程式應檢查 sqlite3_db_status() 的回傳碼，以確保呼叫有效。如果呼叫已停止或不支援的動詞，sqlite3_db_status() 介面會回傳非零錯誤碼。

SQLITE_DBSTATUS_LOOKASIDE_USED

此參數會回傳目前已簽出的預先配置記憶體槽數量。

SQLITE_DBSTATUS_LOOKASIDE_HIT

此參數會回傳使用預先配置記憶體滿足的 malloc 嘗試次數。只有最大值有意義；目前值永遠為零。

SQLITE_DBSTATUS_LOOKASIDE_MISS_SIZE

此參數會回傳可能使用預先配置記憶體滿足，但由於請求的記憶體量大於預先配置槽大小而失敗的 malloc 嘗試次數。只有最大值有意義；目前值永遠為零。

SQLITE_DBSTATUS_LOOKASIDE_MISS_FULL

此參數傳回可能已使用 lookaside 記憶體滿足的 malloc 嘗試次數，但因所有 lookaside 記憶體已在使用中而失敗。只有最高水位值有意義；目前值永遠為零。

SQLITE_DBSTATUS_CACHE_USED

此參數傳回與資料庫連線相關的所有分頁快取所使用的堆積記憶體位元組數近似值。與 SQLITE_DBSTATUS_CACHE_USED 相關的高水位標記永遠為 0。

SQLITE_DBSTATUS_CACHE_USED_SHARED

此參數類似於 DBSTATUS_CACHE_USED，但如果分頁快取在兩個或更多連線之間共用，則該分頁快取所使用的堆積記憶體位元組數會在附加的連線之間平均分配。換句話說，如果與資料庫連線相關的任何分頁快取都沒有共用，則此要求會傳回與 DBSTATUS_CACHE_USED 相同的值。或者，如果一個或多個分頁快取有共用，則此呼叫傳回的值會小於 DBSTATUS_CACHE_USED 傳回的值。與 SQLITE_DBSTATUS_CACHE_USED_SHARED 相關的高水位標記永遠為 0。

SQLITE_DBSTATUS_SCHEMA_USED

此參數傳回用於儲存與連線相關的所有資料庫架構的堆積記憶體位元組數近似值 - 主要、暫時和任何 ATTACH-ed 資料庫。會報告架構使用的完整記憶體量，即使由於啟用 共用快取模式 而與其他資料庫連線共用架構記憶體。與 SQLITE_DBSTATUS_SCHEMA_USED 相關的高水位標記永遠為 0。

SQLITE_DBSTATUS_STMT_USED

此參數傳回與資料庫連線相關的所有已準備陳述式所使用的堆積和 lookaside 記憶體位元組數近似值。與 SQLITE_DBSTATUS_STMT_USED 相關的高水位標記永遠為 0。

SQLITE_DBSTATUS_CACHE_HIT

此參數傳回已發生的分頁快取命中次數。與 SQLITE_DBSTATUS_CACHE_HIT 相關的高水位標記永遠為 0。

SQLITE_DBSTATUS_CACHE_MISS

此參數傳回已發生的分頁快取遺漏次數。與 SQLITE_DBSTATUS_CACHE_MISS 相關的高水位標記永遠為 0。

SQLITE_DBSTATUS_CACHE_WRITE

此參數傳回已寫入磁碟的髒快取條目的數量。特別是，寫入 wal 模式資料庫中的 wal 檔案的頁面數量，或寫入回滾模式資料庫中的資料庫檔案的頁面數量。任何寫入為交易回滾或資料庫復原作業一部分的頁面都不會包含在內。如果在寫入頁面至磁碟時發生 IO 或其他錯誤，後續的 SQLITE_DBSTATUS_CACHE_WRITE 要求的影響是未定義的。與 SQLITE_DBSTATUS_CACHE_WRITE 相關的高水位標記永遠是 0。

SQLITE_DBSTATUS_CACHE_SPILL

此參數傳回由於頁面快取溢位而在交易過程中寫入磁碟的髒快取條目的數量。如果交易一次寫入磁碟，會更有效率。當頁面在交易過程中溢位時，會產生額外的負擔。此參數可用於協助找出可透過增加快取大小來解決的低效率。

SQLITE_DBSTATUS_DEFERRED_FKS

如果且僅當所有外來鍵約束 (延遲或立即) 已解決，此參數會傳回目前的零值。高水位標記永遠是 0。

---

已準備好陳述式的狀態參數

#define SQLITE_STMTSTATUS_FULLSCAN_STEP     1
#define SQLITE_STMTSTATUS_SORT              2
#define SQLITE_STMTSTATUS_AUTOINDEX         3
#define SQLITE_STMTSTATUS_VM_STEP           4
#define SQLITE_STMTSTATUS_REPREPARE         5
#define SQLITE_STMTSTATUS_RUN               6
#define SQLITE_STMTSTATUS_FILTER_MISS       7
#define SQLITE_STMTSTATUS_FILTER_HIT        8
#define SQLITE_STMTSTATUS_MEMUSED           99

這些預處理器巨集定義整數程式碼，用於命名與 sqlite3_stmt_status() 介面相關的計數器值。各種計數器的意義如下

SQLITE_STMTSTATUS_FULLSCAN_STEP

這是 SQLite 在全表掃描中向前移動於表格中的次數。此計數器的數字龐大可能表示透過小心使用索引來改善效能的機會。

SQLITE_STMTSTATUS_SORT

這是已發生的排序作業數量。此計數器中的非零值可能表示透過小心使用索引來改善效能的機會。

SQLITE_STMTSTATUS_AUTOINDEX

這是插入到暫時索引中的列數，這些索引會自動建立，以協助連接執行得更快。此計數器中的非零值可能會指出一個機會，透過新增永久索引來改善效能，而這些索引不需要在每次執行陳述式時重新初始化。

SQLITE_STMTSTATUS_VM_STEP

這是已準備陳述式執行的虛擬機器作業次數，如果該數字小於或等於 2147483647。虛擬機器作業次數可用作已準備陳述式所完成的總工作量的代理。如果虛擬機器作業次數超過 2147483647，則此陳述式狀態碼傳回的值未定義。

SQLITE_STMTSTATUS_REPREPARE

這是準備陳述式因架構變更或可能影響查詢計畫的繫結參數變更而自動重新產生次數。

SQLITE_STMTSTATUS_RUN

這是已準備陳述式執行次數。對於此計數器而言，單一「執行」是一次或多次呼叫sqlite3_step()，後接呼叫sqlite3_reset()。此計數器會在每個週期的第一次sqlite3_step()呼叫中遞增。

SQLITE_STMTSTATUS_FILTER_HIT
SQLITE_STMTSTATUS_FILTER_MISS

SQLITE_STMTSTATUS_FILTER_HIT 是連接步驟因 Bloom 篩選器傳回 not-found 而被略過的次數。對應的 SQLITE_STMTSTATUS_FILTER_MISS 值是 Bloom 篩選器傳回 find 的次數，因此連接步驟必須照常處理。

SQLITE_STMTSTATUS_MEMUSED

這是用於儲存已準備陳述式的堆疊記憶體近似位元組數。此值實際上並非計數器，因此當 opcode 為 SQLITE_STMTSTATUS_MEMUSED 時，sqlite3_stmt_status() 的 resetFlg 參數會被忽略。

---

資料庫快照

typedef struct sqlite3_snapshot {
  unsigned char hidden[48];
} sqlite3_snapshot;

快照物件的實例會記錄 WAL 模式 資料庫在歷史中某個特定時間點的狀態。

在 WAL 模式 中，在同一個資料庫檔案上開啟的多個 資料庫連線 可以各自讀取資料庫檔案的不同歷史版本。當 資料庫連線 開始一個讀取交易時，該連線會看到資料庫在交易首次開始時存在的未變更副本。其他連線對資料庫的後續變更，在開始新的讀取交易之前，讀取器不會看到。

sqlite3_snapshot 物件會記錄資料庫檔案歷史版本的狀態資訊，以便稍後開啟一個新的讀取交易，看到資料庫的歷史版本，而不是最新版本。

使用這個物件的 1 個建構函式：sqlite3_snapshot_get()

使用這個物件的 1 個解構函式：sqlite3_snapshot_free()

使用這個物件的 3 個方法：sqlite3_snapshot_cmp()、sqlite3_snapshot_open()、sqlite3_snapshot_recover()

---

64 位元整數類型

#ifdef SQLITE_INT64_TYPE
  typedef SQLITE_INT64_TYPE sqlite_int64;
# ifdef SQLITE_UINT64_TYPE
    typedef SQLITE_UINT64_TYPE sqlite_uint64;
# else
    typedef unsigned SQLITE_INT64_TYPE sqlite_uint64;
# endif
#elif defined(_MSC_VER) || defined(__BORLANDC__)
  typedef __int64 sqlite_int64;
  typedef unsigned __int64 sqlite_uint64;
#else
  typedef long long int sqlite_int64;
  typedef unsigned long long int sqlite_uint64;
#endif
typedef sqlite_int64 sqlite3_int64;
typedef sqlite_uint64 sqlite3_uint64;

由於沒有跨平台的方式來指定 64 位元整數類型，因此 SQLite 包含 64 位元有號和無號整數的類型定義。

sqlite3_int64 和 sqlite3_uint64 是首選的類型定義。sqlite_int64 和 sqlite_uint64 類型僅支援向後相容性。

sqlite3_int64 和 sqlite_int64 類型可以儲存 -9223372036854775808 到 +9223372036854775807 之間的整數值（含）。sqlite3_uint64 和 sqlite_uint64 類型可以儲存 0 到 +18446744073709551615 之間的整數值（含）。

---

虛擬表格物件

struct sqlite3_module {
  int iVersion;
  int (*xCreate)(sqlite3*, void *pAux,
               int argc, const char *const*argv,
               sqlite3_vtab **ppVTab, char**);
  int (*xConnect)(sqlite3*, void *pAux,
               int argc, const char *const*argv,
               sqlite3_vtab **ppVTab, char**);
  int (*xBestIndex)(sqlite3_vtab *pVTab, sqlite3_index_info*);
  int (*xDisconnect)(sqlite3_vtab *pVTab);
  int (*xDestroy)(sqlite3_vtab *pVTab);
  int (*xOpen)(sqlite3_vtab *pVTab, sqlite3_vtab_cursor **ppCursor);
  int (*xClose)(sqlite3_vtab_cursor*);
  int (*xFilter)(sqlite3_vtab_cursor*, int idxNum, const char *idxStr,
                int argc, sqlite3_value **argv);
  int (*xNext)(sqlite3_vtab_cursor*);
  int (*xEof)(sqlite3_vtab_cursor*);
  int (*xColumn)(sqlite3_vtab_cursor*, sqlite3_context*, int);
  int (*xRowid)(sqlite3_vtab_cursor*, sqlite3_int64 *pRowid);
  int (*xUpdate)(sqlite3_vtab *, int, sqlite3_value **, sqlite3_int64 *);
  int (*xBegin)(sqlite3_vtab *pVTab);
  int (*xSync)(sqlite3_vtab *pVTab);
  int (*xCommit)(sqlite3_vtab *pVTab);
  int (*xRollback)(sqlite3_vtab *pVTab);
  int (*xFindFunction)(sqlite3_vtab *pVtab, int nArg, const char *zName,
                       void (**pxFunc)(sqlite3_context*,int,sqlite3_value**),
                       void **ppArg);
  int (*xRename)(sqlite3_vtab *pVtab, const char *zNew);
  /* The methods above are in version 1 of the sqlite_module object. Those
  ** below are for version 2 and greater. */
  int (*xSavepoint)(sqlite3_vtab *pVTab, int);
  int (*xRelease)(sqlite3_vtab *pVTab, int);
  int (*xRollbackTo)(sqlite3_vtab *pVTab, int);
  /* The methods above are in versions 1 and 2 of the sqlite_module object.
  ** Those below are for version 3 and greater. */
  int (*xShadowName)(const char*);
  /* The methods above are in versions 1 through 3 of the sqlite_module object.
  ** Those below are for version 4 and greater. */
  int (*xIntegrity)(sqlite3_vtab *pVTab, const char *zSchema,
                    const char *zTabName, int mFlags, char **pzErr);
};

這個結構有時稱為「虛擬表格模組」，定義 虛擬表格 的實作。這個結構主要包含模組的方法。

透過填入此結構的持續性實例，並將指標傳遞給 sqlite3_create_module() 或 sqlite3_create_module_v2()，來建立虛擬表格模組。註冊會持續有效，直到被不同的模組取代或直到 資料庫連線 關閉為止。此結構的內容在註冊到任何資料庫連線時，不得變更。

---

虛擬表格游標物件

struct sqlite3_vtab_cursor {
  sqlite3_vtab *pVtab;      /* Virtual table of this cursor */
  /* Virtual table implementations will typically add additional fields */
};

每個 虛擬表格模組 實作都會使用下列結構的子類別，來描述指向 虛擬表格 的游標，並用於迴圈瀏覽虛擬表格。游標會使用模組的 xOpen 方法建立，並由 xClose 方法銷毀。游標會由模組的 xFilter、xNext、xEof、xColumn 和 xRowid 方法使用。每個模組實作都會定義游標結構的內容，以符合自己的需求。

此超類別的存在，是為了定義游標中所有實作共用的欄位。

---

開啟 BLOB 的控制代碼

typedef struct sqlite3_blob sqlite3_blob;

此物件的實例代表一個開啟的 BLOB，可以在其上執行 增量 BLOB I/O。此類型的物件會由 sqlite3_blob_open() 建立，並由 sqlite3_blob_close() 銷毀。可以透過 sqlite3_blob_read() 和 sqlite3_blob_write() 介面，來讀取或寫入 BLOB 的小區段。 sqlite3_blob_bytes() 介面會傳回 BLOB 的大小（以位元組為單位）。

使用此物件的 1 個建構函式：sqlite3_blob_open()

使用此物件的 1 個解構函式：sqlite3_blob_close()

使用此物件的 4 個方法：sqlite3_blob_bytes()、sqlite3_blob_read()、sqlite3_blob_reopen()、sqlite3_blob_write()

---

資料庫連線控制代碼

typedef struct sqlite3 sqlite3;

每個開啟的 SQLite 資料庫都以指向名為「sqlite3」的不透明結構實例的指標表示。將 sqlite3 指標視為物件很有用。sqlite3_open()、sqlite3_open16() 和 sqlite3_open_v2() 介面是其建構函式，而 sqlite3_close() 和 sqlite3_close_v2() 是其解構函式。還有許多其他介面（例如 sqlite3_prepare_v2()、sqlite3_create_function() 和 sqlite3_busy_timeout()，僅舉三者為例）是 sqlite3 物件的方法。

使用此物件的 3 個建構函式：sqlite3_open()、sqlite3_open16()、sqlite3_open_v2()

使用此物件的 2 個解構函式：sqlite3_close()、sqlite3_close_v2()

使用此物件的 79 個方法

• sqlite3_autovacuum_pages
• sqlite3_blob_open
• sqlite3_busy_handler
• sqlite3_busy_timeout
• sqlite3_changes
• sqlite3_changes64
• sqlite3_collation_needed
• sqlite3_collation_needed16
• sqlite3_commit_hook
• sqlite3_create_collation
• sqlite3_create_collation16
• sqlite3_create_collation_v2
• sqlite3_create_function
• sqlite3_create_function16
• sqlite3_create_function_v2
• sqlite3_create_module
• sqlite3_create_module_v2
• sqlite3_create_window_function
• sqlite3_db_cacheflush
• sqlite3_db_config
• sqlite3_db_filename
• sqlite3_db_mutex
• sqlite3_db_name
• sqlite3_db_readonly
• sqlite3_db_release_memory
• sqlite3_db_status
• sqlite3_drop_modules
• sqlite3_enable_load_extension
• sqlite3_errcode
• sqlite3_errmsg
• sqlite3_errmsg16
• sqlite3_error_offset
• sqlite3_errstr
• sqlite3_exec
• sqlite3_extended_errcode
• sqlite3_extended_result_codes
• sqlite3_file_control
• sqlite3_free_table
• sqlite3_get_autocommit
• sqlite3_get_clientdata
• sqlite3_get_table
• sqlite3_interrupt
• sqlite3_is_interrupted
• sqlite3_last_insert_rowid
• sqlite3_limit
• sqlite3_load_extension
• sqlite3_next_stmt
• sqlite3_overload_function
• sqlite3_prepare
• sqlite3_prepare16
• sqlite3_prepare16_v2
• sqlite3_prepare16_v3
• sqlite3_prepare_v2
• sqlite3_prepare_v3
• sqlite3_preupdate_blobwrite
• sqlite3_preupdate_count
• sqlite3_preupdate_depth
• sqlite3_preupdate_hook
• sqlite3_preupdate_new
• sqlite3_preupdate_old
• sqlite3_profile
• sqlite3_progress_handler
• sqlite3_rollback_hook
• sqlite3_set_authorizer
• sqlite3_set_clientdata
• sqlite3_set_last_insert_rowid
• sqlite3_system_errno
• sqlite3_table_column_metadata
• sqlite3_total_changes
• sqlite3_total_changes64
• sqlite3_trace
• sqlite3_trace_v2
• sqlite3_txn_state
• sqlite3_unlock_notify
• sqlite3_update_hook
• sqlite3_wal_autocheckpoint
• sqlite3_wal_checkpoint
• sqlite3_wal_checkpoint_v2
• sqlite3_wal_hook

---

動態字串物件

typedef struct sqlite3_str sqlite3_str;

sqlite3_str 物件的實例包含一個動態大小的字串，正在建構中。

sqlite3_str 物件的生命週期如下

1. 使用 sqlite3_str_new() 建立 sqlite3_str 物件。
2. 使用各種方法將文字附加到 sqlite3_str 物件，例如 sqlite3_str_appendf()。
3. 使用 sqlite3_str_finish() 介面來銷毀 sqlite3_str 物件並傳回它建立的字串。

使用此物件的 1 個建構函式：sqlite3_str_new()

使用此物件的 1 個解構函式：sqlite3_str_finish()

使用此物件的 9 個方法

• sqlite3_str_append
• sqlite3_str_appendall
• sqlite3_str_appendchar
• sqlite3_str_appendf
• sqlite3_str_errcode
• sqlite3_str_length
• sqlite3_str_reset
• sqlite3_str_value
• sqlite3_str_vappendf

---

應用程式定義的頁面快取。

typedef struct sqlite3_pcache_methods2 sqlite3_pcache_methods2;
struct sqlite3_pcache_methods2 {
  int iVersion;
  void *pArg;
  int (*xInit)(void*);
  void (*xShutdown)(void*);
  sqlite3_pcache *(*xCreate)(int szPage, int szExtra, int bPurgeable);
  void (*xCachesize)(sqlite3_pcache*, int nCachesize);
  int (*xPagecount)(sqlite3_pcache*);
  sqlite3_pcache_page *(*xFetch)(sqlite3_pcache*, unsigned key, int createFlag);
  void (*xUnpin)(sqlite3_pcache*, sqlite3_pcache_page*, int discard);
  void (*xRekey)(sqlite3_pcache*, sqlite3_pcache_page*,
      unsigned oldKey, unsigned newKey);
  void (*xTruncate)(sqlite3_pcache*, unsigned iLimit);
  void (*xDestroy)(sqlite3_pcache*);
  void (*xShrink)(sqlite3_pcache*);
};

透過傳遞sqlite3_pcache_methods2結構的執行個體，sqlite3_config(SQLITE_CONFIG_PCACHE2, ...) 介面可以註冊替代頁快取實作。在許多應用程式中，SQLite 分配的大部分堆積記憶體都用於頁快取。透過使用此 API 實作自訂頁快取，應用程式可以更妥善地控制 SQLite 使用的記憶體量、分配和釋放記憶體的方式，以及用於決定資料庫檔案哪些部分快取以及快取多久的政策。

替代頁快取機制是一種極端手段，僅最嚴苛的應用程式才需要。內建頁快取建議用於大多數用途。

在呼叫sqlite3_config時，sqlite3_pcache_methods2結構的內容會由 SQLite 複製到內部緩衝區。因此，應用程式可以在呼叫sqlite3_config()傳回後捨棄參數。

xInit() 方法會針對每次有效的sqlite3_initialize()呼叫呼叫一次（通常在處理程序的生命週期中只呼叫一次）。xInit() 方法會傳遞sqlite3_pcache_methods2.pArg 值的副本。xInit() 方法的目的是設定自訂頁快取實作所需的全球資料結構。如果 xInit() 方法為 NULL，則會使用內建的預設頁快取，而不是應用程式定義的頁快取。

xShutdown() 方法會由sqlite3_shutdown()呼叫。如果需要，可以在處理程序關閉前使用它來清除任何未完成的資源。xShutdown() 方法可以為 NULL。

SQLite 會自動序列化對 xInit 方法的呼叫，因此 xInit 方法不需要執行緒安全。xShutdown 方法只會從 sqlite3_shutdown() 呼叫，因此也不需要執行緒安全。在多執行緒應用程式中，所有其他方法都必須執行緒安全。

SQLite 永遠不會在未呼叫 xShutdown() 的情況下呼叫 xInit() 超過一次。

SQLite 會呼叫 xCreate() 方法來建構新的快取執行個體。SQLite 通常會為每個開啟的資料庫檔案建立一個快取執行個體，但並未保證如此。第一個參數 szPage 是快取必須配置的頁面大小（以位元組為單位）。szPage 永遠會是 2 的次方。第二個參數 szExtra 是與每個頁面快取項目關聯的額外儲存空間大小（以位元組為單位）。szExtra 參數會小於 250。SQLite 會使用每個頁面上的額外 szExtra 位元組來儲存磁碟上基礎資料庫頁面的元資料。傳遞到 szExtra 的值會依據 SQLite 版本、目標平台和 SQLite 編譯方式而有所不同。傳遞到 xCreate() 的第三個引數 bPurgeable 為 true，表示要建立的快取會用來快取儲存在磁碟上的檔案的資料庫頁面；如果用於記憶體中資料庫，則為 false。快取實作不需要針對 bPurgeable 的值執行任何特別的動作；這純粹是建議。在 bPurgeable 為 false 的快取中，SQLite 永遠不會呼叫 xUnpin()，除非要刻意刪除頁面。換句話說，在 bPurgeable 設為 false 的快取中對 xUnpin() 的呼叫永遠會將「捨棄」旗標設為 true。因此，以 bPurgeable false 建立的快取永遠不會包含任何未固定頁面。

SQLite 可隨時呼叫 xCachesize() 方法，以設定建議的最大快取大小（由作為第一個引數傳遞的快取執行個體儲存的頁面數）。這是使用 SQLite "PRAGMA cache_size" 指令設定的值。與 bPurgeable 參數一樣，實作不需要對此值執行任何操作；它僅供參考。

xPagecount() 方法必須傳回快取中目前儲存的頁面數，包括已固定和未固定的頁面。

xFetch() 方法會在快取中找到一個頁面，並傳回與該頁面關聯的 sqlite3_pcache_page 物件指標，或 NULL 指標。傳回的 sqlite3_pcache_page 物件的 pBuf 元素會是指向一個 szPage 位元組緩衝區的指標，用於儲存單一資料庫頁面的內容。sqlite3_pcache_page 的 pExtra 元素會是指向 SQLite 為快取中的每個項目要求的 szExtra 位元組額外儲存空間的指標。

要擷取的頁面由金鑰決定。最小金鑰值為 1。使用 xFetch 擷取後，頁面會被視為「已固定」。

如果要求的頁面已在頁面快取中，則快取實作必須傳回頁面緩衝區的指標，其內容保持完整。如果要求的頁面尚未在快取中，則快取實作應使用 createFlag 參數的值來協助決定要採取的動作。

createFlag	頁面尚未在快取中的行為
0	不配置新的頁面。傳回 NULL。
1	如果容易且方便，請配置一個新頁面。否則傳回 NULL。
2	盡一切努力配置一個新頁面。只有在配置新頁面實際上不可能時才傳回 NULL。

SQLite 通常會以 0 或 1 的 createFlag 呼叫 xFetch()。SQLite 僅會在先前呼叫 createFlag 為 1 失敗後，才使用 createFlag 為 2。在 xFetch() 呼叫之間，SQLite 可能會嘗試解除固定一個或多個快取頁面，方法是將固定頁面的內容溢出到磁碟，並同步作業系統磁碟快取。

SQLite 會以目前固定頁面的指標作為第二個參數，呼叫 xUnpin()。如果第三個參數 discard 為非零，則必須從快取中驅逐頁面。如果 discard 參數為零，則可以根據頁面快取實作的判斷，捨棄或保留頁面。頁面快取實作可以隨時選擇驅逐未固定的頁面。

快取不得執行任何參考計數。不論先前呼叫 xFetch() 的次數為何，單一呼叫 xUnpin() 都會解除固定頁面。

xRekey() 方法用於變更傳遞為第二個參數的頁面所關聯的關鍵值。如果快取先前包含與 newKey 關聯的項目，則必須捨棄該項目。保證任何先前與 newKey 關聯的快取項目都不會被固定。

當 SQLite 呼叫 xTruncate() 方法時，快取必須捨棄所有現有快取項目，其頁面號碼 (金鑰) 大於或等於傳遞給 xTruncate() 的 iLimit 參數值。如果這些頁面有任何一個被固定，則會隱含解除固定，表示可以安全地捨棄它們。

xDestroy() 方法用於刪除由 xCreate() 配置的快取。應釋放與指定快取相關的所有資源。在呼叫 xDestroy() 方法後，SQLite 會將 sqlite3_pcache* 句柄視為無效，並且不會將它與任何其他 sqlite3_pcache_methods2 函數搭配使用。

SQLite 在希望頁面快取釋放盡可能多的堆疊記憶體時，會呼叫 xShrink() 方法。頁面快取實作並非一定要釋放任何記憶體，但良好的實作應該盡力而為。

---

準備好的陳述物件

typedef struct sqlite3_stmt sqlite3_stmt;

此物件的執行個體代表已編譯成二進位形式的單一 SQL 陳述，且已準備好進行評估。

將每一個 SQL 陳述視為一個獨立的電腦程式。原始的 SQL 文字是原始碼。準備好的陳述物件是已編譯的物件碼。在執行所有 SQL 之前，必須先將其轉換成準備好的陳述。

準備好的陳述物件的生命週期通常如下

1. 使用 sqlite3_prepare_v2() 建立準備好的陳述物件。
2. 使用 sqlite3_bind_*() 介面將值繫結到 參數。
3. 呼叫 sqlite3_step() 一次或多次來執行 SQL。
4. 使用 sqlite3_reset() 重設準備好的陳述，然後回到步驟 2。執行此步驟 0 次或多次。
5. 使用 sqlite3_finalize() 銷毀物件。

使用此物件的 6 個建構函式

• sqlite3_prepare
• sqlite3_prepare16
• sqlite3_prepare16_v2
• sqlite3_prepare16_v3
• sqlite3_prepare_v2
• sqlite3_prepare_v3

使用此物件的 1 個解構函式：sqlite3_finalize()

使用此物件的 53 個方法

• sqlite3_bind_blob
• sqlite3_bind_blob64
• sqlite3_bind_double
• sqlite3_bind_int
• sqlite3_bind_int64
• sqlite3_bind_null
• sqlite3_bind_parameter_count
• sqlite3_bind_parameter_index
• sqlite3_bind_parameter_name
• sqlite3_bind_pointer
• sqlite3_bind_text
• sqlite3_bind_text16
• sqlite3_bind_text64
• sqlite3_bind_value
• sqlite3_bind_zeroblob
• sqlite3_bind_zeroblob64
• sqlite3_clear_bindings
• sqlite3_column_blob
• sqlite3_column_bytes
• sqlite3_column_bytes16
• sqlite3_column_count
• sqlite3_column_database_name
• sqlite3_column_database_name16
• sqlite3_column_decltype
• sqlite3_column_decltype16
• sqlite3_column_double
• sqlite3_column_int
• sqlite3_column_int64
• sqlite3_column_name
• sqlite3_column_name16
• sqlite3_column_origin_name
• sqlite3_column_origin_name16
• sqlite3_column_table_name
• sqlite3_column_table_name16
• sqlite3_column_text
• sqlite3_column_text16
• sqlite3_column_type
• sqlite3_column_value
• sqlite3_data_count
• sqlite3_db_handle
• sqlite3_expanded_sql
• sqlite3_normalized_sql
• sqlite3_reset
• sqlite3_sql
• sqlite3_step
• sqlite3_stmt_busy
• sqlite3_stmt_explain
• sqlite3_stmt_isexplain
• sqlite3_stmt_readonly
• sqlite3_stmt_scanstatus
• sqlite3_stmt_scanstatus_reset
• sqlite3_stmt_scanstatus_v2
• sqlite3_stmt_status

---

動態型別值物件

typedef struct sqlite3_value sqlite3_value;

SQLite 使用 sqlite3_value 物件來表示所有可儲存在資料庫表格中的值。SQLite 對其儲存的值使用動態型別。儲存在 sqlite3_value 物件中的值可以是整數、浮點數值、字串、BLOB 或 NULL。

sqlite3_value 物件可以是「受保護的」或「未受保護的」。有些介面需要受保護的 sqlite3_value。其他介面會接受受保護或未受保護的 sqlite3_value。每個接受 sqlite3_value 引數的介面都會指定是否需要受保護的 sqlite3_value。可以使用 sqlite3_value_dup() 介面從未受保護的 sqlite3_value 建立新的受保護 sqlite3_value。

「受保護」和「未受保護」這兩個術語是指是否持有互斥鎖。受保護的 sqlite3_value 物件會持有內部互斥鎖，但未受保護的 sqlite3_value 物件則不會持有互斥鎖。如果 SQLite 編譯為單執行緒（使用 SQLITE_THREADSAFE=0 且 sqlite3_threadsafe() 傳回 0），或如果 SQLite 在其中一種減少互斥鎖模式 SQLITE_CONFIG_SINGLETHREAD 或 SQLITE_CONFIG_MULTITHREAD 中執行，則受保護和未受保護的 sqlite3_value 物件之間沒有區別，而且它們可以互換使用。然而，為了最大程度的程式碼可攜性，建議應用程式在即使沒有嚴格要求的情況下，仍區分受保護和未受保護的 sqlite3_value 物件。

傳遞為 應用程式定義的 SQL 函數 實作中參數的 sqlite3_value 物件受到保護。sqlite3_vtab_rhs_value() 傳回的 sqlite3_value 物件受到保護。sqlite3_column_value() 傳回的 sqlite3_value 物件未受保護。未受保護的 sqlite3_value 物件只能用作 sqlite3_result_value()、sqlite3_bind_value() 和 sqlite3_value_dup() 的引數。sqlite3_value_type() 系列介面需要受保護的 sqlite3_value 物件。

使用此物件的 19 個方法

• sqlite3_value_blob
• sqlite3_value_bytes
• sqlite3_value_bytes16
• sqlite3_value_double
• sqlite3_value_dup
• sqlite3_value_encoding
• sqlite3_value_free
• sqlite3_value_frombind
• sqlite3_value_int
• sqlite3_value_int64
• sqlite3_value_nochange
• sqlite3_value_numeric_type
• sqlite3_value_pointer
• sqlite3_value_subtype
• sqlite3_value_text
• sqlite3_value_text16
• sqlite3_value_text16be
• sqlite3_value_text16le
• sqlite3_value_type

---

已棄用的函數

#ifndef SQLITE_OMIT_DEPRECATED
int sqlite3_aggregate_count(sqlite3_context*);
int sqlite3_expired(sqlite3_stmt*);
int sqlite3_transfer_bindings(sqlite3_stmt*, sqlite3_stmt*);
int sqlite3_global_recover(void);
void sqlite3_thread_cleanup(void);
int sqlite3_memory_alarm(void(*)(void*,sqlite3_int64,int),
                      void*,sqlite3_int64);
#endif

這些函數已 棄用。為了維持與舊程式碼的向下相容性，這些函數仍持續受到支援。然而，新的應用程式應避免使用這些函數。為了鼓勵程式設計人員避免使用這些函數，我們不會說明它們的功能。

---

線上備份 API。

sqlite3_backup *sqlite3_backup_init(
  sqlite3 *pDest,                        /* Destination database handle */
  const char *zDestName,                 /* Destination database name */
  sqlite3 *pSource,                      /* Source database handle */
  const char *zSourceName                /* Source database name */
);
int sqlite3_backup_step(sqlite3_backup *p, int nPage);
int sqlite3_backup_finish(sqlite3_backup *p);
int sqlite3_backup_remaining(sqlite3_backup *p);
int sqlite3_backup_pagecount(sqlite3_backup *p);

備份 API 會將一個資料庫的內容複製到另一個資料庫。這對於建立資料庫備份或將記憶體中資料庫複製到或從持續性檔案很有用。

另請參閱：使用 SQLite 線上備份 API

在備份作業期間，SQLite 會對目標資料庫檔案保持寫入交易開啟。來源資料庫僅在讀取時會被讀取鎖定；它不會在整個備份作業期間持續鎖定。因此，備份可以在動態來源資料庫上執行，而不會在備份進行時阻止其他資料庫連線讀取或寫入來源資料庫。

要執行備份操作

1. sqlite3_backup_init() 呼叫一次以初始化備份，
2. sqlite3_backup_step() 呼叫一次或多次以在兩個資料庫之間傳輸資料，最後
3. sqlite3_backup_finish() 呼叫以釋放與備份操作相關的所有資源。

對於每次成功的 sqlite3_backup_init() 呼叫，都應該有一個 sqlite3_backup_finish() 呼叫。

sqlite3_backup_init()

sqlite3_backup_init(D,N,S,M) 的 D 和 N 參數分別是與目標資料庫相關聯的 資料庫連線 和資料庫名稱。資料庫名稱對於主資料庫是「main」，對於暫時資料庫是「temp」，或者對於在 ATTACH 陳述式中 AS 關鍵字後指定的附加資料庫是指定的資料庫名稱。傳遞給 sqlite3_backup_init(D,N,S,M) 的 S 和 M 參數分別識別來源資料庫的 資料庫連線 和資料庫名稱。來源和目標 資料庫連線（參數 S 和 D）必須不同，否則 sqlite3_backup_init(D,N,S,M) 會失敗並傳回錯誤。

如果目標資料庫上已經開啟讀取或讀寫交易，則呼叫 sqlite3_backup_init() 會失敗並傳回 NULL。

如果在 sqlite3_backup_init(D,N,S,M) 內發生錯誤，則會傳回 NULL，並將錯誤碼和錯誤訊息儲存在目標 資料庫連線 D 中。可以使用 sqlite3_errcode()、sqlite3_errmsg() 和/或 sqlite3_errmsg16() 函數來擷取 sqlite3_backup_init() 失敗呼叫的錯誤碼和訊息。成功呼叫 sqlite3_backup_init() 會傳回指向 sqlite3_backup 物件的指標。可以將 sqlite3_backup 物件與 sqlite3_backup_step() 和 sqlite3_backup_finish() 函數一起使用，以執行指定的備份操作。

sqlite3_backup_step()

函式 sqlite3_backup_step(B,N) 將複製多達 N 個頁面，在由 sqlite3_backup 物件 B 所指定的來源和目標資料庫之間。如果 N 為負值，則會複製所有剩餘的來源頁面。如果 sqlite3_backup_step(B,N) 成功複製 N 個頁面，且仍有更多頁面需要複製，則函式會傳回 SQLITE_OK。如果 sqlite3_backup_step(B,N) 成功完成從來源到目標的所有頁面複製，則會傳回 SQLITE_DONE。如果在執行 sqlite3_backup_step(B,N) 時發生錯誤，則會傳回 錯誤代碼。除了 SQLITE_OK 和 SQLITE_DONE 之外，呼叫 sqlite3_backup_step() 可能會傳回 SQLITE_READONLY、SQLITE_NOMEM、SQLITE_BUSY、SQLITE_LOCKED 或 SQLITE_IOERR_XXX 延伸錯誤代碼。

如果發生下列情況，sqlite3_backup_step() 可能會傳回 SQLITE_READONLY：

1. 目標資料庫是以唯讀方式開啟，或
2. 目標資料庫使用寫入前記錄日誌，且目標和來源頁面大小不同，或
3. 目標資料庫是記憶體中資料庫，且目標和來源頁面大小不同。

如果 sqlite3_backup_step() 無法取得所需的檔案系統鎖定，則會呼叫忙碌處理函式（如果已指定）。如果忙碌處理函式在鎖定可用前傳回非零值，則會傳回 SQLITE_BUSY 給呼叫者。在這種情況下，可以稍後重新嘗試呼叫 sqlite3_backup_step()。如果在呼叫 sqlite3_backup_step() 時，來源資料庫連線用於寫入來源資料庫，則會立即傳回 SQLITE_LOCKED。同樣地，在這種情況下，可以稍後重新嘗試呼叫 sqlite3_backup_step()。如果傳回 SQLITE_IOERR_XXX、SQLITE_NOMEM 或 SQLITE_READONLY，則重新嘗試呼叫 sqlite3_backup_step() 沒有意義。這些錯誤會被視為致命錯誤。應用程式必須接受備份操作已失敗，並將備份操作控制代碼傳遞給 sqlite3_backup_finish() 以釋放相關資源。

第一次呼叫 sqlite3_backup_step() 會取得目標檔案的獨占鎖定。在呼叫 sqlite3_backup_finish() 或備份操作完成且 sqlite3_backup_step() 傳回 SQLITE_DONE 之前，不會釋放獨占鎖定。每次呼叫 sqlite3_backup_step() 都會取得來源資料庫的共用鎖定，持續到 sqlite3_backup_step() 呼叫為止。由於來源資料庫並未在 sqlite3_backup_step() 呼叫之間鎖定，因此來源資料庫可能在備份程序進行期間修改。如果來源資料庫是由外部程序或透過備份操作使用的資料庫連線以外的資料庫連線修改，則備份會在下次呼叫 sqlite3_backup_step() 時自動重新啟動。如果來源資料庫是由與備份操作相同的資料庫連線修改，則備份資料庫會在同時自動更新。

sqlite3_backup_finish()

當 sqlite3_backup_step() 回傳 SQLITE_DONE，或當應用程式想要放棄備份操作時，應用程式應該透過將 sqlite3_backup 傳遞給 sqlite3_backup_finish() 來銷毀 sqlite3_backup。sqlite3_backup_finish() 介面會釋放與 sqlite3_backup 物件相關的所有資源。如果 sqlite3_backup_step() 尚未回傳 SQLITE_DONE，則目標資料庫上的任何主動寫入交易都會被還原。在呼叫 sqlite3_backup_finish() 之後，sqlite3_backup 物件會失效，且不得使用。

如果沒有發生任何 sqlite3_backup_step() 錯誤，則 sqlite3_backup_finish 回傳的值為 SQLITE_OK，無論 sqlite3_backup_step() 是否已完成。如果在同一個 sqlite3_backup 物件上任何先前的 sqlite3_backup_step() 呼叫期間發生記憶體不足情況或 IO 錯誤，則 sqlite3_backup_finish() 會回傳對應的 錯誤代碼。

從 sqlite3_backup_step() 回傳 SQLITE_BUSY 或 SQLITE_LOCKED 並非永久錯誤，且不會影響 sqlite3_backup_finish() 的回傳值。

sqlite3_backup_remaining() 和 sqlite3_backup_pagecount()

sqlite3_backup_remaining() 常式會回傳在最近一次 sqlite3_backup_step() 結束時仍需要備份的頁面數。sqlite3_backup_pagecount() 常式會回傳在最近一次 sqlite3_backup_step() 結束時來源資料庫中的總頁面數。這些函式的回傳值僅由 sqlite3_backup_step() 更新。如果來源資料庫以改變來源資料庫大小或剩餘頁面數的方式進行修改，則這些變更不會反映在 sqlite3_backup_pagecount() 和 sqlite3_backup_remaining() 的輸出中，直到下一次 sqlite3_backup_step() 之後。

資料庫控制項的同時使用

在備份作業進行中或初始化時，應用程式可能會將來源資料庫連線用於其他用途。如果 SQLite 編譯並設定為支援執行緒安全資料庫連線，則來源資料庫連線可同時從其他執行緒中使用。

然而，應用程式必須保證在呼叫 sqlite3_backup_init() 之後且在對應呼叫 sqlite3_backup_finish() 之前，不會將目標資料庫連線傳遞給任何其他 API（由任何執行緒）。SQLite 目前不會檢查應用程式是否錯誤地存取目標資料庫連線，因此不會回報任何錯誤碼，但作業可能會因此發生故障。在備份進行中使用目標資料庫連線也可能會導致 mutex 死結。

如果在共用快取模式中執行，應用程式必須保證在備份執行時不會存取目標資料庫所使用的共用快取。實際上，這表示應用程式必須保證備份到的磁碟檔案不會被程序中的任何連線存取，而不仅仅是傳遞給 sqlite3_backup_init() 的特定連線。

sqlite3_backup 物件本身是部分執行緒安全的。多個執行緒可以安全地對 sqlite3_backup_step() 進行多個同時呼叫。然而，sqlite3_backup_remaining() 和 sqlite3_backup_pagecount() API 嚴格來說並不是執行緒安全的。如果在另一個執行緒呼叫 sqlite3_backup_step() 的同時呼叫它們，它們可能會回傳無效值。

---

計算已修改的列數

int sqlite3_changes(sqlite3*);
sqlite3_int64 sqlite3_changes64(sqlite3*);

這些函數會傳回由唯一參數所指定的資料庫連線中，最近完成的 INSERT、UPDATE 或 DELETE 陳述式所修改、插入或刪除的列數。這兩個函數除了傳回值的類型不同之外，其餘相同，而且如果最近的 INSERT、UPDATE 或 DELETE 所修改的列數大於「int」類型所支援的最大值，則 sqlite3_changes() 的傳回值未定義。執行任何其他類型的 SQL 陳述式不會修改這些函數所傳回的值。

只會考慮 INSERT、UPDATE 或 DELETE 陳述式所直接進行的變更，而不會計算由 觸發器、外來金鑰動作 或 REPLACE 約束解決所造成的輔助變更。

由 INSTEAD OF 觸發器 所攔截的檢視變更不會計算在內。在檢視上執行 INSERT、UPDATE 或 DELETE 陳述式後，sqlite3_changes() 所傳回的值永遠為零。只會計算對實際表格所做的變更。

如果在觸發器程式執行期間執行 sqlite3_changes() 函數，事情會變得更複雜。如果程式使用 changes() SQL 函數，或者如果其他一些回呼函數直接呼叫 sqlite3_changes()，就會發生這種情況。基本上

• 在進入觸發器程式之前，會儲存 sqlite3_changes() 函數所傳回的值。觸發器程式執行完畢後，會還原原始值。

• 在觸發器程式中，每個 INSERT、UPDATE 和 DELETE 陳述式都會在完成時設定 sqlite3_changes() 所傳回的值，就像平常一樣。當然，這個值不會包含任何由子觸發器所執行的變更，因為在每個子觸發器執行完畢後，sqlite3_changes() 值會儲存並還原。

這表示如果觸發器中的第一個 INSERT、UPDATE 或 DELETE 陳述式使用 changes() SQL 函數（或類似函數），它會傳回呼叫陳述式開始執行時所設定的值。如果觸發器程式中的第二個或後續陳述式使用它，傳回的值會反映同一個觸發器中前一個 INSERT、UPDATE 或 DELETE 陳述式所修改的列數。

如果在執行 sqlite3_changes() 時，另一個執行緒對同一個資料庫連線進行變更，則傳回的值將無法預測且無意義。

另請參閱

• sqlite3_total_changes() 介面
• count_changes pragma
• changes() SQL 函數
• data_version pragma

---

關閉資料庫連線

int sqlite3_close(sqlite3*);
int sqlite3_close_v2(sqlite3*);

sqlite3_close() 和 sqlite3_close_v2() 常式是 sqlite3 物件的解構式。如果成功銷毀 sqlite3 物件並釋放所有相關資源，則呼叫 sqlite3_close() 和 sqlite3_close_v2() 會傳回 SQLITE_OK。

理想情況下，應用程式應在嘗試關閉物件之前，完成 所有 已準備好的陳述式、關閉 所有 BLOB 處理，並完成所有與 sqlite3 物件相關的 sqlite3_backup 物件。如果資料庫連線與未完成的已準備好陳述式、BLOB 處理和/或未完成的 sqlite3_backup 物件相關聯，則 sqlite3_close() 會讓資料庫連線保持開啟狀態並傳回 SQLITE_BUSY。如果在未完成的已準備好陳述式、未關閉的 BLOB 處理和/或未完成的 sqlite3_backup 的情況下呼叫 sqlite3_close_v2()，它會傳回 SQLITE_OK，但不會立即釋放資料庫連線，而是將資料庫連線標記為不可用的「殭屍」，並在所有已準備好的陳述式完成、所有 BLOB 處理關閉以及所有備份完成後自動釋放資料庫連線。sqlite3_close_v2() 介面旨在與會進行垃圾回收的主機語言搭配使用，且呼叫解構式的順序是任意的。

如果在交易開啟時，sqlite3 物件遭摧毀，交易會自動回滾。

傳遞給 sqlite3_close(C) 和 sqlite3_close_v2(C) 的 C 參數，必須是 NULL 指標或從 sqlite3_open()、sqlite3_open16() 或 sqlite3_open_v2() 取得的 sqlite3 物件指標，且先前未關閉。使用 NULL 指標引數呼叫 sqlite3_close() 或 sqlite3_close_v2() 是無害的空操作。

---

校對所需回呼

int sqlite3_collation_needed(
  sqlite3*,
  void*,
  void(*)(void*,sqlite3*,int eTextRep,const char*)
);
int sqlite3_collation_needed16(
  sqlite3*,
  void*,
  void(*)(void*,sqlite3*,int eTextRep,const void*)
);

為避免在使用資料庫前必須註冊所有校對順序，可以向 資料庫連線 註冊單一回呼函式，在需要未定義的校對順序時呼叫。

如果使用 sqlite3_collation_needed() API 註冊函式，則會將未定義的校對順序名稱傳遞為 UTF-8 編碼字串。如果使用 sqlite3_collation_needed16()，則會以機器原生位元組順序傳遞 UTF-16 名稱。呼叫任一函式都會取代現有的校對所需回呼。

呼叫回呼時，傳遞的第一個引數是傳遞給 sqlite3_collation_needed() 或 sqlite3_collation_needed16() 的第二個引數的拷貝。第二個引數是資料庫連線。第三個引數是 SQLITE_UTF8、SQLITE_UTF16BE 或 SQLITE_UTF16LE 之一，表示所需校對順序函式的最理想形式。第四個參數是所需校對順序的名稱。

回呼函式應使用 sqlite3_create_collation()、sqlite3_create_collation16() 或 sqlite3_create_collation_v2() 註冊所需的校對。

---

查詢結果中資料的來源

const char *sqlite3_column_database_name(sqlite3_stmt*,int);
const void *sqlite3_column_database_name16(sqlite3_stmt*,int);
const char *sqlite3_column_table_name(sqlite3_stmt*,int);
const void *sqlite3_column_table_name16(sqlite3_stmt*,int);
const char *sqlite3_column_origin_name(sqlite3_stmt*,int);
const void *sqlite3_column_origin_name16(sqlite3_stmt*,int);

這些常式提供一種方法來判斷資料庫、資料表和資料表欄位，是 SELECT 陳述式中特定結果欄位的來源。資料庫、資料表或欄位的名稱可以 UTF-8 或 UTF-16 字串回傳。_database_ 常式回傳資料庫名稱，_table_ 常式回傳資料表名稱，而 origin_ 常式回傳欄位名稱。回傳的字串在使用 sqlite3_finalize() 毀損 準備好的陳述式 之前，或在第一次呼叫 sqlite3_step() 自動重新準備陳述式之前，或在不同編碼中再次要求相同資訊之前，都是有效的。

回傳的名稱是資料庫、資料表和欄位的原始未別名的名稱。

這些介面的第一個引數是 準備好的陳述式。這些函式會回傳陳述式回傳的第 N 個結果欄位的資訊，其中 N 是第二個函式引數。對這些常式而言，最左邊的欄位是欄位 0。

如果陳述式回傳的第 N 個欄位是運算式或子查詢，而不是欄位值，則所有這些函式都會回傳 NULL。如果發生記憶體配置錯誤，這些常式也可能會回傳 NULL。否則，它們會回傳查詢結果欄位所萃取的附加資料庫、資料表或欄位的名稱。

與所有其他 SQLite API 一樣，名稱以「16」結尾的 API 會回傳 UTF-16 編碼字串，而其他函式會回傳 UTF-8。

這些 API 僅在使用 SQLITE_ENABLE_COLUMN_METADATA C 預處理器符號編譯函式庫時才可用。

如果兩個或兩個以上的執行緒同時呼叫同一個 準備好的陳述式 和結果欄位的兩個或兩個以上的 欄位資料介面，則結果未定義。

---

查詢結果的宣告資料型態

const char *sqlite3_column_decltype(sqlite3_stmt*,int);
const void *sqlite3_column_decltype16(sqlite3_stmt*,int);

第一個參數是已準備好的陳述式。如果此陳述式是SELECT陳述式，且該SELECT的回傳結果集的第N欄是資料表欄位（不是運算式或子查詢），則會回傳資料表欄位的宣告類型。如果結果集的第N欄是運算式或子查詢，則會回傳NULL指標。回傳的字串總是UTF-8編碼。

例如，給定資料庫架構

CREATE TABLE t1(c1 VARIANT);

和要編譯的下列陳述式

SELECT c1 + 1, c1 FROM t1;

此常式會為第二個結果欄位（i==1）回傳字串「VARIANT」，並為第一個結果欄位（i==0）回傳NULL指標。

SQLite使用動態執行時期型別。因此，欄位宣告為包含特定型別並不表示儲存在該欄位中的資料是宣告的型別。SQLite是強型別語言，但型別是動態的，不是靜態的。型別與個別值相關聯，而不是與用於儲存這些值的容器相關聯。

---

結果集中欄位名稱

const char *sqlite3_column_name(sqlite3_stmt*, int N);
const void *sqlite3_column_name16(sqlite3_stmt*, int N);

這些常式會回傳指定給SELECT陳述式結果集中特定欄位的名稱。sqlite3_column_name()介面會回傳指向以NULL終止的UTF-8字串的指標，而sqlite3_column_name16()會回傳指向以NULL終止的UTF-16字串的指標。第一個參數是實作SELECT陳述式的已準備好的陳述式。第二個參數是欄位編號。最左邊的欄位是編號0。

回傳的字串指標在已準備好的陳述式被sqlite3_finalize()摧毀，或在陳述式由sqlite3_step()的第一次呼叫自動重新準備特定執行，或在對相同欄位下一次呼叫sqlite3_column_name()或sqlite3_column_name16()之前，都是有效的。

如果在處理任一常式期間 (例如在從 UTF-8 轉換為 UTF-16 期間) sqlite3_malloc() 失敗，則會傳回 NULL 指標。

結果欄位的名稱是該欄位的「AS」子句的值 (如果有 AS 子句)。如果沒有 AS 子句，則欄位的名稱未指定，且可能在 SQLite 的不同版本中變更。

---

提交和回滾通知回呼

void *sqlite3_commit_hook(sqlite3*, int(*)(void*), void*);
void *sqlite3_rollback_hook(sqlite3*, void(*)(void *), void*);

sqlite3_commit_hook() 介面註冊一個回呼函式，在交易 提交 時呼叫。先前呼叫 sqlite3_commit_hook() 所設定的任何回呼，針對相同的資料庫連線，都會被覆寫。sqlite3_rollback_hook() 介面註冊一個回呼函式，在交易 回滾 時呼叫。先前呼叫 sqlite3_rollback_hook() 所設定的任何回呼，針對相同的資料庫連線，都會被覆寫。pArg 參數傳遞至回呼。如果提交掛鉤函式上的回呼傳回非零值，則提交會轉換為回滾。

sqlite3_commit_hook(D,C,P) 和 sqlite3_rollback_hook(D,C,P) 函式傳回相同函式在相同的 資料庫連線 D 上的先前呼叫的 P 參數，或 D 上每個函式的第一次呼叫的 NULL。

提交和回滾掛鉤回呼不是可重新輸入的。回呼實作不得執行任何會修改呼叫回呼的資料庫連線的動作。任何修改資料庫連線的動作都必須延後，直到觸發提交或回滾掛鉤的 sqlite3_step() 呼叫完成之後。請注意，執行任何其他 SQL 陳述式，包括 SELECT 陳述式，或僅呼叫 sqlite3_prepare_v2() 和 sqlite3_step() 將會修改資料庫連線，以符合本段中「修改」的意義。

註冊 NULL 函式會停用回呼。

當提交掛鉤回呼常式回傳零時，COMMIT 作業會被允許正常繼續。如果提交掛鉤回傳非零，則 COMMIT 會轉換成 ROLLBACK。回滾掛鉤會在提交掛鉤回傳非零所導致的回滾中被呼叫，就像在任何其他回滾中一樣。

對於此 API 的目的，如果執行明確的「ROLLBACK」陳述式，或錯誤或限制導致發生隱含回滾，則會表示交易已被回滾。如果交易因為資料庫連線關閉而自動回滾，則不會呼叫回滾掛鉤。

另請參閱 sqlite3_update_hook() 介面。

---

執行時期函式庫編譯選項診斷

#ifndef SQLITE_OMIT_COMPILEOPTION_DIAGS
int sqlite3_compileoption_used(const char *zOptName);
const char *sqlite3_compileoption_get(int N);
#else
# define sqlite3_compileoption_used(X) 0
# define sqlite3_compileoption_get(X)  ((void*)0)
#endif

sqlite3_compileoption_used() 函式會回傳 0 或 1，表示在編譯時期是否定義指定的選項。可以從傳遞給 sqlite3_compileoption_used() 的選項名稱中省略 SQLITE_ 前綴。

sqlite3_compileoption_get() 函式允許透過回傳第 N 個編譯時期選項字串來反覆運算在編譯時期定義的選項清單。如果 N 超出範圍，sqlite3_compileoption_get() 會回傳 NULL 指標。SQLITE_ 前綴會從 sqlite3_compileoption_get() 回傳的任何字串中省略。

可以在編譯時期指定 SQLITE_OMIT_COMPILEOPTION_DIAGS 選項來省略診斷函式 sqlite3_compileoption_used() 和 sqlite3_compileoption_get() 的支援。

另請參閱：SQL 函式 sqlite_compileoption_used() 和 sqlite_compileoption_get() 以及 compile_options pragma。

---

判斷 SQL 陳述式是否完整

int sqlite3_complete(const char *sql);
int sqlite3_complete16(const void *sql);

這些常式在命令列輸入期間很有用，用於確定目前輸入的文字是否形成一個完整的 SQL 陳述式，或是在將文字傳送至 SQLite 以進行剖析之前是否需要其他輸入。如果輸入字串看起來像是一個完整的 SQL 陳述式，這些常式會傳回 1。如果陳述式以分號記號結束，且不是格式良好的 CREATE TRIGGER 陳述式的開頭，則判斷為完整。嵌入在字串文字或帶引號的識別名稱或註解中的分號不是獨立的記號（它們是嵌入其中記號的一部分），因此不會視為陳述式終結符。忽略最終分號之後的空白和註解。

如果陳述式不完整，這些常式會傳回 0。如果記憶體配置失敗，則傳回 SQLITE_NOMEM。

這些常式不會剖析 SQL 陳述式，因此不會偵測語法不正確的 SQL。

如果在呼叫 sqlite3_complete16() 之前，尚未使用 sqlite3_initialize() 初始化 SQLite，則 sqlite3_complete16() 會自動呼叫 sqlite3_initialize()。如果初始化失敗，則 sqlite3_complete16() 的傳回值會是非零值，不論輸入的 SQL 是否完整。

傳入 sqlite3_complete() 的輸入必須是零終止 UTF-8 字串。

傳入 sqlite3_complete16() 的輸入必須是零終止 UTF-16 字串，以原生位元組順序排列。

---

定義新的校對順序

int sqlite3_create_collation(
  sqlite3*,
  const char *zName,
  int eTextRep,
  void *pArg,
  int(*xCompare)(void*,int,const void*,int,const void*)
);
int sqlite3_create_collation_v2(
  sqlite3*,
  const char *zName,
  int eTextRep,
  void *pArg,
  int(*xCompare)(void*,int,const void*,int,const void*),
  void(*xDestroy)(void*)
);
int sqlite3_create_collation16(
  sqlite3*,
  const void *zName,
  int eTextRep,
  void *pArg,
  int(*xCompare)(void*,int,const void*,int,const void*)
);

這些函式會新增、移除或修改與 校對 相關聯的 資料庫連線，指定為第一個引數。

對於 sqlite3_create_collation() 和 sqlite3_create_collation_v2()，校對的名稱是 UTF-8 字串；對於 sqlite3_create_collation16()，校對的名稱是 UTF-16 字串，以原生位元組順序排列。根據 sqlite3_strnicmp() 比較相等的校對名稱，會被視為相同的名稱。

第三個引數 (eTextRep) 必須是下列常數之一

• SQLITE_UTF8,
• SQLITE_UTF16LE,
• SQLITE_UTF16BE,
• SQLITE_UTF16，或
• SQLITE_UTF16_ALIGNED.

eTextRep 引數決定傳遞給校對函數回呼 xCompare 的字串編碼。SQLITE_UTF16 和 SQLITE_UTF16_ALIGNED 的 eTextRep 值強制字串為 UTF16，且採用原生位元組順序。SQLITE_UTF16_ALIGNED 的 eTextRep 值強制字串從偶數位元組位址開始。

第四個引數 pArg 是應用程式資料指標，會作為第一個引數傳遞給校對函數回呼。

第五個引數 xCompare 是指向校對函數的指標。可以使用相同名稱但不同的 eTextRep 參數來註冊多個校對函數，而 SQLite 會使用需要最少資料轉換的函數。如果 xCompare 引數為 NULL，則會刪除校對函數。當所有具有相同名稱的校對函數都被刪除後，該校對就不再可用。

校對函數回呼會使用 pArg 應用程式資料指標的副本，以及兩個以 eTextRep 引數指定的編碼字串來呼叫。校對函數回呼的兩個整數參數是兩個字串的長度（以位元組為單位）。如果第一個字串小於、等於或大於第二個字串，校對函數必須分別傳回負數、零或正數。校對函數必須在給定相同輸入時，始終傳回相同的答案。如果兩個或兩個以上的校對函數註冊到同一個校對名稱（使用不同的 eTextRep 值），則在使用等效字串呼叫時，所有函數都必須提供等效的答案。校對函數必須對所有字串 A、B 和 C 遵守下列屬性

1. 如果 A==B，則 B==A。
2. 如果 A==B 且 B==C，則 A==C。
3. 如果 A<B，則 B>A。
4. 如果 A<B 且 B<C，則 A<C。

如果校對函式不符合以上任何限制，且該校對函式已註冊並使用，則 SQLite 的行為未定義。

sqlite3_create_collation_v2() 的運作方式類似於 sqlite3_create_collation()，但新增了在刪除校對函式時會對 pArg 呼叫 xDestroy 回呼。校對函式會在被後續呼叫校對建立函式覆寫時，或使用 資料庫連線 關閉 sqlite3_close() 時刪除。

如果 sqlite3_create_collation_v2() 函式失敗，則不會呼叫 xDestroy 回呼。使用非 NULL xDestroy 參數呼叫 sqlite3_create_collation_v2() 的應用程式應檢查回傳碼，並自行處理應用程式資料指標，而不是期望 SQLite 替它們處理。這與其他所有 SQLite 介面不同。這種不一致性很不幸，但無法在不破壞向後相容性的情況下進行變更。

另請參閱：sqlite3_collation_needed() 和 sqlite3_collation_needed16()。

---

建立和刪除 VFS 檔名

sqlite3_filename sqlite3_create_filename(
  const char *zDatabase,
  const char *zJournal,
  const char *zWal,
  int nParam,
  const char **azParam
);
void sqlite3_free_filename(sqlite3_filename);

這些介面提供給 VFS shim 實作使用，在該情境之外沒有用處。

sqlite3_create_filename(D,J,W,N,P) 會配置記憶體來儲存資料庫檔名 D 的版本，其中包含對應的日誌檔 J 和 WAL 檔 W，以及陣列 P 中的 N 個 URI 參數金鑰/值對。sqlite3_create_filename(D,J,W,N,P) 的結果是指向資料庫檔名的指標，可以安全地傳遞給下列常式：

• sqlite3_uri_parameter(),
• sqlite3_uri_boolean(),
• sqlite3_uri_int64(),
• sqlite3_uri_key(),
• sqlite3_filename_database(),
• sqlite3_filename_journal() 或
• sqlite3_filename_wal().

如果發生記憶體配置錯誤，sqlite3_create_filename() 可能會傳回 NULL 指標。從 sqlite3_create_filename(X) 取得的記憶體必須透過對應的 sqlite3_free_filename(Y) 呼叫來釋放。

sqlite3_create_filename(D,J,W,N,P) 中的 P 參數應該是 2*N 個指向字串的指標陣列。此陣列中的每一對指標對應於查詢參數的鍵和值。如果 N 為零，P 參數可以是 NULL 指標。P 陣列中的 2*N 個指標都不能是 NULL 指標，而鍵指標不應該是空字串。sqlite3_create_filename(D,J,W,N,P) 中的 D、J 或 W 參數都不能是 NULL 指標，但它們可以是空字串。

sqlite3_free_filename(Y) 常式會釋放先前從 sqlite3_create_filename() 取得的記憶體配置。在 Y 為 NULL 指標的情況下呼叫 sqlite3_free_filename(Y) 是無害的空操作。

如果 sqlite3_free_filename(Y) 的 Y 參數不是 NULL 指標或先前從 sqlite3_create_filename() 取得的指標，可能會發生堆損毀或段落錯誤等不良情況。在呼叫 sqlite3_free_filename(Y) 之後，不應再使用 Y 值。這表示如果已使用 Y 呼叫 VFS 的 sqlite3_vfs.xOpen() 方法，則在呼叫 sqlite3_free_filename(Y) 之前，也應該呼叫對應的 [sqlite3_module.xClose() 方法。

---

註冊虛擬表格實作

int sqlite3_create_module(
  sqlite3 *db,               /* SQLite connection to register module with */
  const char *zName,         /* Name of the module */
  const sqlite3_module *p,   /* Methods for the module */
  void *pClientData          /* Client data for xCreate/xConnect */
);
int sqlite3_create_module_v2(
  sqlite3 *db,               /* SQLite connection to register module with */
  const char *zName,         /* Name of the module */
  const sqlite3_module *p,   /* Methods for the module */
  void *pClientData,         /* Client data for xCreate/xConnect */
  void(*xDestroy)(void*)     /* Module destructor function */
);

這些常式用於註冊新的 虛擬表格模組 名稱。在使用模組建立新的 虛擬表格 以及在使用模組的既有 虛擬表格 之前，必須註冊模組名稱。

模組名稱註冊在第一個參數指定的資料庫連線上。模組名稱由第二個參數給出。第三個參數是指向虛擬表格模組實作的指標。第四個參數是任意用戶端資料指標，當建立或重新初始化新的虛擬表格時，會傳遞到虛擬表格模組的xCreate和xConnect方法中。

sqlite3_create_module_v2()介面有一個第五個參數，是指向pClientData的解構函式的指標。當SQLite不再需要pClientData指標時，SQLite會呼叫解構函式（如果它不是NULL）。如果呼叫sqlite3_create_module_v2()失敗，也會呼叫解構函式。sqlite3_create_module()介面等同於具有NULL解構函式的sqlite3_create_module_v2()。

如果第三個參數（指向sqlite3_module物件的指標）為NULL，則不會建立新的模組，且任何具有相同名稱的現有模組都會被捨棄。

另請參閱：sqlite3_drop_modules()

---

錯誤代碼和訊息

int sqlite3_errcode(sqlite3 *db);
int sqlite3_extended_errcode(sqlite3 *db);
const char *sqlite3_errmsg(sqlite3*);
const void *sqlite3_errmsg16(sqlite3*);
const char *sqlite3_errstr(int);
int sqlite3_error_offset(sqlite3 *db);

如果與資料庫連線D關聯的最近sqlite3_* API呼叫失敗，則sqlite3_errcode(D)介面會傳回該API呼叫的數字結果代碼或延伸結果代碼。sqlite3_extended_errcode()介面相同，但它總是傳回延伸結果代碼，即使已停用延伸結果代碼也是如此。

sqlite3_errcode() 和/或 sqlite3_extended_errcode() 所傳回的值可能會在每次 API 呼叫時有所不同。但有些介面保證絕不會變更錯誤碼的值。會保留錯誤碼的介面包括下列項目

• sqlite3_errcode()
• sqlite3_extended_errcode()
• sqlite3_errmsg()
• sqlite3_errmsg16()
• sqlite3_error_offset()

sqlite3_errmsg() 和 sqlite3_errmsg16() 會傳回描述錯誤的英文文字，分別以 UTF-8 或 UTF-16 編碼，或是在沒有錯誤訊息可用的情況下傳回 NULL。（請參閱 SQLite 如何處理 無效 UTF 來了解此規則的例外情況。）用來儲存錯誤訊息字串的記憶體由內部管理。應用程式不需要擔心釋放結果。不過，後續呼叫其他 SQLite 介面函式可能會覆寫或取消配置錯誤字串。

sqlite3_errstr(E) 介面會傳回描述 結果碼 E 的英文文字，以 UTF-8 編碼，或是在 E 不是有文字錯誤訊息可用的結果碼時傳回 NULL。用來儲存錯誤訊息字串的記憶體由內部管理，應用程式不得釋放。

如果最近的錯誤會參照輸入 SQL 中的特定權杖，則 sqlite3_error_offset() 介面會傳回該權杖開頭的位元組偏移量。sqlite3_error_offset() 所傳回的位元組偏移量假設輸入 SQL 是 UTF8。如果最近的錯誤不會參照輸入 SQL 中的特定權杖，則 sqlite3_error_offset() 函式會傳回 -1。

當序列化 執行緒模式 正在使用時，可能會在第一次錯誤和呼叫這些介面之間的時間內，在不同的執行緒上發生第二次錯誤。當發生這種情況時，將會報告第二次錯誤，因為這些介面總是報告最新的結果。為避免這種情況，每個執行緒可以在開始使用 D 之前呼叫 sqlite3_mutex_enter(sqlite3_db_mutex(D)) 來取得 資料庫連線 D 的獨佔使用權，並在完成所有呼叫此處列出的介面後呼叫 sqlite3_mutex_leave(sqlite3_db_mutex(D))。

如果介面因 SQLITE_MISUSE 而失敗，表示應用程式錯誤呼叫介面。在這種情況下，錯誤代碼和訊息可能會設定，也可能不會設定。

---

擷取陳述式 SQL

const char *sqlite3_sql(sqlite3_stmt *pStmt);
char *sqlite3_expanded_sql(sqlite3_stmt *pStmt);
#ifdef SQLITE_ENABLE_NORMALIZE
const char *sqlite3_normalized_sql(sqlite3_stmt *pStmt);
#endif

如果 P 是由 sqlite3_prepare_v2()、sqlite3_prepare_v3()、sqlite3_prepare16_v2() 或 sqlite3_prepare16_v3() 所建立，sqlite3_sql(P) 介面會傳回一個指標，指向用於建立 已準備陳述式 P 的 UTF-8 SQL 文字的副本。sqlite3_expanded_sql(P) 介面會傳回一個指標，指向包含已準備陳述式 P 的 SQL 文字的 UTF-8 字串，其中 繫結參數 已展開。sqlite3_normalized_sql(P) 介面會傳回一個指標，指向包含已準備陳述式 P 的正規化 SQL 文字的 UTF-8 字串。用於正規化 SQL 陳述式的語意未指定，且可能會變更。至少，文字值會以適當的佔位符取代。

例如，如果使用 SQL 文字「SELECT $abc,:xyz」建立準備陳述，且參數 $abc 繫結到整數 2345，而參數 :xyz 未繫結，則 sqlite3_sql() 會傳回原始字串「SELECT $abc,:xyz」，但 sqlite3_expanded_sql() 會傳回「SELECT 2345,NULL」。

如果沒有足夠的記憶體來儲存結果，或如果結果會超過 SQLITE_LIMIT_LENGTH 所決定的最大字串長度，則 sqlite3_expanded_sql() 介面會傳回 NULL。

編譯時期選項 SQLITE_TRACE_SIZE_LIMIT 會限制繫結參數擴充的大小。編譯時期選項 SQLITE_OMIT_TRACE 會導致 sqlite3_expanded_sql() 永遠傳回 NULL。

sqlite3_sql(P) 和 sqlite3_normalized_sql(P) 傳回的字串由 SQLite 管理，且會在準備陳述完成時自動釋放。另一方面，sqlite3_expanded_sql(P) 傳回的字串是由 sqlite3_malloc() 取得，且必須由應用程式傳遞給 sqlite3_free() 釋放。

sqlite3_normalized_sql() 介面僅在定義編譯時期選項 SQLITE_ENABLE_NORMALIZE 時才可用。

---

轉譯檔案名稱

const char *sqlite3_filename_database(sqlite3_filename);
const char *sqlite3_filename_journal(sqlite3_filename);
const char *sqlite3_filename_wal(sqlite3_filename);

這些常式可供 自訂 VFS 實作 在主資料庫檔案、記錄檔和 WAL 檔案之間轉譯檔案名稱。

如果 F 是 SQLite 核心傳遞到 VFS 的 sqlite 資料庫檔案、記錄檔或 WAL 檔案名稱，則 sqlite3_filename_database(F) 會傳回對應資料庫檔案的名稱。

如果 F 是 SQLite 核心傳遞到 VFS 的 sqlite 資料庫檔案、日誌檔案或 WAL 檔案的名稱，或者如果 F 是從 sqlite3_db_filename() 取得的資料庫檔案名稱，則 sqlite3_filename_journal(F) 會傳回對應的回滾日誌檔案名稱。

如果 F 是 SQLite 核心傳遞到 VFS 的 sqlite 資料庫檔案、日誌檔案或 WAL 檔案的名稱，或者如果 F 是從 sqlite3_db_filename() 取得的資料庫檔案名稱，則 sqlite3_filename_wal(F) 會傳回對應的 WAL 檔案名稱。

在上述所有情況中，如果 F 不是從 SQLite 核心傳遞到 VFS 的資料庫、日誌或 WAL 檔案名稱，而且 F 不是 sqlite3_db_filename() 的傳回值，則結果未定義，而且很可能是記憶體存取違規。

---

記憶體配置子系統

void *sqlite3_malloc(int);
void *sqlite3_malloc64(sqlite3_uint64);
void *sqlite3_realloc(void*, int);
void *sqlite3_realloc64(void*, sqlite3_uint64);
void sqlite3_free(void*);
sqlite3_uint64 sqlite3_msize(void*);

SQLite 核心使用這三個常式處理所有其內部記憶體配置需求。前一句中的「核心」不包括作業系統特定的 VFS 實作。Windows VFS 使用原生 malloc() 和 free() 處理某些作業。

sqlite3_malloc() 常式傳回一個記憶體區塊的指標，長度至少為 N 位元組，其中 N 是參數。如果 sqlite3_malloc() 無法取得足夠的可用記憶體，它會傳回一個 NULL 指標。如果傳遞給 sqlite3_malloc() 的參數 N 為零或負值，則 sqlite3_malloc() 會傳回一個 NULL 指標。

sqlite3_malloc64(N) 常式的運作方式與 sqlite3_malloc(N) 相同，只不過 N 是未簽名的 64 位元整數，而不是有簽名的 32 位元整數。

呼叫 sqlite3_free() 使用先前由 sqlite3_malloc() 或 sqlite3_realloc() 傳回的指標，釋放該記憶體以便重複使用。如果呼叫 sqlite3_free() 使用 NULL 指標，則為無動作例程。將 NULL 指標傳遞給 sqlite3_free() 無害。釋放後，不應讀取或寫入記憶體。即使讀取先前釋放的記憶體，也可能導致分段錯誤或其他嚴重錯誤。如果呼叫 sqlite3_free() 使用非 NULL 指標，但並非從 sqlite3_malloc() 或 sqlite3_realloc() 取得，則可能導致記憶體毀損、分段錯誤或其他嚴重錯誤。

sqlite3_realloc(X,N) 介面嘗試將先前記憶體配置 X 調整大小，至少為 N 位元組。如果 sqlite3_realloc(X,N) 的 X 參數為 NULL 指標，則其行為與呼叫 sqlite3_malloc(N) 相同。如果 sqlite3_realloc(X,N) 的 N 參數為零或負數，則行為與呼叫 sqlite3_free(X) 完全相同。sqlite3_realloc(X,N) 傳回指向至少 N 位元組大小的記憶體配置的指標，或在記憶體不足時傳回 NULL。如果 M 是先前配置的大小，則將先前配置的 min(N,M) 位元組複製到 sqlite3_realloc(X,N) 傳回的緩衝區開頭，並釋放先前配置。如果 sqlite3_realloc(X,N) 傳回 NULL 且 N 為正數，則不釋放先前配置。

sqlite3_realloc64(X,N) 介面運作方式與 sqlite3_realloc(X,N) 相同，但 N 為 64 位元無號整數，而非 32 位元有號整數。

如果 X 是先前從 sqlite3_malloc()、sqlite3_malloc64()、sqlite3_realloc() 或 sqlite3_realloc64() 取得的記憶體配置，則 sqlite3_msize(X) 會傳回該記憶體配置的大小（以位元組為單位）。sqlite3_msize(X) 傳回的值可能會大於在配置 X 時要求的位元組數。如果 X 是 NULL 指標，則 sqlite3_msize(X) 會傳回零。如果 X 指向的不是記憶體配置的開頭，或者它指向先前有效的記憶體配置（但現已釋放），則 sqlite3_msize(X) 的行為未定義，且可能會造成損害。

sqlite3_malloc()、sqlite3_realloc()、sqlite3_malloc64() 和 sqlite3_realloc64() 傳回的記憶體總是對齊至至少 8 位元組邊界，或者在使用 SQLITE_4_BYTE_ALIGNED_MALLOC 編譯時期選項時對齊至 4 位元組邊界。

傳遞給 sqlite3_free() 和 sqlite3_realloc() 的指標引數必須為 NULL，或者必須是從先前呼叫 sqlite3_malloc() 或 sqlite3_realloc() 取得且尚未釋放的指標。

應用程式在使用 sqlite3_free() 或 sqlite3_realloc() 釋放記憶體區塊後，不得讀取或寫入該區塊的任何部分。

---

執行查詢的便利常式

int sqlite3_get_table(
  sqlite3 *db,          /* An open database */
  const char *zSql,     /* SQL to be evaluated */
  char ***pazResult,    /* Results of the query */
  int *pnRow,           /* Number of result rows written here */
  int *pnColumn,        /* Number of result columns written here */
  char **pzErrmsg       /* Error msg written here */
);
void sqlite3_free_table(char **result);

這是保留以維持向後相容性的舊式介面。不建議使用此介面。

定義：結果表格是由 sqlite3_get_table() 介面建立的記憶體資料結構。結果表格會記錄一個或多個查詢的完整查詢結果。

此表格在概念上具有多列和多行。但這些數字並非結果表格本身的一部分。這些數字是分開取得的。假設 N 是列數，M 是行數。

結果表格是一個指向零終止 UTF-8 字串的指標陣列。陣列中有 (N+1)*M 個元素。前 M 個指標指向包含欄位名稱的零終止字串。其餘的項目都指向查詢結果。NULL 值會產生 NULL 指標。所有其他值都是以 sqlite3_column_text() 傳回的 UTF-8 零終止字串表示。

結果表格可能包含一個或多個記憶體配置。將結果表格直接傳遞給 sqlite3_free() 並不安全。應該使用 sqlite3_free_table() 來解除結果表格的配置。

作為結果表格格式的範例，假設查詢結果如下

Name        | Age
-----------------------
Alice       | 43
Bob         | 28
Cindy       | 21

有兩個欄位 (M==2) 和三列 (N==3)。因此，結果表格有 8 個項目。假設結果表格儲存在名為 azResult 的陣列中。那麼 azResult 會包含此內容

azResult[0] = "Name";
azResult[1] = "Age";
azResult[2] = "Alice";
azResult[3] = "43";
azResult[4] = "Bob";
azResult[5] = "28";
azResult[6] = "Cindy";
azResult[7] = "21";

sqlite3_get_table() 函式會評估其第二個參數的零終止 UTF-8 字串中一個或多個以分號分隔的 SQL 陳述式，並將結果表格傳回其第三個參數中指定的指標。

應用程式完成 sqlite3_get_table() 的結果後，它必須將結果表格指標傳遞給 sqlite3_free_table() 以釋放已配置的記憶體。由於 sqlite3_get_table() 中 sqlite3_malloc() 的發生方式，呼叫函式不得嘗試直接呼叫 sqlite3_free()。只有 sqlite3_free_table() 能夠適當且安全地釋放記憶體。

sqlite3_get_table() 介面實作為 sqlite3_exec() 的包裝器。sqlite3_get_table() 常式無法存取 SQLite 的任何內部資料結構。它只使用這裡定義的公開介面。因此，發生在內部 sqlite3_exec() 呼叫之外的包裝層中的錯誤不會反映在後續對 sqlite3_errcode() 或 sqlite3_errmsg() 的呼叫中。

---

函式輔助資料

void *sqlite3_get_auxdata(sqlite3_context*, int N);
void sqlite3_set_auxdata(sqlite3_context*, int N, void*, void (*)(void*));

這些函式可用於（非聚合）SQL 函式，以將輔助資料與引數值關聯。如果在查詢執行期間將同一個引數值傳遞給同一個 SQL 函式的多個呼叫，在某些情況下，關聯的輔助資料可能會被保留。這可能在正規表示式比對函式中很有用。正規表示式的編譯版本可以儲存為與模式字串關聯的輔助資料。然後，只要模式字串保持不變，編譯的正規表示式就可以在同一個函式的多個呼叫中重複使用。

sqlite3_get_auxdata(C,N) 介面會傳回一個指向輔助資料的指標，該資料是由 sqlite3_set_auxdata(C,N,P,X) 函式與應用程式定義函式的第 N 個引數值關聯。對於最左邊的函式引數，N 為零。如果沒有與函式引數關聯的輔助資料，sqlite3_get_auxdata(C,N) 介面會傳回一個 NULL 指標。

sqlite3_set_auxdata(C,N,P,X) 介面會將 P 儲存為應用程式定義函式的第 N 個引數的輔助資料。後續對 sqlite3_get_auxdata(C,N) 的呼叫會從最近一次的 sqlite3_set_auxdata(C,N,P,X) 呼叫傳回 P，如果輔助資料仍然有效，或在輔助資料已被捨棄時傳回 NULL。在每次呼叫 sqlite3_set_auxdata(C,N,P,X)（其中 X 不為 NULL）之後，當輔助資料被捨棄時，SQLite 會使用參數 P 精確地呼叫一次終結函式 X。SQLite 可以隨時捨棄輔助資料，包括

• 在對應的函式參數變更時，或
• 在對 SQL 陳述式呼叫 sqlite3_reset() 或 sqlite3_finalize() 時，或
• 在對同一個參數再次呼叫 sqlite3_set_auxdata() 時，或
• 在原始 sqlite3_set_auxdata() 呼叫期間發生記憶體配置錯誤時。
• 在原始 sqlite3_set_auxdata() 呼叫期間，如果函式是在查詢規劃期間評估，而不是在查詢執行期間評估，就像有時會發生在 SQLITE_ENABLE_STAT4 中一樣。

特別注意最後兩個項目符號。在 sqlite3_set_auxdata(C,N,P,X) 中的解構函數 X 可能會在 sqlite3_set_auxdata() 介面傳回之前立即呼叫。因此，sqlite3_set_auxdata() 應在函數實作的結尾附近呼叫，且在呼叫 sqlite3_set_auxdata() 之後，函數實作不應使用 P。此外，如果在呼叫 sqlite3_set_auxdata() 期間發生記憶體不足的情況，或是在查詢規劃期間而非查詢執行期間評估函數，則在對應呼叫 sqlite3_set_auxdata() 之後立即呼叫 sqlite3_get_auxdata() 仍可能會傳回 NULL。

在實務上，輔助資料會保留在編譯時期常數的函數參數的函數呼叫之間，包括文字值和 參數，以及由相同參數組成的運算式。

這些介面的 N 參數值應為非負值。未來的強化功能可能會使用負 N 值來定義新的函數快取行為類型。

這些常式必須從執行 SQL 函數的相同執行緒呼叫。

另請參閱：sqlite3_get_clientdata() 和 sqlite3_set_clientdata()。

---

資料庫連線用戶端資料

void *sqlite3_get_clientdata(sqlite3*,const char*);
int sqlite3_set_clientdata(sqlite3*, const char*, void*, void(*)(void*));

這些函數用於將一個或多個命名指標與 資料庫連線 關聯。呼叫 sqlite3_set_clientdata(D,N,P,X) 會導致指標 P 附加到 資料庫連線 D，並使用名稱 N。後續呼叫 sqlite3_get_clientdata(D,N) 會傳回指標 P 的副本，或是在先前沒有使用 D 和 N 的相同值呼叫 sqlite3_set_clientdata() 的情況下傳回 NULL 指標。名稱會使用 strcmp() 進行比較，因此會區分大小寫。

如果 P 和 X 都是非 NULL，則會在以下第一個事件發生時，以引數 P 呼叫解構函數 X

• 在嘗試註冊指標 P 的 sqlite3_set_clientdata() 呼叫期間發生記憶體不足錯誤。
• 使用相同的 D 和 N 參數進行後續的 sqlite3_set_clientdata(D,N,P,X) 呼叫。
• 資料庫連線關閉。SQLite 不保證會以何種順序呼叫解構函式，只保證在資料庫連線關閉程序的某個時間點，所有解構函式都會被呼叫一次且僅一次。

SQLite 除了在適當的時間呼叫解構函式對客戶端資料執行操作外，不會對客戶端資料做任何其他操作。客戶端資料的預期用途是提供一個機制，讓包裝函式庫可以儲存有關 SQLite 資料庫連線的其他資訊。

可以附加到單一資料庫連線的不同客戶端資料指標（具有不同名稱）的數量沒有限制（除了可用記憶體之外）。但是，此實作已針對僅有一個或兩個不同的客戶端資料名稱的情況進行最佳化。建議應用程式和包裝函式庫不要使用超過一個客戶端資料名稱。

沒有辦法列舉與資料庫連線相關聯的客戶端資料指標。N 參數可以視為一個密鑰，只有知道密鑰的程式碼才能存取相關資料。

安全性警告：這些介面不應公開在指令碼語言或其他情況中，在這些情況下，攻擊者可能會呼叫它們。任何可以呼叫這些介面的代理程式，可能也可以控制程序。

資料庫連線客戶端資料僅適用於 SQLite 版本 3.44.0（2023-11-01）及更新版本。

另請參閱：sqlite3_set_auxdata() 和 sqlite3_get_auxdata()。

---

對堆積大小施加限制

sqlite3_int64 sqlite3_soft_heap_limit64(sqlite3_int64 N);
sqlite3_int64 sqlite3_hard_heap_limit64(sqlite3_int64 N);

這些介面對單一程序中所有資料庫連線將使用的堆積記憶體量施加限制。

sqlite3_soft_heap_limit64() 介面設定和/或查詢 SQLite 可配置的堆記憶體上限。SQLite 透過減少頁面快取中所保留頁面的數量，在堆記憶體使用量接近上限時，努力將堆記憶體使用率保持在軟堆疊限制以下。軟堆疊限制之所以稱為「軟」，是因為即使 SQLite 努力保持在限制以下，它也會超過限制，而不是產生 SQLITE_NOMEM 錯誤。換句話說，軟堆疊限制僅供參考。

sqlite3_hard_heap_limit64(N) 介面設定一個硬上限 N 位元組，表示將配置的記憶體量。sqlite3_hard_heap_limit64(N) 介面類似於 sqlite3_soft_heap_limit64(N)，但當達到硬堆疊限制時，記憶體配置會失敗。

sqlite3_soft_heap_limit64() 和 sqlite3_hard_heap_limit64() 的傳回值是呼叫前的堆疊限制大小，或在發生錯誤時為負值。如果參數 N 為負值，則堆疊限制不會變更。因此，可以透過呼叫 sqlite3_soft_heap_limit64(-1) 或 sqlite3_hard_heap_limit(-1) 來判斷堆疊限制的目前大小。

將堆疊限制設定為零會停用堆疊限制器機制。

軟堆疊限制不得大於硬堆疊限制。如果啟用硬堆疊限制，且 sqlite3_soft_heap_limit(N) 被呼叫時，N 的值大於硬堆疊限制，則軟堆疊限制會設定為硬堆疊限制的值。只要硬堆疊限制啟用，就會自動啟用軟堆疊限制。當呼叫 sqlite3_hard_heap_limit64(N) 時，如果軟堆疊限制超出 1..N 的範圍，則軟堆疊限制會設定為 N。在啟用硬堆疊限制時呼叫 sqlite3_soft_heap_limit64(0) 會使軟堆疊限制等於硬堆疊限制。

記憶體配置限制也可以使用 PRAGMA soft_heap_limit 和 PRAGMA hard_heap_limit 調整。

如果下列條件有一個或多個為真，則在目前的實作中不會強制執行堆積限制

• 限制值設為零。
• 使用 sqlite3_config(SQLITE_CONFIG_MEMSTATUS,...) 啟動時間選項和 SQLITE_DEFAULT_MEMSTATUS 編譯時間選項的組合來停用記憶體計算。
• 使用 sqlite3_config(SQLITE_CONFIG_PCACHE2,...) 指定替代頁面快取實作。
• 頁面快取從 sqlite3_config(SQLITE_CONFIG_PAGECACHE,...) 提供的自己的記憶體池配置，而不是從堆積配置。

SQLite 在哪些情況下會強制執行堆積限制可能會在 SQLite 的未來版本中變更。

---

初始化 SQLite 函式庫

int sqlite3_initialize(void);
int sqlite3_shutdown(void);
int sqlite3_os_init(void);
int sqlite3_os_end(void);

sqlite3_initialize() 常式會初始化 SQLite 函式庫。sqlite3_shutdown() 常式會釋放由 sqlite3_initialize() 配置的任何資源。這些常式旨在協助嵌入式系統的程序初始化和關閉。使用 SQLite 的工作站應用程式通常不需要呼叫這些常式。

如果 sqlite3_initialize() 是在程序生命週期中第一次呼叫，或者如果 sqlite3_initialize() 是在呼叫 sqlite3_shutdown() 之後第一次呼叫，則呼叫 sqlite3_initialize() 是「有效」呼叫。只有 sqlite3_initialize() 的有效呼叫才會執行任何初始化。所有其他呼叫都是無害的空操作。

如果 sqlite3_shutdown() 是自上次 sqlite3_initialize() 以來第一次呼叫 sqlite3_shutdown()，則呼叫 sqlite3_shutdown() 是「有效」呼叫。只有 sqlite3_shutdown() 的有效呼叫才會執行任何去初始化。所有其他對 sqlite3_shutdown() 的有效呼叫都是無害的空操作。

sqlite3_initialize() 介面是執行緒安全的，但 sqlite3_shutdown() 則不是。sqlite3_shutdown() 介面只能從單一執行緒呼叫。在呼叫 sqlite3_shutdown() 之前，所有開啟的資料庫連線都必須關閉，且所有其他 SQLite 資源都必須解除配置。

在其他事項中，sqlite3_initialize() 會呼叫 sqlite3_os_init()。類似地，sqlite3_shutdown() 會呼叫 sqlite3_os_end()。

sqlite3_initialize() 常式在成功時傳回SQLITE_OK。如果因為某些原因，sqlite3_initialize() 無法初始化函式庫（也許它無法配置必要的資源，例如互斥鎖），它會傳回錯誤碼，而非SQLITE_OK。

sqlite3_initialize() 常式由許多其他 SQLite 介面在內部呼叫，因此應用程式通常不需要直接呼叫 sqlite3_initialize()。例如，sqlite3_open() 會呼叫 sqlite3_initialize()，因此如果 SQLite 函式庫尚未初始化，則在呼叫sqlite3_open() 時會自動初始化。但是，如果 SQLite 是以SQLITE_OMIT_AUTOINIT 編譯時間選項編譯，則會略過對 sqlite3_initialize() 的自動呼叫，且應用程式必須在使用任何其他 SQLite 介面前直接呼叫 sqlite3_initialize()。為了最大的可移植性，建議應用程式在使用任何其他 SQLite 介面前，始終直接呼叫 sqlite3_initialize()。SQLite 的未來版本可能需要這樣做。換句話說，當 SQLite 以SQLITE_OMIT_AUTOINIT編譯時所表現出的行為，可能會在 SQLite 的某些未來版本中成為預設行為。

sqlite3_os_init() 常式會執行 SQLite 函式庫的作業系統特定初始化。sqlite3_os_end() 常式會取消 sqlite3_os_init() 的效果。這些常式執行的典型任務包括配置或解除配置靜態資源、初始化全域變數、設定預設sqlite3_vfs 模組，或使用sqlite3_config()設定預設組態。

應用程式不應直接呼叫 sqlite3_os_init() 或 sqlite3_os_end()。應用程式應只呼叫 sqlite3_initialize() 和 sqlite3_shutdown()。當編譯 SQLite 至 Unix、Windows 或 OS/2 時，sqlite3_os_init() 介面會由 sqlite3_initialize() 自動呼叫，而 sqlite3_os_end() 則會由 sqlite3_shutdown() 呼叫。當 編譯至其他平台（使用 SQLITE_OS_OTHER=1 編譯時間選項）時，應用程式必須提供適當的 sqlite3_os_init() 和 sqlite3_os_end() 實作。應用程式提供的 sqlite3_os_init() 或 sqlite3_os_end() 實作必須在成功時傳回 SQLITE_OK，在失敗時傳回其他 錯誤碼。

---

中斷長時間執行查詢

void sqlite3_interrupt(sqlite3*);
int sqlite3_is_interrupted(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_is_interrupted(D) 介面來判斷中斷是否目前對 資料庫連線 D 生效。如果中斷目前生效，則傳回 1，否則傳回 0。

---

SQL 關鍵字檢查

int sqlite3_keyword_count(void);
int sqlite3_keyword_name(int,const char**,int*);
int sqlite3_keyword_check(const char*,int);

這些常式提供存取 SQLite 辨識的 SQL 語言關鍵字組的管道。應用程式可以使用這些常式來判斷特定識別碼是否需要跳脫（例如，用雙引號括起來），以免混淆剖析器。

sqlite3_keyword_count() 介面傳回 SQLite 了解的不同關鍵字數量。

sqlite3_keyword_name(N,Z,L) 介面會找出第 N 個關鍵字，並讓 *Z 指向以 UTF8 表示的關鍵字，並將關鍵字中的位元組數寫入 *L。*Z 指向的字串並非零終止。如果 N 在界限內，sqlite3_keyword_name(N,Z,L) 常式會傳回 SQLITE_OK；否則傳回 SQLITE_ERROR。如果 Z 或 L 是 NULL 或無效指標，則呼叫 sqlite3_keyword_name(N,Z,L) 會導致未定義的行為。

sqlite3_keyword_check(Z,L) 介面會檢查 Z 指向的 L 位元組 UTF8 識別碼是否為關鍵字，如果是則傳回非零值，否則傳回零。

SQLite 使用的剖析器很寬容。通常只要不會造成剖析歧義，就可以將關鍵字用作識別碼。例如，SQLite 接受陳述式「CREATE TABLE BEGIN(REPLACE,PRAGMA,END);」，並建立一個名為「BEGIN」的新表格，其中有三個欄位，分別名為「REPLACE」、「PRAGMA」和「END」。不過，最佳實務做法是避免將關鍵字用作識別碼。避免關鍵字名稱衝突的常見技巧包括

• 將所有識別名稱置於雙引號內。這是轉譯識別名稱的官方 SQL 方式。
• 將識別名稱置於 [...] 內。這不是標準 SQL，但這是 SQL Server 所做的，因此許多程式設計師使用此技術。
• 每個識別名稱以字母「Z」開頭，因為沒有 SQL 關鍵字以「Z」開頭。
• 在每個識別名稱中包含數字。

請注意，SQLite 理解的關鍵字數量可能取決於編譯時期選項。例如，如果 SQLite 是使用 -DSQLITE_OMIT_VACUUM 選項編譯的，則「VACUUM」不是關鍵字。此外，新的關鍵字可能會新增至未來版本的 SQLite。

---

執行時期函式庫版本號碼

SQLITE_EXTERN const char sqlite3_version[];
const char *sqlite3_libversion(void);
const char *sqlite3_sourceid(void);
int sqlite3_libversion_number(void);

這些介面提供與 SQLITE_VERSION、SQLITE_VERSION_NUMBER 和 SQLITE_SOURCE_ID C 預處理器巨集相同資訊，但與函式庫相關，而不是標頭檔。謹慎的程式設計師可能會在他們的應用程式中包含 assert() 陳述式，以驗證這些介面回傳的值與標頭中的巨集相符，並因此確保應用程式已使用相符的函式庫和標頭檔編譯。

assert( sqlite3_libversion_number()==SQLITE_VERSION_NUMBER );
assert( strncmp(sqlite3_sourceid(),SQLITE_SOURCE_ID,80)==0 );
assert( strcmp(sqlite3_libversion(),SQLITE_VERSION)==0 );

sqlite3_version[] 字串常數包含 SQLITE_VERSION 巨集的文字。sqlite3_libversion() 函式傳回指向 sqlite3_version[] 字串常數的指標。sqlite3_libversion() 函式提供給 DLL 使用，因為 DLL 使用者通常無法直接存取 DLL 內的字串常數。sqlite3_libversion_number() 函式傳回等於 SQLITE_VERSION_NUMBER 的整數。sqlite3_sourceid() 函式傳回指向字串常數的指標，其值與 SQLITE_SOURCE_ID C 預處理器巨集相同。除非 SQLite 是使用 合併 的編輯副本建置，否則雜湊的最後四個字元可能與 SQLITE_SOURCE_ID 不同。

另請參閱：sqlite_version() 和 sqlite_source_id()。

---

記憶體配置器統計

sqlite3_int64 sqlite3_memory_used(void);
sqlite3_int64 sqlite3_memory_highwater(int resetFlag);

SQLite 提供這兩個介面來回報 sqlite3_malloc()、sqlite3_free() 和 sqlite3_realloc() 常式的狀態，這些常式組成內建的記憶體配置子系統。

例程 sqlite3_memory_used() 傳回目前未釋放（已配置但未釋放）的記憶體位元組數。例程 sqlite3_memory_highwater() 傳回自上次重設高水位標記以來 sqlite3_memory_used() 的最大值。由 sqlite3_memory_used() 和 sqlite3_memory_highwater() 傳回的值包括 SQLite 在其 sqlite3_malloc() 實作中新增的任何開銷，但不包括 sqlite3_malloc() 可能呼叫的任何底層系統函式庫例程所新增的開銷。

如果且僅當 sqlite3_memory_highwater() 的參數為 true，才會將記憶體高水位標記重設為 sqlite3_memory_used() 的目前值。由 sqlite3_memory_highwater(1) 傳回的值是重設前的最高水位標記。

---

格式化字串列印函式

char *sqlite3_mprintf(const char*,...);
char *sqlite3_vmprintf(const char*, va_list);
char *sqlite3_snprintf(int,char*,const char*, ...);
char *sqlite3_vsnprintf(int,char*,const char*, va_list);

這些例程是標準 C 函式庫中「printf()」函式系列的類似函式。這些例程瞭解標準函式庫 printf() 中大部分常見的格式化選項，以及一些額外的非標準格式（%q、%Q、%w 和 %z）。有關詳細資訊，請參閱 內建 printf() 文件。

例程 sqlite3_mprintf() 和 sqlite3_vmprintf() 將其結果寫入從 sqlite3_malloc64() 取得的記憶體中。這兩個例程傳回的字串應該由 sqlite3_free() 釋放。如果 sqlite3_malloc64() 無法配置足夠的記憶體來儲存結果字串，兩個例程都會傳回 NULL 指標。

例程 sqlite3_snprintf() 類似於標準 C 函式庫中的「snprintf()」。結果會寫入提供為第二個參數的緩衝區中，其大小由第一個參數指定。請注意，前兩個參數的順序與 snprintf() 相反。這是一個歷史意外，無法在不破壞向後相容性的情況下修復。另請注意，sqlite3_snprintf() 會傳回其緩衝區的指標，而不是實際寫入緩衝區的字元數。我們承認寫入的字元數會是一個更有用的傳回值，但我們現在無法在不破壞相容性的情況下變更 sqlite3_snprintf() 的實作。

只要緩衝區大小大於零，sqlite3_snprintf() 保證緩衝區總是零終止。第一個參數「n」是緩衝區的總大小，包括零終止符的空間。因此，可以完全寫入的最長字串將是 n-1 個字元。

sqlite3_vsnprintf() 常式是 sqlite3_snprintf() 的變數參數版本。

另請參閱：內建 printf()、printf() SQL 函數

---

互斥鎖

sqlite3_mutex *sqlite3_mutex_alloc(int);
void sqlite3_mutex_free(sqlite3_mutex*);
void sqlite3_mutex_enter(sqlite3_mutex*);
int sqlite3_mutex_try(sqlite3_mutex*);
void sqlite3_mutex_leave(sqlite3_mutex*);

SQLite 核心使用這些常式進行執行緒同步。儘管它們供 SQLite 內部使用，但連結到 SQLite 的程式碼允許使用這些常式中的任何一個。

SQLite 原始碼包含這些互斥鎖常式的多個實作。適當的實作會在編譯時自動選取。SQLite 核心提供下列實作

• SQLITE_MUTEX_PTHREADS
• SQLITE_MUTEX_W32
• SQLITE_MUTEX_NOOP

SQLITE_MUTEX_NOOP 實作是一組不會執行實際鎖定的常式，適合用於單執行緒應用程式。SQLITE_MUTEX_PTHREADS 和 SQLITE_MUTEX_W32 實作適合用於 Unix 和 Windows。

如果 SQLite 是以定義 SQLITE_MUTEX_APPDEF 預處理器巨集 (使用「-DSQLITE_MUTEX_APPDEF=1」) 編譯，則函式庫中不包含任何互斥鎖實作。在此情況下，應用程式必須在呼叫 sqlite3_initialize() 或任何其他呼叫 sqlite3_initialize() 的公開 sqlite3_ 函數之前，使用 sqlite3_config() 函數的 SQLITE_CONFIG_MUTEX 選項提供自訂互斥鎖實作。

sqlite3_mutex_alloc() 常式會配置新的互斥鎖，並傳回指標。如果無法配置請求的互斥鎖，sqlite3_mutex_alloc() 常式會傳回 NULL。sqlite3_mutex_alloc() 的引數必須是下列整數常數之一

• SQLITE_MUTEX_FAST
• SQLITE_MUTEX_RECURSIVE
• SQLITE_MUTEX_STATIC_MAIN
• SQLITE_MUTEX_STATIC_MEM
• SQLITE_MUTEX_STATIC_OPEN
• SQLITE_MUTEX_STATIC_PRNG
• SQLITE_MUTEX_STATIC_LRU
• SQLITE_MUTEX_STATIC_PMEM
• SQLITE_MUTEX_STATIC_APP1
• SQLITE_MUTEX_STATIC_APP2
• SQLITE_MUTEX_STATIC_APP3
• SQLITE_MUTEX_STATIC_VFS1
• SQLITE_MUTEX_STATIC_VFS2
• SQLITE_MUTEX_STATIC_VFS3

前兩個常數 (SQLITE_MUTEX_FAST 和 SQLITE_MUTEX_RECURSIVE) 會導致 sqlite3_mutex_alloc() 建立新的互斥鎖。當使用 SQLITE_MUTEX_RECURSIVE 時，新的互斥鎖是遞迴的，但使用 SQLITE_MUTEX_FAST 時則不一定。如果互斥鎖實作不希望區分 SQLITE_MUTEX_RECURSIVE 和 SQLITE_MUTEX_FAST，則不需要。SQLite 只有在真正需要的情況下才會要求遞迴互斥鎖。如果主機平台上有更快的非遞迴互斥鎖實作，則互斥鎖子系統可能會在回應 SQLITE_MUTEX_FAST 時傳回此類互斥鎖。

sqlite3_mutex_alloc() 的其他允許參數 (除了 SQLITE_MUTEX_FAST 和 SQLITE_MUTEX_RECURSIVE 之外) 各會傳回指向靜態預先存在的互斥鎖的指標。SQLite 的目前版本使用九個靜態互斥鎖。SQLite 的未來版本可能會新增其他靜態互斥鎖。靜態互斥鎖僅供 SQLite 內部使用。使用 SQLite 互斥鎖的應用程式應僅使用 SQLITE_MUTEX_FAST 或 SQLITE_MUTEX_RECURSIVE 傳回的動態互斥鎖。

請注意，如果使用其中一個動態互斥鎖參數 (SQLITE_MUTEX_FAST 或 SQLITE_MUTEX_RECURSIVE)，則 sqlite3_mutex_alloc() 會在每次呼叫時傳回不同的互斥鎖。對於靜態互斥鎖類型，每次呼叫時都會傳回具有相同類型編號的相同互斥鎖。

sqlite3_mutex_free() 常式會解除配置先前配置的動態互斥鎖。嘗試解除配置靜態互斥鎖會導致未定義的行為。

sqlite3_mutex_enter() 和 sqlite3_mutex_try() 常式會嘗試進入互斥鎖。如果另一個執行緒已經在互斥鎖內，則 sqlite3_mutex_enter() 會封鎖，而 sqlite3_mutex_try() 會傳回 SQLITE_BUSY。sqlite3_mutex_try() 介面會在成功進入時傳回 SQLITE_OK。使用 SQLITE_MUTEX_RECURSIVE 建立的互斥鎖可以由同一個執行緒多次進入。在這種情況下，必須退出互斥鎖相同的次數，才能讓另一個執行緒進入。如果同一個執行緒嘗試多次進入除了 SQLITE_MUTEX_RECURSIVE 之外的任何互斥鎖，則行為未定義。

有些系統 (例如 Windows 95) 不支援 sqlite3_mutex_try() 實作的作業。在這些系統上，sqlite3_mutex_try() תמיד會傳回 SQLITE_BUSY。在大部分情況下，SQLite 核心只將 sqlite3_mutex_try() 用作最佳化，因此這是可接受的行為。例外情況是設定 SQLITE_ENABLE_SETLK_TIMEOUT 建置選項的 unix 建置。在這種情況下，需要可運作的 sqlite3_mutex_try()。

sqlite3_mutex_leave() 常式會離開先前由相同執行緒輸入的 mutex。如果 mutex 目前未由呼叫執行緒輸入或目前未配置，則行為未定義。

如果 sqlite3_mutex_enter()、sqlite3_mutex_try()、sqlite3_mutex_leave() 或 sqlite3_mutex_free() 的引數為 NULL 指標，則這四個常式中的任何一個都會表現為無作用。

另請參閱：sqlite3_mutex_held() 和 sqlite3_mutex_notheld()。

---

Mutex 驗證常式

#ifndef NDEBUG
int sqlite3_mutex_held(sqlite3_mutex*);
int sqlite3_mutex_notheld(sqlite3_mutex*);
#endif

sqlite3_mutex_held() 和 sqlite3_mutex_notheld() 常式旨在用於 assert() 陳述式中。SQLite 核心從不使用這些常式，除非是在 assert() 內部，建議應用程式遵循核心的做法。SQLite 核心僅在使用 SQLITE_DEBUG 旗標編譯時才提供這些常式的實作。外部 mutex 實作僅在定義 SQLITE_DEBUG 且未定義 NDEBUG 時才需要提供這些常式。

如果呼叫執行緒分別持有或不持有引數中的 mutex，則這些常式應傳回 true。

實作不需要提供實際運作的這些常式版本。如果實作未提供這些常式的運作版本，則至少應提供始終傳回 true 的 stub，這樣就不會得到虛假的斷言失敗。

如果 sqlite3_mutex_held() 的引數為 NULL 指標，則常式應傳回 1。這看起來違反直覺，因為如果 mutex 不存在，則顯然無法持有 mutex。但 mutex 不存在的原因是建置未使用 mutex。我們不希望包含呼叫 sqlite3_mutex_held() 的 assert() 失敗，因此傳回非零值是適當的作法。當給定 NULL 指標時，sqlite3_mutex_notheld() 介面也應傳回 1。

---

開啟新的資料庫連線

int sqlite3_open(
  const char *filename,   /* Database filename (UTF-8) */
  sqlite3 **ppDb          /* OUT: SQLite db handle */
);
int sqlite3_open16(
  const void *filename,   /* Database filename (UTF-16) */
  sqlite3 **ppDb          /* OUT: SQLite db handle */
);
int sqlite3_open_v2(
  const char *filename,   /* Database filename (UTF-8) */
  sqlite3 **ppDb,         /* OUT: SQLite db handle */
  int flags,              /* Flags */
  const char *zVfs        /* Name of VFS module to use */
);

這些常式會開啟一個由 filename 參數指定的 SQLite 資料庫檔案。filename 參數會被 sqlite3_open() 和 sqlite3_open_v2() 解釋成 UTF-8，而會被 sqlite3_open16() 解釋成原生位元組順序的 UTF-16。通常會在 *ppDb 中傳回一個 資料庫連線 處理常式，即使發生錯誤也是如此。唯一的例外是如果 SQLite 無法配置記憶體來儲存 sqlite3 物件，就會在 *ppDb 中寫入 NULL，而不是 sqlite3 物件的指標。如果資料庫已成功開啟（和/或建立），就會傳回 SQLITE_OK。否則就會傳回一個 錯誤碼。可以在任何 sqlite3_open() 常式發生錯誤後，使用 sqlite3_errmsg() 或 sqlite3_errmsg16() 常式來取得英文錯誤說明。

使用 sqlite3_open() 或 sqlite3_open_v2() 建立的資料庫，其預設編碼會是 UTF-8。使用 sqlite3_open16() 建立的資料庫，其預設編碼會是原生位元組順序的 UTF-16。

不論在開啟時是否發生錯誤，都應該在不再需要 資料庫連線 處理常式時，將其傳遞給 sqlite3_close() 來釋放與其相關的資源。

sqlite3_open_v2() 介面會像 sqlite3_open() 一樣運作，但它會接受兩個額外的參數，以進一步控制新的資料庫連線。傳遞給 sqlite3_open_v2() 的 flags 參數，至少必須包含下列三個旗標組合之一

SQLITE_OPEN_READONLY

資料庫會以唯讀模式開啟。如果資料庫尚未存在，就會傳回錯誤。

SQLITE_OPEN_READWRITE

如果可能，資料庫會開啟為讀寫模式，或者如果檔案受到作業系統寫入保護，則只讀取。在任何情況下，資料庫都必須已經存在，否則會傳回錯誤。基於歷史原因，如果因為作業系統層級的權限而無法以讀寫模式開啟，系統會嘗試以唯讀模式開啟。可以使用 sqlite3_db_readonly() 來判斷資料庫是否實際上是讀寫模式。

SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE

資料庫會開啟為讀寫模式，如果資料庫尚未存在，則會建立資料庫。這是 sqlite3_open() 和 sqlite3_open16() 始終使用的行為。

除了必要的旗標外，還支援下列選用旗標

SQLITE_OPEN_URI

如果設定此旗標，檔名可以解釋為 URI。

SQLITE_OPEN_MEMORY

資料庫會開啟為記憶體中資料庫。如果啟用共用快取模式，則資料庫會以「檔名」引數命名，以進行快取共用，但「檔名」會被忽略。

SQLITE_OPEN_NOMUTEX

新的資料庫連線會使用「多執行緒」執行緒模式。這表示允許多個執行緒同時使用 SQLite，只要每個執行緒使用不同的資料庫連線即可。

SQLITE_OPEN_FULLMUTEX

新的資料庫連線會使用「序列化」執行緒模式。這表示多個執行緒可以安全地嘗試同時使用相同的資料庫連線。（互斥鎖會封鎖任何實際的並行性，但在這個模式中，嘗試並不會造成傷害。）

SQLITE_OPEN_SHAREDCACHE

資料庫會開啟共用快取已啟用，覆寫 sqlite3_enable_shared_cache() 提供的預設共用快取設定。不建議使用共用快取模式，因此許多 SQLite 建置可能會略過共用快取功能。在這種情況下，這個選項不會執行任何操作。

SQLITE_OPEN_PRIVATECACHE

資料庫會開啟共用快取已停用，覆寫 sqlite3_enable_shared_cache() 提供的預設共用快取設定。

SQLITE_OPEN_EXRESCODE

資料庫連線會以「延伸結果碼模式」啟動。換句話說，資料庫的行為就像在建立連線時，對資料庫連線呼叫 sqlite3_extended_result_codes(db,1) 一樣。除了設定延伸結果碼模式外，這個旗標也會導致 sqlite3_open_v2() 傳回延伸結果碼。

SQLITE_OPEN_NOFOLLOW

資料庫檔名不得包含符號連結

如果 sqlite3_open_v2() 的第 3 個參數不是上面顯示的必要組合之一，或者與其他 SQLITE_OPEN_* 位元 選擇性地結合，則行為未定義。SQLite 的歷史版本會在 sqlite3_open_v2() 的旗標參數中靜默略過多餘的位元，但此行為可能不會延續到未來的 SQLite 版本，因此應用程式不應依賴它。特別注意，對於 sqlite3_open_v2()，SQLITE_OPEN_EXCLUSIVE 旗標是無操作的。如果資料庫已存在，SQLITE_OPEN_EXCLUSIVE *不會* 導致開啟失敗。SQLITE_OPEN_EXCLUSIVE 旗標僅供 VFS 介面 使用，而非供 sqlite3_open_v2() 使用。

sqlite3_open_v2() 的第 4 個參數是 sqlite3_vfs 物件的名稱，它定義新資料庫連線應使用的作業系統介面。如果第 4 個參數是 NULL 指標，則會使用預設的 sqlite3_vfs 物件。

如果檔名是「:memory:」，則會為連線建立一個私密的暫時內存資料庫。當資料庫連線關閉時，這個內存資料庫將會消失。未來的 SQLite 版本可能會使用以「:」字元開頭的其他特殊檔名。建議當資料庫檔名實際上以「:」字元開頭時，您應該在檔名前加上路徑名稱，例如「./」，以避免歧義。

如果檔案名稱為空字串，將會建立一個私有的、暫時性的磁碟資料庫。此私有資料庫會在資料庫連線關閉後自動刪除。

URI 檔案名稱

如果啟用 URI 檔案名稱 解譯，且檔案名稱引數以「file:」開頭，則檔案名稱會被解譯為 URI。如果在 sqlite3_open_v2() 的第三個引數中設定 SQLITE_OPEN_URI 旗標，或使用 SQLITE_CONFIG_URI 選項搭配 sqlite3_config() 方法，或使用 SQLITE_USE_URI 編譯時期選項，在全域啟用，則會啟用 URI 檔案名稱解譯。URI 檔案名稱解譯預設為關閉，但未來版本的 SQLite 可能會預設啟用 URI 檔案名稱解譯。請參閱「URI 檔案名稱」以取得更多資訊。

URI 檔案名稱會根據 RFC 3986 進行剖析。如果 URI 包含授權，則它必須是空字串或字串「localhost」。如果授權不是空字串或「localhost」，則會傳回錯誤給呼叫者。URI 的片段組件（如果存在）會被忽略。

SQLite 會使用 URI 的路徑組件作為包含資料庫的磁碟檔案名稱。如果路徑以「/」字元開頭，則會被解譯為絕對路徑。如果路徑未以「/」開頭（表示 URI 中省略了授權區段），則路徑會被解譯為相對路徑。在 Windows 中，絕對路徑的第一個組件是磁碟機規格（例如「C:」）。

URI 的查詢組件可能包含由 SQLite 本身或 自訂 VFS 實作 解譯的參數。SQLite 及其內建 VFS 會解譯下列查詢參數

• vfs：可以使用「vfs」參數指定提供作業系統介面的 VFS 物件名稱，該介面用於存取磁碟上的資料庫檔案。如果此選項設定為空字串，則會使用預設的 VFS 物件。指定未知的 VFS 會產生錯誤。如果使用 sqlite3_open_v2() 且 vfs 選項存在，則由選項指定的 VFS 優先於傳遞給 sqlite3_open_v2() 第四個參數的值。

• mode：mode 參數可以設定為「ro」、「rw」、「rwc」或「memory」。嘗試設定為任何其他值都會產生錯誤。如果指定「ro」，則資料庫會開啟為唯讀存取，就像在 sqlite3_open_v2() 的第三個參數中設定了 SQLITE_OPEN_READONLY 旗標一樣。如果 mode 選項設定為「rw」，則資料庫會開啟為讀寫（但非建立）存取，就像設定了 SQLITE_OPEN_READWRITE（但未設定 SQLITE_OPEN_CREATE）一樣。值「rwc」等於同時設定 SQLITE_OPEN_READWRITE 和 SQLITE_OPEN_CREATE。如果 mode 選項設定為「memory」，則會使用純 記憶體中資料庫，該資料庫絕不會從磁碟讀取或寫入磁碟。指定小於 sqlite3_open_v2() 第三個參數中傳遞的旗標所指定限制的 mode 參數值會產生錯誤。

• cache：cache 參數可以設定為「shared」或「private」。將其設定為「shared」等於在傳遞給 sqlite3_open_v2() 的 flags 參數中設定 SQLITE_OPEN_SHAREDCACHE 位元。將 cache 參數設定為「private」等於設定 SQLITE_OPEN_PRIVATECACHE 位元。如果使用 sqlite3_open_v2() 且 URI 檔案名稱中存在「cache」參數，則其值會覆寫透過設定 SQLITE_OPEN_PRIVATECACHE 或 SQLITE_OPEN_SHAREDCACHE 旗標所要求的任何行為。

• psow：psow 參數指出資料庫檔案所在的儲存媒體是否套用 電源安全覆寫 屬性。

• nolock：nolock 參數是一個布林查詢參數，如果設定，會停用回滾日誌模式中的檔案鎖定。這對於存取不支援鎖定的檔案系統上的資料庫很有用。小心：如果兩個或以上的處理程序寫入同一個資料庫，且其中任何一個處理程序使用 nolock=1，可能會導致資料庫損毀。

• immutable：immutable 參數是一個布林查詢參數，表示資料庫檔案儲存在唯讀媒體上。當設定 immutable 時，SQLite 會假設資料庫檔案無法變更，即使是具有較高權限的處理程序也一樣，因此資料庫會以唯讀方式開啟，且所有鎖定和變更偵測都會停用。小心：對實際上會變更的資料庫檔案設定 immutable 屬性，可能會導致不正確的查詢結果和/或 SQLITE_CORRUPT 錯誤。另請參閱：SQLITE_IOCAP_IMMUTABLE。

在 URI 的查詢元件中指定未知參數並非錯誤。SQLite 的未來版本可能會理解其他查詢參數。有關其他資訊，請參閱「對 SQLite 具有特殊意義的查詢參數」。

URI 檔案名稱範例

URI 檔案名稱	結果
file:data.db	開啟目前目錄中的「data.db」檔案。
file:/home/fred/data.db file:///home/fred/data.db file://127.0.0.1/home/fred/data.db	開啟資料庫檔案「/home/fred/data.db」。
file://darkstar/home/fred/data.db	錯誤。「darkstar」並非已識別的授權。
file:///C:/Documents%20and%20Settings/fred/Desktop/data.db	僅限 Windows：開啟 C 磁碟機上 fred 桌面上的「data.db」檔案。請注意，此範例中的 %20 跳脫字元並非絕對必要 - 空白字元可以在 URI 檔案名稱中直接使用。
file:data.db?mode=ro&cache=private	在目前目錄中開啟檔案「data.db」以進行唯讀存取。不論是否預設啟用共用快取模式，請使用私人快取。
file:/home/fred/data.db?vfs=unix-dotfile	開啟檔案「/home/fred/data.db」。使用特殊 VFS「unix-dotfile」，它使用點檔來取代 POSIX 建議鎖定。
file:data.db?mode=readonly	錯誤。「readonly」不是「mode」參數的有效選項。請改用「ro」：「file:data.db?mode=ro」。

URI 十六進位轉譯序列 (%HH) 受 URI 的路徑和查詢元件支援。十六進位轉譯序列包含百分比符號 -「%」- 後面緊接著兩個十六進位數字，用來指定一個八位元組值。在 URI 檔名的路徑或查詢元件被詮釋之前，它們會使用 UTF-8 編碼，並且所有十六進位轉譯序列都會被一個包含對應八位元組的單一位元組取代。如果這個程序產生無效的 UTF-8 編碼，結果將是未定義的。

Windows 使用者注意事項：sqlite3_open() 和 sqlite3_open_v2() 的檔名引數所使用的編碼必須是 UTF-8，而不是目前定義的任何一個編碼頁。包含國際字元的檔名必須在傳遞到 sqlite3_open() 或 sqlite3_open_v2() 之前轉換成 UTF-8。

Windows Runtime 使用者注意事項：必須在呼叫 sqlite3_open() 或 sqlite3_open_v2() 之前設定暫存目錄。否則，需要使用暫存檔案的各種功能可能會失敗。

另請參閱：sqlite3_temp_directory

---

預更新掛鉤。

#if defined(SQLITE_ENABLE_PREUPDATE_HOOK)
void *sqlite3_preupdate_hook(
  sqlite3 *db,
  void(*xPreUpdate)(
    void *pCtx,                   /* Copy of third arg to preupdate_hook() */
    sqlite3 *db,                  /* Database handle */
    int op,                       /* SQLITE_UPDATE, DELETE or INSERT */
    char const *zDb,              /* Database name */
    char const *zName,            /* Table name */
    sqlite3_int64 iKey1,          /* Rowid of row about to be deleted/updated */
    sqlite3_int64 iKey2           /* New rowid value (for a rowid UPDATE) */
  ),
  void*
);
int sqlite3_preupdate_old(sqlite3 *, int, sqlite3_value **);
int sqlite3_preupdate_count(sqlite3 *);
int sqlite3_preupdate_depth(sqlite3 *);
int sqlite3_preupdate_new(sqlite3 *, int, sqlite3_value **);
int sqlite3_preupdate_blobwrite(sqlite3 *);
#endif

這些介面僅在使用 SQLITE_ENABLE_PREUPDATE_HOOK 編譯時間選項編譯 SQLite 時才可用。

介面 sqlite3_preupdate_hook() 註冊一個回呼函式，在資料庫表格上的每個 INSERT、UPDATE 和 DELETE 操作之前呼叫。在單一 資料庫連線 上一次只能註冊一個 preupdate 掛勾；每次呼叫 sqlite3_preupdate_hook() 都會覆寫前一個設定。呼叫 sqlite3_preupdate_hook() 並將第二個參數設為 NULL 指標，即可停用 preupdate 掛勾。傳遞給 sqlite3_preupdate_hook() 的第三個參數會作為第一個參數傳遞給回呼函式。

preupdate 掛勾只會對真實資料庫表格的變更觸發；對於 虛擬表格 或 sqlite_sequence 或 sqlite_stat1 等系統表格的變更，不會呼叫 preupdate 掛勾。

傳遞給 preupdate 回呼函式的第二個參數，是指向註冊 preupdate 掛勾的 資料庫連線 的指標。傳遞給 preupdate 回呼函式的第三個參數，是常數 SQLITE_INSERT、SQLITE_DELETE 或 SQLITE_UPDATE 之一，用於識別即將發生的更新操作類型。傳遞給 preupdate 回呼函式的第四個參數，是正在修改的資料庫連線中資料庫的名稱。對於主資料庫，這會是「main」；對於 TEMP 表格，這會是「temp」；對於附加資料庫，這會是 ATTACH 陳述式中 AS 關鍵字後的指定名稱。傳遞給 preupdate 回呼函式的第五個參數，是正在修改的表格名稱。

對於 rowid 表格 上的 UPDATE 或 DELETE 操作，傳遞給 preupdate 回呼的第六個參數是正在修改或刪除的列的初始 rowid。對於 rowid 表格上的 INSERT 操作，或在 WITHOUT ROWID 表格上的任何操作，第六個參數的值未定義。對於 rowid 表格上的 INSERT 或 UPDATE，第七個參數是正在插入或更新的列的最終 rowid 值。傳遞給回呼函數的第七個參數的值未定義，適用於 WITHOUT ROWID 表格上的操作，或 rowid 表格上的 DELETE 操作。

sqlite3_preupdate_hook(D,C,P) 函數從同一個 資料庫連線 D 上的前一次呼叫傳回 P 參數，或對於 D 上的第一次呼叫傳回 NULL。

sqlite3_preupdate_old()、sqlite3_preupdate_new()、sqlite3_preupdate_count() 和 sqlite3_preupdate_depth() 介面提供有關 preupdate 事件的其他資訊。這些常式只能從 preupdate 回呼中呼叫。在 preupdate 回呼外部或使用與提供給 preupdate 回呼不同的 資料庫連線 指標呼叫其中任何常式，會導致未定義且可能不理想的行為。

sqlite3_preupdate_count(D) 介面傳回正在插入、更新或刪除的列中欄位的數量。

介面 sqlite3_preupdate_old(D,N,P) 會將指標寫入 P，指向 受保護的 sqlite3_value，其中包含資料表列在更新前第 N 欄的值。N 參數必須介於 0 到欄位數少 1 之間，否則行為將未定義。這只能在 SQLITE_UPDATE 和 SQLITE_DELETE 預更新回呼中使用；如果由 SQLITE_INSERT 回呼使用，則行為將未定義。P 指向的 sqlite3_value 會在預更新回呼傳回時毀損。

介面 sqlite3_preupdate_new(D,N,P) 會將指標寫入 P，指向 受保護的 sqlite3_value，其中包含資料表列在更新後第 N 欄的值。N 參數必須介於 0 到欄位數少 1 之間，否則行為將未定義。這只能在 SQLITE_INSERT 和 SQLITE_UPDATE 預更新回呼中使用；如果由 SQLITE_DELETE 回呼使用，則行為將未定義。P 指向的 sqlite3_value 會在預更新回呼傳回時毀損。

介面 sqlite3_preupdate_depth(D) 會傳回 0，如果預更新回呼是因直接插入、更新或刪除操作而呼叫；或 1，如果插入、更新或刪除是由頂層觸發器呼叫；或 2，如果變更是由頂層觸發器呼叫的觸發器所造成；以此類推。

當 sqlite3_blob_write() API 用於更新 blob 欄位時，預更新掛勾會以 SQLITE_DELETE 呼叫。這是因為在此情況下，新的值不可用。在此情況下，當使用 op==SQLITE_DELETE 進行的回呼實際上是使用 sqlite3_blob_write() API 進行寫入時，sqlite3_preupdate_blobwrite() 會傳回正在寫入的欄位索引。在其他情況下，當預更新掛勾因其他原因（包括一般 DELETE）而呼叫時，sqlite3_preupdate_blobwrite() 會傳回 -1。

另請參閱：sqlite3_update_hook()

---

追蹤和分析函數

void *sqlite3_trace(sqlite3*,
   void(*xTrace)(void*,const char*), void*);
void *sqlite3_profile(sqlite3*,
   void(*xProfile)(void*,const char*,sqlite3_uint64), void*);

這些常式已棄用。請使用 sqlite3_trace_v2() 介面，而非此處所述的常式。

這些常式會註冊可供追蹤和分析 SQL 陳述式執行的回呼函數。

當 sqlite3_step() 執行 SQL 陳述式時，會在不同時間呼叫 sqlite3_trace() 所註冊的回呼函數。當 SQL 陳述式文字開始執行時，會呼叫 sqlite3_trace() 回呼函數，並將其轉換成 UTF-8。當每個觸發的子程式進入時，可能會呼叫其他 sqlite3_trace() 回呼函數。觸發器的回呼函數會包含一個 UTF-8 SQL 註解，用於識別觸發器。

編譯時期選項 SQLITE_TRACE_SIZE_LIMIT 可用於限制 sqlite3_trace() 輸出中 繫結參數 擴充的長度。

當每個 SQL 陳述式完成時，會呼叫 sqlite3_profile() 所註冊的回呼函數。分析回呼函數會包含原始陳述式文字，以及執行該陳述式所花費的時脈時間估計值。分析回呼函數時間的單位為奈秒，但目前實作僅能達到毫秒解析度，因此時間中的最後六個最小有效數字沒有意義。SQLite 的未來版本可能會提供更高的解析度分析回呼函數。呼叫 sqlite3_trace() 或 sqlite3_trace_v2() 會取消分析回呼函數。

---

設定 SQL 函數的結果

void sqlite3_result_blob(sqlite3_context*, const void*, int, void(*)(void*));
void sqlite3_result_blob64(sqlite3_context*,const void*,
                           sqlite3_uint64,void(*)(void*));
void sqlite3_result_double(sqlite3_context*, double);
void sqlite3_result_error(sqlite3_context*, const char*, int);
void sqlite3_result_error16(sqlite3_context*, const void*, int);
void sqlite3_result_error_toobig(sqlite3_context*);
void sqlite3_result_error_nomem(sqlite3_context*);
void sqlite3_result_error_code(sqlite3_context*, int);
void sqlite3_result_int(sqlite3_context*, int);
void sqlite3_result_int64(sqlite3_context*, sqlite3_int64);
void sqlite3_result_null(sqlite3_context*);
void sqlite3_result_text(sqlite3_context*, const char*, int, void(*)(void*));
void sqlite3_result_text64(sqlite3_context*, const char*,sqlite3_uint64,
                           void(*)(void*), unsigned char encoding);
void sqlite3_result_text16(sqlite3_context*, const void*, int, void(*)(void*));
void sqlite3_result_text16le(sqlite3_context*, const void*, int,void(*)(void*));
void sqlite3_result_text16be(sqlite3_context*, const void*, int,void(*)(void*));
void sqlite3_result_value(sqlite3_context*, sqlite3_value*);
void sqlite3_result_pointer(sqlite3_context*, void*,const char*,void(*)(void*));
void sqlite3_result_zeroblob(sqlite3_context*, int n);
int sqlite3_result_zeroblob64(sqlite3_context*, sqlite3_uint64 n);

這些常式由實作 SQL 函數和聚集函數的 xFunc 或 xFinal 回呼函數使用。請參閱 sqlite3_create_function() 和 sqlite3_create_function16() 以取得更多資訊。

這些函數的運作方式非常類似於 參數繫結 函數系列，用於將值繫結到準備陳述式中的主機參數。請參閱 SQL 參數 文件以取得更多資訊。

sqlite3_result_blob() 介面將應用程式定義函式的結果設定為第二個參數所指的 BLOB，其長度為 N 個位元組，其中 N 是第三個參數。

sqlite3_result_zeroblob(C,N) 和 sqlite3_result_zeroblob64(C,N) 介面將應用程式定義函式的結果設定為包含所有零位元組且大小為 N 個位元組的 BLOB。

sqlite3_result_double() 介面將應用程式定義函式的結果設定為其第二個參數所指定的浮點值。

sqlite3_result_error() 和 sqlite3_result_error16() 函式會導致實作的 SQL 函式擲回例外。SQLite 會使用 sqlite3_result_error() 或 sqlite3_result_error16() 的第二個參數所指的字串作為錯誤訊息的文字。SQLite 會將 sqlite3_result_error() 的錯誤訊息字串解譯為 UTF-8。SQLite 會使用與 sqlite3_bind_text16() 相同的 位元組順序判斷規則 將 sqlite3_result_error16() 的字串解譯為 UTF-16。如果 sqlite3_result_error() 或 sqlite3_result_error16() 的第三個參數為負值，則 SQLite 會將所有文字視為錯誤訊息，直到第一個零字元為止。如果 sqlite3_result_error() 或 sqlite3_result_error16() 的第三個參數為非負值，則 SQLite 會從第二個參數中取出這麼多個位元組 (而非字元) 作為錯誤訊息。sqlite3_result_error() 和 sqlite3_result_error16() 常式會在傳回之前製作錯誤訊息文字的私人副本。因此，呼叫函式可以在傳回後釋放或修改文字，而不會造成損害。sqlite3_result_error_code() 函式會變更 SQLite 因函式錯誤而傳回的錯誤碼。預設錯誤碼為 SQLITE_ERROR。後續呼叫 sqlite3_result_error() 或 sqlite3_result_error16() 會將錯誤碼重設為 SQLITE_ERROR。

sqlite3_result_error_toobig() 介面會導致 SQLite 擲回一個錯誤，指出字串或 BLOB 太長而無法表示。

sqlite3_result_error_nomem() 介面會導致 SQLite 擲回一個錯誤，指出記憶體配置失敗。

sqlite3_result_int() 介面會將應用程式定義函數的回傳值設定為第 2 個引數中提供的 32 位元有號整數值。sqlite3_result_int64() 介面會將應用程式定義函數的回傳值設定為第 2 個引數中提供的 64 位元有號整數值。

sqlite3_result_null() 介面會將應用程式定義函數的回傳值設定為 NULL。

The sqlite3_result_text(), sqlite3_result_text16(), sqlite3_result_text16le(), and sqlite3_result_text16be() interfaces set the return value of the application-defined function to be a text string which is represented as UTF-8, UTF-16 native byte order, UTF-16 little endian, or UTF-16 big endian, respectively. The sqlite3_result_text64() interface sets the return value of an application-defined function to be a text string in an encoding specified by the fifth (and last) parameter, which must be one of SQLITE_UTF8, SQLITE_UTF16, SQLITE_UTF16BE, or SQLITE_UTF16LE. SQLite takes the text result from the application from the 2nd parameter of the sqlite3_result_text* interfaces. If the 3rd parameter to any of the sqlite3_result_text* interfaces other than sqlite3_result_text64() is negative, then SQLite computes the string length itself by searching the 2nd parameter for the first zero character. If the 3rd parameter to the sqlite3_result_text* interfaces is non-negative, then as many bytes (not characters) of the text pointed to by the 2nd parameter are taken as the application-defined function result. If the 3rd parameter is non-negative, then it must be the byte offset into the string where the NUL terminator would appear if the string where NUL terminated. If any NUL characters occur in the string at a byte offset that is less than the value of the 3rd parameter, then the resulting string will contain embedded NULs and the result of expressions operating on strings with embedded NULs is undefined. If the 4th parameter to the sqlite3_result_text* interfaces or sqlite3_result_blob is a non-NULL pointer, then SQLite calls that function as the destructor on the text or BLOB result when it has finished using that result. If the 4th parameter to the sqlite3_result_text* interfaces or to sqlite3_result_blob is the special constant SQLITE_STATIC, then SQLite assumes that the text or BLOB result is in constant space and does not copy the content of the parameter nor call a destructor on the content when it has finished using that result. If the 4th parameter to the sqlite3_result_text* interfaces or sqlite3_result_blob is the special constant SQLITE_TRANSIENT then SQLite makes a copy of the result into space obtained from sqlite3_malloc() before it returns.

對於 sqlite3_result_text16()、sqlite3_result_text16le() 和 sqlite3_result_text16be() 常式，以及當編碼不是 UTF8 時的 sqlite3_result_text64()，如果輸入的 UTF16 以位元組順序標記 (BOM，U+FEFF) 開頭，則會從字串中移除 BOM，並根據 BOM 指定的位元組順序來詮釋字串的其餘部分。文字開頭的 BOM 指定的位元組順序會覆寫介面程序指定的位元組順序。因此，例如，如果 sqlite3_result_text16le() 被呼叫時，文字以位元組 0xfe、0xff (大端位元組順序標記) 開頭，則會略過輸入的前兩個位元組，並將其餘輸入詮釋為 UTF16BE 文字。

對於 sqlite3_result_text16()、sqlite3_result_text16be()、sqlite3_result_text16le() 和 sqlite3_result_text64() 常式的 UTF16 輸入文字，如果文字包含無效的 UTF16 字元，則無效的字元可能會轉換成 Unicode 替換字元 U+FFFD。

sqlite3_result_value() 介面將應用程式定義函式的結果設定為由第二個參數指定的 未保護的 sqlite3_value 物件的副本。sqlite3_result_value() 介面會製作 sqlite3_value 的副本，如此一來，在 sqlite3_result_value() 回傳後，參數中指定的 sqlite3_value 可以變更或解除配置，而不會造成損害。受保護的 sqlite3_value 物件永遠可以在需要 未保護的 sqlite3_value 物件的地方使用，因此這兩種 sqlite3_value 物件都可以用於這個介面。

sqlite3_result_pointer(C,P,T,D) 介面將結果設定為 SQL NULL 值，就像 sqlite3_result_null(C) 一樣，但它也會將主機語言指標 P 或類型 T 與該 NULL 值關聯起來，如此一來，指標就可以在 應用程式定義的 SQL 函式 中使用 sqlite3_value_pointer() 來擷取。如果 D 參數不為 NULL，則它會指向 P 參數的解構函式。當 SQLite 完成 P 時，SQLite 會以 P 作為其唯一引數來呼叫 D。T 參數應該是靜態字串，最好是字串文字。sqlite3_result_pointer() 常式是 SQLite 3.20.0 新增的 指標傳遞介面 的一部分。

如果這些常式是在與收到 sqlite3_context 指標的應用程式定義函式不同的執行緒中呼叫，則結果是未定義的。

---

SQLite 執行時間狀態

int sqlite3_status(int op, int *pCurrent, int *pHighwater, int resetFlag);
int sqlite3_status64(
  int op,
  sqlite3_int64 *pCurrent,
  sqlite3_int64 *pHighwater,
  int resetFlag
);

這些介面用於擷取 SQLite 效能的執行階段狀態資訊，並選擇性地重設各種高水位標記。第一個參數是特定參數的整數代碼，用於測量。已識別的整數代碼形式為 SQLITE_STATUS_...。參數的目前值會傳回至 *pCurrent。最高記錄值會傳回至 *pHighwater。如果 resetFlag 為 true，則在寫入 *pHighwater 後會重設最高記錄值。有些參數不會記錄最高值。對於這些參數，不會寫入任何內容至 *pHighwater，且會忽略 resetFlag。其他參數只會記錄高水位標記，而不會記錄目前值。對於後者參數，不會寫入任何內容至 *pCurrent。

sqlite3_status() 和 sqlite3_status64() 常式在成功時傳回 SQLITE_OK，在失敗時傳回非零的 錯誤代碼。

如果目前值或高水位標記太大，無法以 32 位元整數表示，則 sqlite3_status() 傳回的值未定義。

另請參閱：sqlite3_db_status()

---

準備陳述式掃描狀態

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 */
);
int sqlite3_stmt_scanstatus_v2(
  sqlite3_stmt *pStmt,      /* Prepared statement for which info desired */
  int idx,                  /* Index of loop to report on */
  int iScanStatusOp,        /* Information desired.  SQLITE_SCANSTAT_* */
  int flags,                /* Mask of flags defined below */
  void *pOut                /* Result written here */
);

這些介面會傳回 pStmt 預測和測量效能的資訊。進階應用程式可以使用此介面來比較預測和測量效能，並在發現差異時發出警告和/或重新執行 ANALYZE。

由於預期此介面很少使用，因此只有在使用 SQLITE_ENABLE_STMT_SCANSTATUS 編譯時間選項編譯 SQLite 時才可用。

「iScanStatusOp」參數會決定要傳回哪些狀態資訊。「iScanStatusOp」必須為其中一個 scanstatus 選項，否則此介面的行為未定義。請求的測量值會寫入「pOut」參數所指的變數。

「flags」參數必須傳遞旗標遮罩。目前只定義一個旗標 - SQLITE_SCANSTAT_COMPLEX。如果指定 SQLITE_SCANSTAT_COMPLEX，則「EXPLAIN QUERY PLAN」輸出所報告的查詢計畫所有元素的狀態資訊都可用。如果未指定 SQLITE_SCANSTAT_COMPLEX，則只有對應於查詢迴圈的查詢計畫元素（EXPLAIN QUERY PLAN 輸出的「SCAN...」和「SEARCH...」元素）才可用。呼叫 API sqlite3_stmt_scanstatus() 等於呼叫 sqlite3_stmt_scanstatus_v2()，且旗標參數為零。

參數「idx」識別要擷取其統計資料的特定查詢元素。查詢元素從零開始編號。值 -1 可用於查詢關於整個查詢的統計資料。如果 idx 超出範圍（小於 -1 或大於或等於用於實作陳述式的查詢元素總數），將傳回非零值，且 pOut 指向的變數保持不變。

另請參閱：sqlite3_stmt_scanstatus_reset()

---

將內容新增至動態字串

void sqlite3_str_appendf(sqlite3_str*, const char *zFormat, ...);
void sqlite3_str_vappendf(sqlite3_str*, const char *zFormat, va_list);
void sqlite3_str_append(sqlite3_str*, const char *zIn, int N);
void sqlite3_str_appendall(sqlite3_str*, const char *zIn);
void sqlite3_str_appendchar(sqlite3_str*, int N, char C);
void sqlite3_str_reset(sqlite3_str*);

這些介面將內容新增至先前從 sqlite3_str_new() 取得的 sqlite3_str 物件。

sqlite3_str_appendf(X,F,...) 和 sqlite3_str_vappendf(X,F,V) 介面使用 SQLite 的 內建 printf 功能，將格式化文字新增至 sqlite3_str 物件 X 的尾端。

sqlite3_str_append(X,S,N) 方法將字串 S 中的 N 個位元組新增至 sqlite3_str 物件 X 的尾端。N 必須是非負數。S 必須包含至少 N 個非零位元組的內容。若要完整新增以零終止的字串，請改用 sqlite3_str_appendall() 方法。

sqlite3_str_appendall(X,S) 方法將以零終止的字串 S 的完整內容新增至 sqlite3_str 物件 X 的尾端。

sqlite3_str_appendchar(X,N,C) 方法將單位元組字元 C 的 N 個副本新增至 sqlite3_str 物件 X 的尾端。例如，此方法可用于新增空白縮排。

sqlite3_str_reset(X) 方法將 sqlite3_str 物件 X 內正在建構的字串重設回長度為零位元組。

這些方法不會傳回結果碼。如果發生錯誤，該事實會記錄在 sqlite3_str 物件中，並可透過後續呼叫 sqlite3_str_errcode(X) 來復原。

---

動態字串狀態

int sqlite3_str_errcode(sqlite3_str*);
int sqlite3_str_length(sqlite3_str*);
char *sqlite3_str_value(sqlite3_str*);

這些介面會傳回 sqlite3_str 物件的目前狀態。

如果在建立 sqlite3_str X 中的動態字串時發生任何先前的錯誤，則 sqlite3_str_errcode(X) 方法會傳回適當的錯誤碼。在任何記憶體不足的錯誤後，sqlite3_str_errcode(X) 方法會傳回 SQLITE_NOMEM；如果動態字串的大小超過 SQLITE_MAX_LENGTH，則會傳回 SQLITE_TOOBIG；如果沒有錯誤，則會傳回 SQLITE_OK。

sqlite3_str_length(X) 方法會傳回 sqlite3_str 物件 X 中正在建立的動態字串的目前長度（以位元組為單位）。sqlite3_str_length(X) 傳回的長度不包含零終止位元組。

sqlite3_str_value(X) 方法會傳回 X 中正在建立的動態字串的目前內容的指標。sqlite3_str_value(X) 傳回的值由 sqlite3_str 物件 X 管理，並且可能會被同一個 sqlite3_str 物件上的任何後續方法釋放或變更。應用程式在對同一個物件進行任何後續方法呼叫後，不得使用 sqlite3_str_value(X) 傳回的指標。應用程式可以變更 sqlite3_str_value(X) 傳回的字串內容，只要它們不寫入 0 到 sqlite3_str_length(X) 範圍外的任何位元組，也不在任何後續 sqlite3_str 方法呼叫後讀取或寫入任何位元組即可。

---

字串比較

int sqlite3_stricmp(const char *, const char *);
int sqlite3_strnicmp(const char *, const char *, int);

API sqlite3_stricmp() 與 sqlite3_strnicmp() 允許應用程式與擴充功能以不區分大小寫的方式比較兩個包含 UTF-8 字串的緩衝區內容，使用與 SQLite 在比較識別碼時內部使用的「不區分大小寫」定義相同。

---

修改的總列數

int sqlite3_total_changes(sqlite3*);
sqlite3_int64 sqlite3_total_changes64(sqlite3*);

這些函式會傳回自資料庫連線開啟以來，所有已完成的 INSERT、UPDATE 或 DELETE 陳述式所插入、修改或刪除的總列數，包括作為觸發程式的一部分執行的陳述式。這兩個函式除了傳回值的類型不同之外，其餘完全相同，而且如果連線修改的列數超過類型「int」支援的最大值，則 sqlite3_total_changes() 的傳回值未定義。執行任何其他類型的 SQL 陳述式不會影響 sqlite3_total_changes() 傳回的值。

作為 外來鍵動作 一部分所做的變更會計入總數，但作為 REPLACE 約束解決方案一部分所做的變更不會。由 INSTEAD OF 觸發攔截的檢視變更不會計入。

介面 sqlite3_total_changes(D) 只會報告因為針對資料庫連線 D 執行的 SQL 陳述式而變更的列數。其他資料庫連線所做的任何變更都會略過。若要偵測其他資料庫連線針對資料庫檔案所做的變更，請使用 PRAGMA data_version 指令或 SQLITE_FCNTL_DATA_VERSION 檔案控制。

如果在執行 sqlite3_total_changes() 時，有另一個執行緒在同一個資料庫連線上進行變更，則傳回的值無法預測且沒有意義。

另請參閱

• 介面 sqlite3_changes()
• count_changes pragma
• changes() SQL 函數
• data_version pragma
• SQLITE_FCNTL_DATA_VERSION 檔案控制

---

取得 URI 參數的值

const char *sqlite3_uri_parameter(sqlite3_filename z, const char *zParam);
int sqlite3_uri_boolean(sqlite3_filename z, const char *zParam, int bDefault);
sqlite3_int64 sqlite3_uri_int64(sqlite3_filename, const char*, sqlite3_int64);
const char *sqlite3_uri_key(sqlite3_filename z, int N);

這些是實用常式，對 自訂 VFS 實作 有用，用於檢查資料庫檔案是否為包含特定查詢參數的 URI，如果是，則取得該查詢參數的值。

這些介面的第一個參數（以下稱為 F）必須是下列其中之一

• 由 SQLite 核心建立並傳遞至 VFS 實作的 xOpen() 方法的資料庫檔案名稱指標，或
• 從 sqlite3_db_filename() 取得的檔案名稱，或
• 使用 sqlite3_create_filename() 建立的新檔案名稱。

如果 F 參數不是上述其中之一，則行為未定義，且可能不理想。較舊版本的 SQLite 比較新版本更能容忍無效的 F 參數。

如果 F 是合適的檔案名稱（如前一段所述），且 P 是查詢參數的名稱，則 sqlite3_uri_parameter(F,P) 會傳回 P 參數的值（如果存在），或傳回 NULL 指標（如果 P 未以查詢參數的形式出現在 F 中）。如果 P 是 F 的查詢參數，且沒有明確的值，則 sqlite3_uri_parameter(F,P) 會傳回指向空字串的指標。

sqlite3_uri_boolean(F,P,B) 常式假設 P 是布林參數，並根據 P 的值傳回 true (1) 或 false (0)。如果查詢參數 P 的值是大寫或小寫的「yes」、「true」或「on」，或如果該值以非零數字開頭，則 sqlite3_uri_boolean(F,P,B) 常式會傳回 true (1)。如果查詢參數 P 的值是大寫或小寫的「no」、「false」或「off」，或如果該值以數字 0 開頭，則 sqlite3_uri_boolean(F,P,B) 常式會傳回 false (0)。如果 P 不是 F 的查詢參數，或如果 P 的值與上述任何值都不相符，則 sqlite3_uri_boolean(F,P,B) 會傳回 (B!=0)。

sqlite3_uri_int64(F,P,D) 常式會將 P 的值轉換為 64 位元有號整數，並傳回該整數，或在 P 不存在時傳回 D。如果 P 的值不是整數，則會傳回 0。

sqlite3_uri_key(F,N) 會傳回指標至檔案名稱 F 的第 N 個查詢參數名稱（而非值），或在 N 小於 0 或大於查詢參數數量減 1 時傳回 NULL 指標。N 值是從 0 開始，因此 N 應為 0 以取得第一個查詢參數名稱，1 為第二個參數，以此類推。

如果 F 是 NULL 指標，則 sqlite3_uri_parameter(F,P) 會傳回 NULL，而 sqlite3_uri_boolean(F,P,B) 會傳回 B。如果 F 不是 NULL 指標，且不是 SQLite 核心傳遞至 xOpen VFS 方法的資料庫檔案路徑指標，則此例程的行為未定義，且可能不理想。

從 SQLite 版本 3.31.0（2020-01-22）開始，輸入 F 參數除了可以是主資料庫檔案外，也可以是回滾記錄檔檔案或 WAL 檔案的名稱。在版本 3.31.0 之前，這些例程僅在 F 是主資料庫檔案名稱時才會運作。當 F 參數是回滾記錄檔或 WAL 檔案名稱時，它可以存取與主資料庫檔案上找到的所有相同查詢參數。

請參閱 URI 檔案名稱 文件以取得其他資訊。

---

取得 SQL 值

const void *sqlite3_value_blob(sqlite3_value*);
double sqlite3_value_double(sqlite3_value*);
int sqlite3_value_int(sqlite3_value*);
sqlite3_int64 sqlite3_value_int64(sqlite3_value*);
void *sqlite3_value_pointer(sqlite3_value*, const char*);
const unsigned char *sqlite3_value_text(sqlite3_value*);
const void *sqlite3_value_text16(sqlite3_value*);
const void *sqlite3_value_text16le(sqlite3_value*);
const void *sqlite3_value_text16be(sqlite3_value*);
int sqlite3_value_bytes(sqlite3_value*);
int sqlite3_value_bytes16(sqlite3_value*);
int sqlite3_value_type(sqlite3_value*);
int sqlite3_value_numeric_type(sqlite3_value*);
int sqlite3_value_nochange(sqlite3_value*);
int sqlite3_value_frombind(sqlite3_value*);

摘要

sqlite3_value_blob	→	BLOB 值
sqlite3_value_double	→	REAL 值
sqlite3_value_int	→	32 位元 INTEGER 值
sqlite3_value_int64	→	64 位元 INTEGER 值
sqlite3_value_pointer	→	指標值
sqlite3_value_text	→	UTF-8 TEXT 值
sqlite3_value_text16	→	原生位元組順序中的 UTF-16 TEXT 值
sqlite3_value_text16be	→	UTF-16be TEXT 值
sqlite3_value_text16le	→	UTF-16le TEXT 值
sqlite3_value_bytes	→	BLOB 或 UTF-8 TEXT 的大小（以位元組為單位）
sqlite3_value_bytes16	→	UTF-16 TEXT 的大小（以位元組為單位）
sqlite3_value_type	→	值的預設資料類型
sqlite3_value_numeric_type	→	數值資料類型的最佳值
sqlite3_value_nochange	→	如果虛擬表格中的欄位在 UPDATE 中未變更，則為 True。
sqlite3_value_frombind	→	如果值來自 繫結參數，則為 True

詳細資料

這些常式會從 受保護的 sqlite3_value 物件中提取類型、大小和內容資訊。受保護的 sqlite3_value 物件用於將參數資訊傳遞到實作 應用程式定義的 SQL 函數 和 虛擬表格 的函數中。

這些常式僅適用於 受保護的 sqlite3_value 物件。嘗試對 未受保護的 sqlite3_value 使用這些常式並非執行緒安全。

這些常式的工作方式與對應的 欄位存取函數 相同，但這些常式會採用單一 受保護的 sqlite3_value 物件指標，而不是 sqlite3_stmt* 指標和整數欄位號碼。

sqlite3_value_text16() 介面會提取主機電腦本機位元組順序中的 UTF-16 字串。sqlite3_value_text16be() 和 sqlite3_value_text16le() 介面分別會提取大尾序和低尾序的 UTF-16 字串。

如果 sqlite3_value 物件 V 是使用 sqlite3_bind_pointer(S,I,P,X,D) 或 sqlite3_result_pointer(C,P,X,D) 初始化，且 X 和 Y 是根據 strcmp(X,Y) 比較為相等的字串，則 sqlite3_value_pointer(V,Y) 會傳回指標 P。否則，sqlite3_value_pointer(V,Y) 會傳回 NULL。sqlite3_bind_pointer() 常式是 SQLite 3.20.0 新增的 指標傳遞介面 的一部分。

sqlite3_value_type(V) 介面會傳回 資料類型代碼，作為 sqlite3_value 物件 V 的初始資料類型。傳回的值可能是 SQLITE_INTEGER、SQLITE_FLOAT、SQLITE_TEXT、SQLITE_BLOB 或 SQLITE_NULL。其他介面可能會變更 sqlite3_value 物件的資料類型。例如，如果資料類型最初是 SQLITE_INTEGER，且呼叫 sqlite3_value_text(V) 來萃取該整數的文字值，則後續呼叫 sqlite3_value_type(V) 可能會傳回 SQLITE_TEXT。是否會執行持續性的內部資料類型轉換是未定義的，且可能會在 SQLite 的不同版本之間變更。

sqlite3_value_numeric_type() 介面會嘗試對值套用數字親和性。這表示會嘗試將值轉換為整數或浮點數。如果可以轉換而不遺失資訊（換句話說，如果值是看起來像數字的字串），則會執行轉換。否則，不會執行轉換。會傳回轉換後的 資料類型。

在 xUpdate 虛擬表格 方法中，sqlite3_value_nochange(X) 介面會傳回 true，當且僅當 UPDATE 作業（呼叫 xUpdate 方法來實作）未變更與 X 相關的欄位，且先前呼叫 xColumn 方法來萃取該欄位的值，且未設定結果（可能是因為查詢 sqlite3_vtab_nochange()，並發現欄位未變更）。在 xUpdate 方法中，任何 sqlite3_value_nochange(X) 為 true 的值，在其他所有方面都會顯示為 NULL 值。如果在 UPDATE 陳述式的 xUpdate 方法呼叫以外的地方呼叫 sqlite3_value_nochange(X)，則傳回值是任意的且沒有意義。

sqlite3_value_frombind(X) 介面會傳回非零值，如果值 X 來自於 sqlite3_bind() 介面之一。如果 X 來自於 SQL 文字值、表格欄位或運算式，則 sqlite3_value_frombind(X) 會傳回零。

請特別注意，從 sqlite3_value_blob()、sqlite3_value_text() 或 sqlite3_value_text16() 傳回的指標可能會因為後續呼叫 sqlite3_value_bytes()、sqlite3_value_bytes16()、sqlite3_value_text() 或 sqlite3_value_text16() 而失效。

這些常式必須從提供 sqlite3_value* 參數的 SQL 函數的相同執行緒呼叫。

只要輸入參數正確，這些常式只能在格式轉換期間發生記憶體不足錯誤時失敗。只有下列介面子集會受到記憶體不足錯誤影響

• sqlite3_value_blob()
• sqlite3_value_text()
• sqlite3_value_text16()
• sqlite3_value_text16le()
• sqlite3_value_text16be()
• sqlite3_value_bytes()
• sqlite3_value_bytes16()

如果發生記憶體不足錯誤，則這些常式的傳回值會與欄位包含 SQL NULL 值相同。有效的 SQL NULL 傳回值可以透過在取得可疑傳回值後立即呼叫 sqlite3_errcode()，且在同一個 資料庫連線 上呼叫任何其他 SQLite 介面之前，來區分記憶體不足錯誤。

---

複製並釋放 SQL 值

sqlite3_value *sqlite3_value_dup(const sqlite3_value*);
void sqlite3_value_free(sqlite3_value*);

sqlite3_value_dup(V) 介面會複製 sqlite3_value 物件 D，並傳回指向該副本的指標。傳回的 sqlite3_value 是 受保護的 sqlite3_value 物件，即使輸入不是。如果 V 為 NULL 或記憶體配置失敗，則 sqlite3_value_dup(V) 介面會傳回 NULL。如果 V 是 指標值，則 sqlite3_value_dup(V) 的結果是 NULL 值。

sqlite3_value_free(V) 介面會釋放先前從 sqlite3_value_dup() 取得的 sqlite3_value 物件。如果 V 是 NULL 指標，則 sqlite3_value_free(V) 是無害的空操作。

---

虛擬檔案系統物件

sqlite3_vfs *sqlite3_vfs_find(const char *zVfsName);
int sqlite3_vfs_register(sqlite3_vfs*, int makeDflt);
int sqlite3_vfs_unregister(sqlite3_vfs*);

虛擬檔案系統 (VFS) 是 sqlite3_vfs 物件，SQLite 使用它與底層作業系統互動。大多數 SQLite 建置都附帶一個單一預設 VFS，它適用於主機電腦。可以註冊新的 VFS，也可以取消註冊現有的 VFS。提供下列介面。

sqlite3_vfs_find() 介面會傳回 VFS 的指標，給定其名稱。名稱會區分大小寫。名稱是零終止的 UTF-8 字串。如果沒有相符項，則傳回 NULL 指標。如果 zVfsName 是 NULL，則傳回預設 VFS。

新的 VFS 會使用 sqlite3_vfs_register() 註冊。如果設定 makeDflt 旗標，每個新的 VFS 都會成為預設 VFS。可以多次註冊相同的 VFS，而不會造成損害。若要將現有的 VFS 設為預設 VFS，請再次註冊它，並設定 makeDflt 旗標。如果註冊了兩個具有相同名稱的不同 VFS，則行為未定義。如果註冊的 VFS 名稱是 NULL 或空字串，則行為未定義。

使用 sqlite3_vfs_unregister() 介面取消註冊 VFS。如果取消註冊預設 VFS，則會選擇另一個 VFS 作為預設。新 VFS 的選擇是任意的。

---

在 IN 約束的右側找出所有元素。

int sqlite3_vtab_in_first(sqlite3_value *pVal, sqlite3_value **ppOut);
int sqlite3_vtab_in_next(sqlite3_value *pVal, sqlite3_value **ppOut);

這些介面僅在 xFilter() 方法 的 虛擬表格 實作中才有用。從任何其他內容呼叫這些介面的結果未定義，而且可能是有害的。

在呼叫 sqlite3_vtab_in_first(X,P) 或 sqlite3_vtab_in_next(X,P) 時，X 參數應為呼叫這些常式的 xFilter 方法的參數之一，特別是先前選取用於一次性 IN 約束處理的參數，使用 sqlite3_vtab_in() 介面在 xBestIndex 方法 中。如果 X 參數不是選取用於一次性 IN 約束處理的 xFilter 參數，則這些常式會傳回 SQLITE_ERROR。

使用這些常式存取 IN 約束右側的所有值，使用類似下列的程式碼

   for(rc=sqlite3_vtab_in_first(pList, &pVal);
       rc==SQLITE_OK && pVal;
       rc=sqlite3_vtab_in_next(pList, &pVal)
   ){
     // do something with pVal
   }
   if( rc!=SQLITE_OK ){
     // an error has occurred
   }

成功時，sqlite3_vtab_in_first(X,P) 和 sqlite3_vtab_in_next(X,P) 常式會傳回 SQLITE_OK，並將 *P 設定為指向 IN 約束右側的第一個或下一個值。如果 IN 約束右側沒有更多值，則 *P 會設定為 NULL，且這些常式會傳回 SQLITE_DONE。在發生故障時，傳回值可能是其他值，例如 SQLITE_NOMEM。

這些常式傳回的 *ppOut 值僅在下次呼叫這些常式或呼叫這些常式的 xFilter 方法結束前有效。如果虛擬表格實作需要保留 *ppOut 值較長時間，則必須建立副本。*ppOut 值是 受保護的。

---

Win32 特定介面

int sqlite3_win32_set_directory(
  unsigned long type, /* Identifier for directory being set or reset */
  void *zValue        /* New value for directory being set or reset */
);
int sqlite3_win32_set_directory8(unsigned long type, const char *zValue);
int sqlite3_win32_set_directory16(unsigned long type, const void *zValue);

這些介面僅在 Windows 上可用。sqlite3_win32_set_directory 介面用於設定與 sqlite3_temp_directory 或 sqlite3_data_directory 變數相關聯的值，為 zValue，視 type 參數的值而定。zValue 參數應為 NULL，以導致先前值透過 sqlite3_free 釋放；非 NULL 值會在使用前複製到從 sqlite3_malloc 取得的記憶體中。sqlite3_win32_set_directory 介面傳回 SQLITE_OK 表示成功，SQLITE_ERROR 表示類型不受支援，或 SQLITE_NOMEM 表示無法配置記憶體。sqlite3_data_directory 變數的值旨在作為 Win32 子平台上目前目錄的替代，在這些子平台上不存在該概念，例如 WinRT 和 UWP。sqlite3_win32_set_directory8 和 sqlite3_win32_set_directory16 介面的行為與 sqlite3_win32_set_directory 介面完全相同，但字串參數分別必須為 UTF-8 或 UTF-16。

---

將值繫結至已準備好的陳述式

int sqlite3_bind_blob(sqlite3_stmt*, int, const void*, int n, void(*)(void*));
int sqlite3_bind_blob64(sqlite3_stmt*, int, const void*, sqlite3_uint64,
                        void(*)(void*));
int sqlite3_bind_double(sqlite3_stmt*, int, double);
int sqlite3_bind_int(sqlite3_stmt*, int, int);
int sqlite3_bind_int64(sqlite3_stmt*, int, sqlite3_int64);
int sqlite3_bind_null(sqlite3_stmt*, int);
int sqlite3_bind_text(sqlite3_stmt*,int,const char*,int,void(*)(void*));
int sqlite3_bind_text16(sqlite3_stmt*, int, const void*, int, void(*)(void*));
int sqlite3_bind_text64(sqlite3_stmt*, int, const char*, sqlite3_uint64,
                         void(*)(void*), unsigned char encoding);
int sqlite3_bind_value(sqlite3_stmt*, int, const sqlite3_value*);
int sqlite3_bind_pointer(sqlite3_stmt*, int, void*, const char*,void(*)(void*));
int sqlite3_bind_zeroblob(sqlite3_stmt*, int, int n);
int sqlite3_bind_zeroblob64(sqlite3_stmt*, int, sqlite3_uint64);

在輸入至 sqlite3_prepare_v2() 及其變體的 SQL 陳述式文字中，文字常數可以用 參數 取代，該參數符合下列範本之一

• ?
• ?NNN
• :VVV
• @VVV
• $VVV

在上述範本中，NNN 代表整數文字常數，而 VVV 代表字母數字識別碼。這些參數的值（也稱為「主機參數名稱」或「SQL 參數」）可以使用此處定義的 sqlite3_bind_*() 常式設定。

sqlite3_bind_*() 常式的第一個引數永遠是指向從 sqlite3_prepare_v2() 或其變體傳回的 sqlite3_stmt 物件。

第二個參數是要設定的 SQL 參數索引。最左邊的 SQL 參數索引為 1。當同名的 SQL 參數使用超過一次時，第二次和後續出現的索引與第一次出現的相同。如果需要，可以使用 sqlite3_bind_parameter_index() API 來查詢命名參數的索引。"?NNN" 參數的索引為 NNN 的值。NNN 值必須介於 1 和 sqlite3_limit() 參數 SQLITE_LIMIT_VARIABLE_NUMBER（預設值：32766）之間。

第三個參數是要繫結到參數的值。如果 sqlite3_bind_text()、sqlite3_bind_text16() 或 sqlite3_bind_blob() 的第三個參數是 NULL 指標，則會忽略第四個參數，最終結果與 sqlite3_bind_null() 相同。如果 sqlite3_bind_text() 的第三個參數不是 NULL，則它應該是指向格式良好的 UTF8 文字的指標。如果 sqlite3_bind_text16() 的第三個參數不是 NULL，則它應該是指向格式良好的 UTF16 文字的指標。如果 sqlite3_bind_text64() 的第三個參數不是 NULL，則它應該是指向格式良好的 Unicode 字串的指標，如果第六個參數是 SQLITE_UTF8，則為 UTF8，否則為 UTF16。

UTF16 輸入文字的位元組順序由第一個字元中找到的位元組順序標記 (BOM, U+FEFF) 決定，該標記會被移除，或在沒有 BOM 的情況下，位元組順序是 sqlite3_bind_text16() 的主機電腦原生位元組順序或 sqlite3_bind_text64() 中第六個參數指定的位元組順序。如果 UTF16 輸入文字包含無效的 Unicode 字元，則 SQLite 可能會將這些無效字元變更為 Unicode 替換字元：U+FFFD。

在有第四個參數的例程中，其值是參數中的位元組數。說清楚一點：值是值中的位元組數，而不是字元數。如果 sqlite3_bind_text() 或 sqlite3_bind_text16() 的第四個參數為負數，則字串長度為到第一個零終結符號為止的位元組數。如果 sqlite3_bind_blob() 的第四個參數為負數，則行為未定義。如果為 sqlite3_bind_text() 或 sqlite3_bind_text16() 或 sqlite3_bind_text64() 提供非負第四個參數，則該參數必須是假設字串以 NUL 終止時，NUL 終止符號會出現的位元組偏移量。如果任何 NUL 字元出現在小於第四個參數值的位元組偏移量，則產生的字串值將包含嵌入式 NUL。包含嵌入式 NUL 的字串所涉及的運算式結果未定義。

BLOB 和字串繫結介面的第五個引數控制或指示第三個引數所參照的物件的生命期。有下列三種選項：(1) 可以傳遞一個在 SQLite 使用完 BLOB 或字串後將其清除的解構函式。它會在對繫結 API 的呼叫失敗時清除 BLOB 或字串，但如果第三個引數是 NULL 指標或第四個引數為負數，則不會呼叫解構函式。(2) 可以傳遞特殊常數 SQLITE_STATIC，以指出應用程式仍負責清除物件。在此情況下，物件和指向它的提供的指標必須保持有效，直到準備好的陳述式完成或同一個 SQL 引數繫結到其他項目（以較早發生的為準）。(3) 可以傳遞常數 SQLITE_TRANSIENT，以指出物件將在從 sqlite3_bind_*() 傳回之前複製。物件和指向它的指標必須保持有效，直到那時。然後，SQLite 將管理其私有副本的生命期。

sqlite3_bind_text64() 的第六個引數必須是 SQLITE_UTF8、SQLITE_UTF16、SQLITE_UTF16BE 或 SQLITE_UTF16LE 之一，以指定第三個引數中文字的編碼。如果 sqlite3_bind_text64() 的第六個引數不是上面顯示的允許值之一，或者如果文字編碼與第六個引數指定的編碼不同，則行為未定義。

sqlite3_bind_zeroblob() 常式會繫結一個長度為 N 的 BLOB，且該 BLOB 填滿零。在處理 zeroblob 時，會使用固定數量的記憶體（只有一個整數來儲存其大小）。zeroblob 的目的是作為 BLOB 的佔位符，其內容稍後會使用增量 BLOB I/O常式寫入。zeroblob 的負值會產生長度為零的 BLOB。

sqlite3_bind_pointer(S,I,P,T,D) 常式會使準備好的陳述式 S 中的第 I 個參數具有 NULL 的 SQL 值，但也會與類型為 T 的指標 P 關聯。D 是 NULL 指標或指向 P 的解構函數的指標。當 SQLite 完成使用 P 時，會以 P 的單一引數呼叫解構函數 D。T 參數應為靜態字串，最好是字串文字。sqlite3_bind_pointer() 常式是指標傳遞介面的一部分，已新增至 SQLite 3.20.0。

如果任何 sqlite3_bind_*() 常式呼叫時，準備好的陳述式的 NULL 指標或準備好的陳述式（sqlite3_step()的呼叫時間比sqlite3_reset()最近）而呼叫，則呼叫會傳回SQLITE_MISUSE。如果任何 sqlite3_bind_() 常式傳遞的準備好的陳述式已完成，則結果未定義且可能是有害的。

繫結不會由sqlite3_reset()常式清除。未繫結的參數會解釋為 NULL。

sqlite3_bind_* 常式在成功時傳回 SQLITE_OK，或在發生任何問題時傳回 錯誤代碼。如果字串或 BLOB 的大小超過 sqlite3_limit(SQLITE_LIMIT_LENGTH) 或 SQLITE_MAX_LENGTH 所施加的限制，可能會傳回 SQLITE_TOOBIG。如果參數索引超出範圍，則會傳回 SQLITE_RANGE。如果 malloc() 失敗，則會傳回 SQLITE_NOMEM。

另請參閱：sqlite3_bind_parameter_count()、sqlite3_bind_parameter_name() 和 sqlite3_bind_parameter_index()。

---

編譯 SQL 陳述式

int sqlite3_prepare(
  sqlite3 *db,            /* Database handle */
  const char *zSql,       /* SQL statement, UTF-8 encoded */
  int nByte,              /* Maximum length of zSql in bytes. */
  sqlite3_stmt **ppStmt,  /* OUT: Statement handle */
  const char **pzTail     /* OUT: Pointer to unused portion of zSql */
);
int sqlite3_prepare_v2(
  sqlite3 *db,            /* Database handle */
  const char *zSql,       /* SQL statement, UTF-8 encoded */
  int nByte,              /* Maximum length of zSql in bytes. */
  sqlite3_stmt **ppStmt,  /* OUT: Statement handle */
  const char **pzTail     /* OUT: Pointer to unused portion of zSql */
);
int sqlite3_prepare_v3(
  sqlite3 *db,            /* Database handle */
  const char *zSql,       /* SQL statement, UTF-8 encoded */
  int nByte,              /* Maximum length of zSql in bytes. */
  unsigned int prepFlags, /* Zero or more SQLITE_PREPARE_ flags */
  sqlite3_stmt **ppStmt,  /* OUT: Statement handle */
  const char **pzTail     /* OUT: Pointer to unused portion of zSql */
);
int sqlite3_prepare16(
  sqlite3 *db,            /* Database handle */
  const void *zSql,       /* SQL statement, UTF-16 encoded */
  int nByte,              /* Maximum length of zSql in bytes. */
  sqlite3_stmt **ppStmt,  /* OUT: Statement handle */
  const void **pzTail     /* OUT: Pointer to unused portion of zSql */
);
int sqlite3_prepare16_v2(
  sqlite3 *db,            /* Database handle */
  const void *zSql,       /* SQL statement, UTF-16 encoded */
  int nByte,              /* Maximum length of zSql in bytes. */
  sqlite3_stmt **ppStmt,  /* OUT: Statement handle */
  const void **pzTail     /* OUT: Pointer to unused portion of zSql */
);
int sqlite3_prepare16_v3(
  sqlite3 *db,            /* Database handle */
  const void *zSql,       /* SQL statement, UTF-16 encoded */
  int nByte,              /* Maximum length of zSql in bytes. */
  unsigned int prepFlags, /* Zero or more SQLITE_PREPARE_ flags */
  sqlite3_stmt **ppStmt,  /* OUT: Statement handle */
  const void **pzTail     /* OUT: Pointer to unused portion of zSql */
);

若要執行 SQL 陳述式，必須先使用下列其中一個常式將其編譯成位元組碼程式。換句話說，這些常式是 已準備好的陳述式 物件的建構函式。

建議使用的常式是 sqlite3_prepare_v2()。sqlite3_prepare() 介面已過時，應避免使用。sqlite3_prepare_v3() 有額外的「prepFlags」選項，用於特殊目的。

建議使用 UTF-8 介面，因為 SQLite 目前使用 UTF-8 進行所有剖析。UTF-16 介面提供為一種便利性。UTF-16 介面透過將輸入文字轉換為 UTF-8，然後呼叫對應的 UTF-8 介面來運作。

第一個參數「db」是從先前成功呼叫 sqlite3_open()、sqlite3_open_v2() 或 sqlite3_open16() 取得的 資料庫連線。資料庫連線不得已關閉。

第二個參數「zSql」是要編譯的陳述式，編碼為 UTF-8 或 UTF-16。sqlite3_prepare()、sqlite3_prepare_v2() 和 sqlite3_prepare_v3() 介面使用 UTF-8，而 sqlite3_prepare16()、sqlite3_prepare16_v2() 和 sqlite3_prepare16_v3() 使用 UTF-16。

如果 nByte 參數為負，則 zSql 會讀取至第一個零終止符。如果 nByte 為正，則為從 zSql 讀取的位元組數。如果 nByte 為零，則不會產生已準備好的陳述式。如果呼叫者知道提供的字串為零終止，則傳遞 nByte 參數（為輸入字串中的位元組數，包含零終止符）會帶來一些效能優勢。

如果 pzTail 不為 NULL，則 *pzTail 會指向 zSql 中第一個 SQL 陳述式結束後的位元組。這些常式只會編譯 zSql 中的第一個陳述式，因此 *pzTail 會指向未編譯的內容。

*ppStmt 會指向已編譯的 已準備好的陳述式，可以使用 sqlite3_step() 執行。如果發生錯誤，*ppStmt 會設為 NULL。如果輸入文字不包含 SQL（如果輸入為空字串或註解），則 *ppStmt 會設為 NULL。呼叫程序負責使用 sqlite3_finalize() 刪除已編譯的 SQL 陳述式，在完成後。ppStmt 不可為 NULL。

成功時，sqlite3_prepare() 常式會傳回 SQLITE_OK；否則會傳回 錯誤代碼。

建議所有新程式使用 sqlite3_prepare_v2()、sqlite3_prepare_v3()、sqlite3_prepare16_v2() 和 sqlite3_prepare16_v3() 介面。舊介面 (sqlite3_prepare() 和 sqlite3_prepare16()) 僅為維持向下相容性而保留，但建議不要使用。在「vX」介面中，傳回的準備陳述式 (即 sqlite3_stmt 物件) 包含原始 SQL 文字的副本。這會讓 sqlite3_step() 介面的行為在三個方面有所不同

1. 如果資料庫結構變更，sqlite3_step() 動作會和以前不同，它不會再傳回 SQLITE_SCHEMA，而是會自動重新編譯 SQL 陳述式並嘗試再次執行。在 sqlite3_step() 放棄並傳回錯誤之前，會進行多達 SQLITE_MAX_SCHEMA_RETRY 次的重試。
2. 當錯誤發生時，sqlite3_step() 會傳回詳細的 錯誤碼 或 延伸錯誤碼 之一。舊有的行為是 sqlite3_step() 只會傳回一般性的 SQLITE_ERROR 結果碼，而應用程式必須再呼叫 sqlite3_reset() 一次才能找出問題的根本原因。使用「v2」準備介面，錯誤的根本原因會立即傳回。
3. 如果 WHERE 子句中與 主機參數 綁定的特定值可能會影響陳述式的查詢計畫選擇，則該陳述式將在第一次 sqlite3_step() 呼叫後自動重新編譯，就像架構已變更一樣，在任何 綁定 的 參數 變更之後。WHERE 子句 參數 的特定值可能會影響查詢計畫的選擇，如果參數是 LIKE 或 GLOB 運算子的左側，或如果參數與索引欄位進行比較，且 SQLITE_ENABLE_STAT4 編譯時間選項已啟用。

sqlite3_prepare_v3() 與 sqlite3_prepare_v2() 唯一的不同在於具有額外的 prepFlags 參數，它是一個由零個或多個 SQLITE_PREPARE_* 旗標組成的位元陣列。sqlite3_prepare_v2() 介面與具有零 prepFlags 參數的 sqlite3_prepare_v3() 完全相同。

---

編譯時間授權回呼

int sqlite3_set_authorizer(
  sqlite3*,
  int (*xAuth)(void*,int,const char*,const char*,const char*,const char*),
  void *pUserData
);

此常式會註冊授權呼叫回函與特定 資料庫連線，在第一個引數中提供。當 SQL 陳述式由 sqlite3_prepare() 或其變體 sqlite3_prepare_v2()、sqlite3_prepare_v3()、sqlite3_prepare16()、sqlite3_prepare16_v2() 和 sqlite3_prepare16_v3() 編譯時，會呼叫授權呼叫回函。在編譯程序的各個點中，當邏輯被建立來執行各種動作時，會呼叫授權呼叫回函以查看是否允許這些動作。授權呼叫回函應傳回 SQLITE_OK 以允許動作，SQLITE_IGNORE 以不允許特定動作，但允許 SQL 陳述式繼續編譯，或 SQLITE_DENY 以導致整個 SQL 陳述式被拒絕並產生錯誤。如果授權呼叫回函傳回任何值，除了 SQLITE_IGNORE、SQLITE_OK 或 SQLITE_DENY 之外，觸發授權的 sqlite3_prepare_v2() 或等效呼叫會失敗並顯示錯誤訊息。

當呼叫回函傳回 SQLITE_OK 時，表示要求的操作是正確的。當呼叫回函傳回 SQLITE_DENY 時，觸發授權的 sqlite3_prepare_v2() 或等效呼叫會失敗並顯示錯誤訊息，說明存取遭拒絕。

授權呼叫回函的第一個參數是 sqlite3_set_authorizer() 介面的第三個參數的副本。呼叫回函的第二個參數是整數 動作碼，用來指定要授權的特定動作。呼叫回函的第三個到第六個參數是 NULL 指標或以零終止的字串，其中包含要授權的動作的其他詳細資料。應用程式必須隨時準備好，在授權呼叫回函的第三個到第六個參數中遇到 NULL 指標。

如果動作碼是 SQLITE_READ，而呼叫回函傳回 SQLITE_IGNORE，則會建構 已準備好的陳述式 陳述式，以 NULL 值取代如果傳回 SQLITE_OK 時會讀取的表格欄位。 SQLITE_IGNORE 傳回值可用於拒絕不受信任的使用者存取表格的個別欄位。當表格由 SELECT 參照，但未從該表格中擷取任何欄位值（例如在類似「SELECT count(*) FROM tab」的查詢中），則會針對該表格呼叫 SQLITE_READ 授權呼叫回函一次，而欄位名稱為空字串。如果動作碼是 SQLITE_DELETE，而呼叫回函傳回 SQLITE_IGNORE，則 DELETE 作業會繼續執行，但會停用 截斷最佳化，而且會個別刪除所有列。

當從不受信任的來源 準備 SQL 陳述式時，會使用授權，以確保 SQL 陳述式不會嘗試存取他們無權查看的資料，或不會嘗試執行會損壞資料庫的惡意陳述式。例如，應用程式可能允許使用者輸入任意 SQL 查詢，以供資料庫評估。但是，應用程式不希望使用者能夠對資料庫進行任意變更。因此，可以在 準備使用者輸入的 SQL 時，放置一個授權，禁止除 SELECT 陳述式以外的所有內容。

需要處理來自不受信任來源 SQL 的應用程式，也可能考慮使用 sqlite3_limit() 降低資源限制，並使用 max_page_count PRAGMA 限制資料庫大小，除了使用授權者。

一次只有一個授權者可以在資料庫連線上。每次呼叫 sqlite3_set_authorizer 會覆寫前一次呼叫。安裝 NULL 回呼來停用授權者。授權者預設為停用。

授權者回呼不得執行任何會修改呼叫授權者回呼的資料庫連線。請注意，sqlite3_prepare_v2() 和 sqlite3_step() 都會修改其資料庫連線，以符合本段落中「修改」的意義。

當 sqlite3_prepare_v2() 用於準備陳述式時，由於架構變更，陳述式可能會在 sqlite3_step() 期間重新準備。因此，應用程式應確保在 sqlite3_step() 期間正確的授權者回呼仍然存在。

請注意，僅在 sqlite3_prepare() 或其變體期間呼叫授權者回呼。在 sqlite3_step() 的陳述式評估期間不會執行授權，除非如前一段所述，sqlite3_step() 在架構變更後呼叫 sqlite3_prepare_v2() 以重新準備陳述式。

---

測試自動提交模式

int sqlite3_get_autocommit(sqlite3*);

如果指定的資料庫連線處於自動提交模式，則 sqlite3_get_autocommit() 介面會傳回非零值；否則傳回零值。預設情況下，自動提交模式為開啟。自動提交模式會因 BEGIN 陳述式而停用。自動提交模式會因 COMMIT 或 ROLLBACK 而重新啟用。

如果在多重陳述式交易中，陳述式發生特定類型的錯誤（包括 SQLITE_FULL、SQLITE_IOERR、SQLITE_NOMEM、SQLITE_BUSY 和 SQLITE_INTERRUPT），則交易可能會自動回滾。找出 SQLite 是否在錯誤後自動回滾交易的唯一方法是使用此函數。

如果在這個常式執行時，另一個執行緒改變了資料庫連線的自動提交狀態，那麼回傳值是不確定的。

---

註冊一個回呼函式來處理 SQLITE_BUSY 錯誤

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

sqlite3_busy_handler(D,X,P) 常式設定一個回呼函式 X，當嘗試存取與 資料庫連線 D 相關的資料庫表格時，如果另一個執行緒或程序已鎖定表格，可能會以參數 P 呼叫此回呼函式。sqlite3_busy_handler() 介面用於實作 sqlite3_busy_timeout() 和 PRAGMA busy_timeout。

如果忙碌回呼函式為 NULL，則在遇到鎖定時會立即回傳 SQLITE_BUSY。如果忙碌回呼函式不為 NULL，則可能會以兩個參數呼叫回呼函式。

忙碌處理常式的第一個參數是 void* 指標的複本，它是 sqlite3_busy_handler() 的第三個參數。忙碌處理常式的第二個參數是忙碌處理常式先前針對同一個鎖定事件呼叫的次數。如果忙碌回呼函式回傳 0，則不會再嘗試存取資料庫，並會回傳 SQLITE_BUSY 給應用程式。如果回呼函式回傳非零值，則會再嘗試存取資料庫，並重複這個循環。

繁忙處理常式的存在並不能保證在鎖定爭用時會被呼叫。如果 SQLite 判定呼叫繁忙處理常式可能會導致死結，它會繼續並傳回 SQLITE_BUSY 給應用程式，而不是呼叫繁忙處理常式。考慮一個場景，其中一個程序持有讀取鎖定，並嘗試將其提升為保留鎖定，而另一個程序持有保留鎖定，並嘗試將其提升為獨佔鎖定。第一個程序無法繼續，因為它被第二個程序封鎖，而第二個程序也無法繼續，因為它被第一個程序封鎖。如果兩個程序都呼叫繁忙處理常式，則都不會取得任何進展。因此，SQLite 會傳回 SQLITE_BUSY 給第一個程序，希望這會誘使第一個程序釋放其讀取鎖定，並允許第二個程序繼續執行。

預設繁忙回呼為 NULL。

每個 資料庫連線 只可以定義一個繁忙處理常式。設定新的繁忙處理常式會清除任何先前設定的處理常式。請注意，呼叫 sqlite3_busy_timeout() 或評估 PRAGMA busy_timeout=N 會變更繁忙處理常式，因此會清除任何先前設定的繁忙處理常式。

繁忙回呼不應採取任何修改呼叫繁忙處理常式的資料庫連線的動作。換句話說，繁忙處理常式不是可重入的。任何此類動作都會導致未定義的行為。

繁忙處理常式不得關閉呼叫繁忙處理常式的資料庫連線或 已準備好的陳述。

---

查詢的結果值

const void *sqlite3_column_blob(sqlite3_stmt*, int iCol);
double sqlite3_column_double(sqlite3_stmt*, int iCol);
int sqlite3_column_int(sqlite3_stmt*, int iCol);
sqlite3_int64 sqlite3_column_int64(sqlite3_stmt*, int iCol);
const unsigned char *sqlite3_column_text(sqlite3_stmt*, int iCol);
const void *sqlite3_column_text16(sqlite3_stmt*, int iCol);
sqlite3_value *sqlite3_column_value(sqlite3_stmt*, int iCol);
int sqlite3_column_bytes(sqlite3_stmt*, int iCol);
int sqlite3_column_bytes16(sqlite3_stmt*, int iCol);
int sqlite3_column_type(sqlite3_stmt*, int iCol);

摘要

sqlite3_column_blob	→	BLOB 結果
sqlite3_column_double	→	REAL 結果
sqlite3_column_int	→	32 位元組 INTEGER 結果
sqlite3_column_int64	→	64 位元組 INTEGER 結果
sqlite3_column_text	→	UTF-8 TEXT 結果
sqlite3_column_text16	→	UTF-16 TEXT 結果
sqlite3_column_value	→	結果為 未保護的 sqlite3_value 物件。
sqlite3_column_bytes	→	BLOB 或 UTF-8 TEXT 結果的位元組大小
sqlite3_column_bytes16	→	UTF-16 TEXT 的大小（以位元組為單位）
sqlite3_column_type	→	結果的預設資料型態

詳細資料

這些常式回傳查詢目前結果列中單一欄位的資訊。在每個情況下，第一個參數都是指向正在評估的 已準備好陳述式 的指標（sqlite3_stmt* 從 sqlite3_prepare_v2() 或其變體回傳），第二個參數則是應該回傳資訊的欄位索引。結果集的最左欄位索引為 0。可以使用 sqlite3_column_count() 來判斷結果中的欄位數量。

如果 SQL 陳述式目前未指向有效列，或是欄位索引超出範圍，結果將未定義。只有在最近一次呼叫 sqlite3_step() 回傳 SQLITE_ROW，且尚未呼叫 sqlite3_reset() 或 sqlite3_finalize() 之後，才能呼叫這些常式。如果在呼叫 sqlite3_reset() 或 sqlite3_finalize() 之後，或是 sqlite3_step() 回傳非 SQLITE_ROW 之後，呼叫任何這些常式，結果將未定義。如果在任何這些常式待處理時，從不同執行緒呼叫 sqlite3_step()、sqlite3_reset() 或 sqlite3_finalize()，結果將未定義。

前六個介面（_blob、_double、_int、_int64、_text 和 _text16）各回傳特定資料格式中結果欄位的數值。如果結果欄位最初不在所要求的格式中（例如，如果查詢回傳整數，但使用 sqlite3_column_text() 介面來萃取數值），則會執行自動類型轉換。

sqlite3_column_type() 常式會傳回結果欄位初始資料類型的 資料類型代碼。傳回的值為 SQLITE_INTEGER、SQLITE_FLOAT、SQLITE_TEXT、SQLITE_BLOB 或 SQLITE_NULL 之一。sqlite3_column_type() 的傳回值可用於決定應使用哪一個前六個介面來萃取欄位值。sqlite3_column_type() 傳回的值僅在針對問題中的值未發生自動類型轉換時才有意義。在類型轉換後，呼叫 sqlite3_column_type() 的結果未定義，但無害。SQLite 的未來版本可能會在類型轉換後變更 sqlite3_column_type() 的行為。

如果結果為 BLOB 或 TEXT 字串，則可使用 sqlite3_column_bytes() 或 sqlite3_column_bytes16() 介面來判斷該 BLOB 或字串的大小。

如果結果為 BLOB 或 UTF-8 字串，則 sqlite3_column_bytes() 常式會傳回該 BLOB 或字串中的位元組數。如果結果為 UTF-16 字串，則 sqlite3_column_bytes() 會將字串轉換為 UTF-8，然後傳回位元組數。如果結果為數值，則 sqlite3_column_bytes() 會使用 sqlite3_snprintf() 將該值轉換為 UTF-8 字串，然後傳回該字串中的位元組數。如果結果為 NULL，則 sqlite3_column_bytes() 會傳回零。

如果結果為 BLOB 或 UTF-16 字串，則 sqlite3_column_bytes16() 常式會傳回該 BLOB 或字串中的位元組數。如果結果為 UTF-8 字串，則 sqlite3_column_bytes16() 會將字串轉換為 UTF-16，然後傳回位元組數。如果結果為數值，則 sqlite3_column_bytes16() 會使用 sqlite3_snprintf() 將該值轉換為 UTF-16 字串，然後傳回該字串中的位元組數。如果結果為 NULL，則 sqlite3_column_bytes16() 會傳回零。

由 sqlite3_column_bytes() 和 sqlite3_column_bytes16() 傳回的值不包含字串結尾的零終止符。為清楚起見：sqlite3_column_bytes() 和 sqlite3_column_bytes16() 傳回的值是字串中的位元組數，而不是字元數。

由 sqlite3_column_text() 和 sqlite3_column_text16() 傳回的字串，即使是空字串，總是零終止的。對於零長度 BLOB，sqlite3_column_blob() 的傳回值是 NULL 指標。

由 sqlite3_column_text16() 傳回的字串總是具有與平台本機相同的位元序，而不論為資料庫設定的文字編碼為何。

警告：sqlite3_column_value() 傳回的物件是 未受保護的 sqlite3_value 物件。在多執行緒環境中，未受保護的 sqlite3_value 物件只能與 sqlite3_bind_value() 和 sqlite3_result_value() 安全地一起使用。如果以任何其他方式使用 sqlite3_column_value() 傳回的 未受保護的 sqlite3_value 物件，包括呼叫 sqlite3_value_int()、sqlite3_value_text() 或 sqlite3_value_bytes() 等常式，其行為將不是執行緒安全的。因此，sqlite3_column_value() 介面通常只在 應用程式定義的 SQL 函數 或 虛擬表格 的實作中才有用，而不是在頂層應用程式程式碼中。

這些常式可能會嘗試轉換結果的資料類型。例如，如果內部表示是 FLOAT 且要求文字結果，sqlite3_snprintf() 會在內部使用來自動執行轉換。下表詳細說明所套用的轉換

內部 類型	要求 類型	轉換
NULL	INTEGER	結果為 0
NULL	FLOAT	結果為 0.0
NULL	TEXT	結果為 NULL 指標
NULL	BLOB	結果為 NULL 指標
INTEGER	FLOAT	將整數轉換為浮點數
INTEGER	TEXT	整數的 ASCII 呈現
INTEGER	BLOB	與 INTEGER->TEXT 相同
FLOAT	INTEGER	CAST 為 INTEGER
FLOAT	TEXT	浮點數的 ASCII 呈現
FLOAT	BLOB	CAST 為 BLOB
TEXT	INTEGER	CAST 為 INTEGER
TEXT	FLOAT	CAST 為 REAL
TEXT	BLOB	不變更
BLOB	INTEGER	CAST 為 INTEGER
BLOB	FLOAT	CAST 為 REAL
BLOB	TEXT	CAST 為 TEXT，確保零終止符

請注意，當發生類型轉換時，先前呼叫 sqlite3_column_blob()、sqlite3_column_text() 和/或 sqlite3_column_text16() 所傳回的指標可能會失效。類型轉換和指標失效可能會在以下情況發生

• 初始內容為 BLOB，且呼叫了 sqlite3_column_text() 或 sqlite3_column_text16()。可能需要在字串中加入零終止符。
• 初始內容為 UTF-8 文字，且呼叫了 sqlite3_column_bytes16() 或 sqlite3_column_text16()。必須將內容轉換為 UTF-16。
• 初始內容為 UTF-16 文字，且呼叫了 sqlite3_column_bytes() 或 sqlite3_column_text()。必須將內容轉換為 UTF-8。

UTF-16be 和 UTF-16le 之間的轉換總是就地進行，且不會使先前的指標失效，儘管先前指標所參照的緩衝區內容當然會被修改。其他類型的轉換在可能的情況下會就地進行，但有時無法進行，在這種情況下，先前的指標會失效。

最安全的策略是使用下列其中一種方式呼叫這些常式

• sqlite3_column_text() 接著是 sqlite3_column_bytes()
• sqlite3_column_blob() 接著是 sqlite3_column_bytes()
• sqlite3_column_text16() 接著是 sqlite3_column_bytes16()

換句話說，您應該先呼叫 sqlite3_column_text()、sqlite3_column_blob() 或 sqlite3_column_text16() 以強制結果轉換為所需格式，然後呼叫 sqlite3_column_bytes() 或 sqlite3_column_bytes16() 以找出結果的大小。請勿將呼叫 sqlite3_column_text() 或 sqlite3_column_blob() 與呼叫 sqlite3_column_bytes16() 混用，也不要將呼叫 sqlite3_column_text16() 與呼叫 sqlite3_column_bytes() 混用。

傳回的指標在發生上述類型轉換之前，或在呼叫 sqlite3_step() 或 sqlite3_reset() 或 sqlite3_finalize() 之前都是有效的。用來儲存字串和 BLOB 的記憶體空間會自動釋放。請勿將從 sqlite3_column_blob()、sqlite3_column_text() 等傳回的指標傳遞到 sqlite3_free()。

只要輸入參數正確，這些常式只會在格式轉換期間發生記憶體不足錯誤時才會失敗。只有下列介面子集會受到記憶體不足錯誤影響

• sqlite3_column_blob()
• sqlite3_column_text()
• sqlite3_column_text16()
• sqlite3_column_bytes()
• sqlite3_column_bytes16()

如果發生記憶體不足錯誤，則這些常式的傳回值會與欄位包含 SQL NULL 值相同。有效的 SQL NULL 傳回值可以透過在取得可疑傳回值後立即呼叫 sqlite3_errcode()，且在同一個 資料庫連線 上呼叫任何其他 SQLite 介面之前，來區分記憶體不足錯誤。

---

資料庫檔案的低階控制

int sqlite3_file_control(sqlite3*, const char *zDbName, int op, void*);

對於由第二個參數識別的特定資料庫所關聯的 sqlite3_io_methods 物件，sqlite3_file_control() 介面會直接呼叫 xFileControl 方法。資料庫名稱對於主資料庫為「main」，對於 TEMP 資料庫為「temp」，或對於使用 ATTACH SQL 指令新增的資料庫，則為出現在 AS 關鍵字之後的名稱。可使用 NULL 指標取代「main」來參照主資料庫檔案。此常式的第三個和第四個參數會直接傳遞到 xFileControl 方法的第二個和第三個參數。xFileControl 方法的傳回值會成為此常式的傳回值。

幾個 sqlite3_file_control() 的操作碼由 SQLite 核心直接處理，從不呼叫 sqlite3_io_methods.xFileControl 方法。SQLITE_FCNTL_FILE_POINTER 值對於 op 參數會導致指向底層 sqlite3_file 物件的指標寫入到由第 4 個參數指向的空間中。SQLITE_FCNTL_JOURNAL_POINTER 的運作方式類似，只不過它會傳回與日誌檔案相關聯的 sqlite3_file 物件，而不是主資料庫。 SQLITE_FCNTL_VFS_POINTER 操作碼會傳回指向檔案的底層 sqlite3_vfs 物件的指標。SQLITE_FCNTL_DATA_VERSION 會從分頁器傳回資料版本計數器。

如果第二個參數 (zDbName) 與任何開啟資料庫檔案的名稱不符，則會傳回 SQLITE_ERROR。此錯誤碼不會被記住，也不會由 sqlite3_errcode() 或 sqlite3_errmsg() 呼叫回來。底層 xFileControl 方法也可能會傳回 SQLITE_ERROR。無法區分不正確的 zDbName 和底層 xFileControl 方法傳回的 SQLITE_ERROR。

另請參閱：檔案控制操作碼

---

建立或重新定義 SQL 函數

int sqlite3_create_function(
  sqlite3 *db,
  const char *zFunctionName,
  int nArg,
  int eTextRep,
  void *pApp,
  void (*xFunc)(sqlite3_context*,int,sqlite3_value**),
  void (*xStep)(sqlite3_context*,int,sqlite3_value**),
  void (*xFinal)(sqlite3_context*)
);
int sqlite3_create_function16(
  sqlite3 *db,
  const void *zFunctionName,
  int nArg,
  int eTextRep,
  void *pApp,
  void (*xFunc)(sqlite3_context*,int,sqlite3_value**),
  void (*xStep)(sqlite3_context*,int,sqlite3_value**),
  void (*xFinal)(sqlite3_context*)
);
int sqlite3_create_function_v2(
  sqlite3 *db,
  const char *zFunctionName,
  int nArg,
  int eTextRep,
  void *pApp,
  void (*xFunc)(sqlite3_context*,int,sqlite3_value**),
  void (*xStep)(sqlite3_context*,int,sqlite3_value**),
  void (*xFinal)(sqlite3_context*),
  void(*xDestroy)(void*)
);
int sqlite3_create_window_function(
  sqlite3 *db,
  const char *zFunctionName,
  int nArg,
  int eTextRep,
  void *pApp,
  void (*xStep)(sqlite3_context*,int,sqlite3_value**),
  void (*xFinal)(sqlite3_context*),
  void (*xValue)(sqlite3_context*),
  void (*xInverse)(sqlite3_context*,int,sqlite3_value**),
  void(*xDestroy)(void*)
);

這些函數（統稱為「函數建立常式」）用於新增 SQL 函數或聚合，或重新定義現有 SQL 函數或聚合的行為。三個「sqlite3_create_function*」常式之間唯一的差異在於預期第二個參數（要建立的函數名稱）的文字編碼，以及應用程式資料指標是否有毀損器回呼。函數 sqlite3_create_window_function() 類似，但允許使用者提供 聚合視窗函數 所需的額外回呼函數。

第一個參數是 資料庫連線，SQL 函數將新增至其中。如果應用程式使用多個資料庫連線，則必須將應用程式定義的 SQL 函數分別新增至每個資料庫連線。

第二個參數是要建立或重新定義的 SQL 函數名稱。名稱長度限制為 UTF-8 表示形式中 255 個位元組，不含零終止符。請注意，名稱長度限制以 UTF-8 位元組為單位，而非字元或 UTF-16 位元組。任何嘗試建立名稱較長的函數，都將導致傳回 SQLITE_MISUSE。

第三個參數 (nArg) 是 SQL 函數或聚合函數所使用的引數數量。如果這個參數為 -1，則 SQL 函數或聚合函數可以使用 0 到 sqlite3_limit(SQLITE_LIMIT_FUNCTION_ARG) 設定的限制之間的任何引數數量。如果第三個參數小於 -1 或大於 127，則行為未定義。

第四個參數 eTextRep 指定此 SQL 函數偏好其參數的 文字編碼。如果函數實作呼叫輸入的 sqlite3_value_text16le()，應用程式應將此參數設定為 SQLITE_UTF16LE；如果實作呼叫輸入的 sqlite3_value_text16be()，則設定為 SQLITE_UTF16BE；如果使用 sqlite3_value_text16()，則設定為 SQLITE_UTF16；否則設定為 SQLITE_UTF8。相同的 SQL 函數可以使用不同的偏好文字編碼多次註冊，並針對每種編碼提供不同的實作。當有相同函數的多個實作可用時，SQLite 會選擇涉及最少資料轉換的實作。

第四個參數可以選擇性地與 SQLITE_DETERMINISTIC 進行 OR 運算，以表示函數在單一 SQL 陳述式中給定相同的輸入時，將永遠傳回相同的結果。大部分的 SQL 函數都是確定性的。內建的 random() SQL 函數是非確定性函數的範例。SQLite 查詢規劃器能夠對確定性函數執行其他最佳化，因此建議在可能的情況下使用 SQLITE_DETERMINISTIC 旗標。

第四個參數也可以選擇性地包含 SQLITE_DIRECTONLY 旗標，如果存在此旗標，函數將無法從 VIEW、觸發器、CHECK 約束、已產生欄位運算式、索引運算式或部分索引的 WHERE 子句中呼叫。

對於最佳安全性，建議所有應用程式定義的 SQL 函數使用 SQLITE_DIRECTONLY 旗標，這些函數不需要在觸發器、檢視、CHECK 約束或資料庫架構的其他元素中使用。特別建議將此旗標用於有副作用或揭露內部應用程式狀態的 SQL 函數。沒有此旗標，攻擊者可能會修改資料庫檔案的架構，以包含使用攻擊者選擇的參數呼叫函數，然後應用程式會在開啟並讀取資料庫檔案時執行該函數。

第五個參數是任意指標。函數的實作可以使用 sqlite3_user_data() 存取此指標。

傳遞給三個「sqlite3_create_function*」函數（xFunc、xStep 和 xFinal）的第六、第七和第八個參數，是實作 SQL 函數或聚合的 C 語言函數指標。純量 SQL 函數僅需要 xFunc 回呼的實作；xStep 和 xFinal 參數必須傳遞 NULL 指標。聚合 SQL 函數需要 xStep 和 xFinal 的實作，而 xFunc 必須傳遞 NULL 指標。若要刪除現有的 SQL 函數或聚合，請為所有三個函數回呼傳遞 NULL 指標。

傳遞給 sqlite3_create_window_function 的第六、第七、第八和第九個參數（xStep、xFinal、xValue 和 xInverse）是實作新函數的 C 語言回呼指標。xStep 和 xFinal 都必須是非 NULL。xValue 和 xInverse 可以都為 NULL，這種情況下會建立常規聚合函數，或都必須是非 NULL，這種情況下新函數可以用作聚合或聚合視窗函數。有關聚合視窗函數實作的更多詳細資訊，請按此處取得。

如果 sqlite3_create_function_v2() 或 sqlite3_create_window_function() 的最後一個參數不是 NULL，則它是應用程式資料指標的解構函數。當函數被刪除（透過覆載或資料庫連線關閉時）會呼叫解構函數。如果對 sqlite3_create_function_v2() 的呼叫失敗，也會呼叫解構函數。當呼叫解構函數回呼時，會傳遞一個單一引數，該引數是應用程式資料指標的副本，也就是 sqlite3_create_function_v2() 的第五個參數。

允許註冊具有相同名稱但具有不同數量的參數或不同的首選文字編碼的多個相同函數實作。SQLite 將使用與 SQL 函數使用方式最相符的實作。具有非負 nArg 參數的函數實作比具有負 nArg 的函數實作更相符。首選文字編碼與資料庫編碼相符的函數比編碼不同的函數更相符。編碼差異在 UTF16le 和 UTF16be 之間的函數比編碼差異在 UTF8 和 UTF16 之間的函數更相符。

內建函數可能會被新的應用程式定義函數覆載。

應用程式定義函數允許呼叫其他 SQLite 介面。但是，此類呼叫不得關閉資料庫連線，也不得完成或重設函數正在執行的已準備好陳述式。

---