VFS架构：
┌─────────────────────────────────────────┐
│ 应用程序层 │
├─────────────────────────────────────────┤
│ sqlite核心层 │
├─────────────────────────────────────────┤
│ VFS抽象层 │
├─────────────────────────────────────────┤
│ Unix VFS │ Windows VFS │ 自定义VFS │
├─────────────────────────────────────────┤
│ 操作系统文件系统 │
└─────────────────────────────────────────┘

VFS核心功能：
├── 文件操作：打开、关闭、读写
├── 锁定管理：文件锁实现
├── 内存映射：mmap支持
├── 目录操作：创建、删除目录
└── 系统调用：随机数、时间等

VFS对象结构：
├── sqlite3_vfs：VFS对象
│ ├── xOpen：打开文件
│ ├── xDelete：删除文件
│ ├── xAccess：检查访问权限
│ ├── xFullPathname：获取完整路径
│ └── 其他方法…
└── sqlite3_file：文件对象
├── pMethods：方法指针
└── 文件句柄

内置VFS：
├── unix：Unix/Linux系统
├── win32：Windows系统
├── os2：OS/2系统
└── 自定义VFS

VFS方法列表：
├── xOpen：打开文件
├── xDelete：删除文件
├── xAccess：检查文件存在
├── xFullPathname：获取完整路径
├── xDlOpen：加载动态库
├── xDlError：动态库错误
├── xDlSym：获取符号
├── xDlClose：关闭动态库
├── xRandomness：生成随机数
├── xSleep：休眠
├── xCurrentTime：获取当前时间
├── xGetLastError：获取最后错误
└── xCurrentTimeInt64：获取时间戳

文件方法列表：
├── xClose：关闭文件
├── xRead：读取数据
├── xWrite：写入数据
├── xTruncate：截断文件
├── xSync：同步数据
├── xFileSize：获取文件大小
├── xLock：加锁
├── xUnlock：解锁
├── xCheckReservedLock：检查保留锁
├── xFileControl：文件控制
├── xSectorSize：获取扇区大小
├── xDeviceCharacteristics：设备特性
└── xFetch/xUnfetch：内存映射

VFS注册：
├── sqlite3_vfs_register()：注册VFS
├── sqlite3_vfs_unregister()：注销VFS
└── sqlite3_vfs_find()：查找VFS

嵌入式特点：
├── 资源受限：内存、存储有限
├── 无操作系统：裸机或RTOS
├── 特殊文件系统：Flash、FAT等
├── 实时性要求：响应时间敏感
└── 功耗限制：低功耗设计

集成考虑因素：
├── 内存管理：自定义内存分配
├── 文件系统：适配目标文件系统
├── 线程安全：是否需要多线程
├── 电源管理：掉电保护
└── 性能优化：针对平台优化

移植要点：
├── 实现VFS接口
├── 配置编译选项
├── 内存管理适配
├── 错误处理
└── 测试验证

常见嵌入式平台：
├── ARM Cortex-M系列
├── ESP32/ESP8266
├── STM32
├── FreeRTOS
├── RT-Thread
└── Zephyr

1. VFS应用场景
├── 内存数据库：纯内存存储
├── 加密存储：透明加密
├── 网络存储：远程文件访问
├── 压缩存储：自动压缩
└── 审计日志：记录所有操作

2. VFS设计要点
├── 继承默认VFS
├── 只重写需要的方法
├── 保持兼容性
└── 错误处理

3. 性能考虑
├── 减少系统调用
├── 使用缓存
├── 批量操作
└── 异步IO

4. 安全考虑
├── 数据加密
├── 访问控制
├── 完整性校验
└── 审计日志

#include <sqlite3.h>
#include <stdio.h>
#include <string.h>

// 自定义文件对象
typedef struct CustomFile {
sqlite3_file base;
FILE *fp;
char *path;
} CustomFile;

// 文件方法实现
static int customClose(sqlite3_file *pFile) {
CustomFile *p = (CustomFile*)pFile;
if (p->fp) {
fclose(p->fp);
p->fp = NULL;
}
if (p->path) {
sqlite3_free(p->path);
p->path = NULL;
}
return SQLITE_OK;
}

static int customRead(sqlite3_file *pFile, void *zBuf, int iAmt, sqlite3_int64 iOfst) {
CustomFile *p = (CustomFile*)pFile;
fseek(p->fp, iOfst, SEEK_SET);
size_t nRead = fread(zBuf, 1, iAmt, p->fp);
if (nRead == iAmt) return SQLITE_OK;
if (nRead == 0) return SQLITE_IOERR_SHORT_READ;
memset((char*)zBuf + nRead, 0, iAmt – nRead);
return SQLITE_IOERR_SHORT_READ;
}

static int customWrite(sqlite3_file *pFile, const void *zBuf, int iAmt, sqlite3_int64 iOfst) {
CustomFile *p = (CustomFile*)pFile;
fseek(p->fp, iOfst, SEEK_SET);
size_t nWritten = fwrite(zBuf, 1, iAmt, p->fp);
return (nWritten == iAmt) ? SQLITE_OK : SQLITE_IOERR_WRITE;
}

static int customTruncate(sqlite3_file *pFile, sqlite3_int64 size) {
CustomFile *p = (CustomFile*)pFile;
fflush(p->fp);
return (ftruncate(fileno(p->fp), size) == 0) ? SQLITE_OK : SQLITE_IOERR_TRUNCATE;
}

static int customSync(sqlite3_file *pFile, int flags) {
CustomFile *p = (CustomFile*)pFile;
fflush(p->fp);
return SQLITE_OK;
}

static int customFileSize(sqlite3_file *pFile, sqlite3_int64 *pSize) {
CustomFile *p = (CustomFile*)pFile;
fseek(p->fp, 0, SEEK_END);
*pSize = ftell(p->fp);
return SQLITE_OK;
}

// 文件方法表
static sqlite3_io_methods customIoMethods = {
1, // iVersion
customClose, // xClose
customRead, // xRead
customWrite, // xWrite
customTruncate, // xTruncate
customSync, // xSync
customFileSize, // xFileSize
NULL, // xLock
NULL, // xUnlock
NULL, // xCheckReservedLock
NULL, // xFileControl
NULL, // xSectorSize
NULL, // xDeviceCharacteristics
NULL, // xFetch
NULL // xUnfetch
};

// VFS方法实现
static int customOpen(sqlite3_vfs *pVfs, const char *zPath, sqlite3_file *pFile,
int flags, int *pOutFlags) {
CustomFile *p = (CustomFile*)pFile;
memset(p, 0, sizeof(CustomFile));
p->base.pMethods = &customIoMethods;
p->path = sqlite3_mprintf(“%s”, zPath);

const char *mode = (flags & SQLITE_OPEN_READWRITE) ? “w+b” : “rb”;
p->fp = fopen(zPath, mode);

if (!p->fp && (flags & SQLITE_OPEN_CREATE)) {
p->fp = fopen(zPath, “w+b”);
}

return p->fp ? SQLITE_OK : SQLITE_CANTOPEN;
}

static int customDelete(sqlite3_vfs *pVfs, const char *zPath, int dirSync) {
return (remove(zPath) == 0) ? SQLITE_OK : SQLITE_IOERR_DELETE;
}

static int customAccess(sqlite3_vfs *pVfs, const char *zPath, int flags, int *pResOut) {
FILE *fp = fopen(zPath, “rb”);
*pResOut = (fp != NULL);
if (fp) fclose(fp);
return SQLITE_OK;
}

// 注册自定义VFS
int register_custom_vfs() {
static sqlite3_vfs customVfs = {
1, // iVersion
sizeof(CustomFile), // szOsFile
1024, // mxPathname
NULL, // pNext
“custom”, // zName
NULL, // pAppData
customOpen, // xOpen
customDelete, // xDelete
customAccess, // xAccess
// … 其他方法
};

return sqlite3_vfs_register(&customVfs, 0);
}

// 嵌入式平台配置
#define SQLITE_THREADSAFE 0
#define SQLITE_OMIT_LOAD_EXTENSION 1
#define SQLITE_OMIT_DEPRECATED 1
#define SQLITE_DEFAULT_CACHE_SIZE 100
#define SQLITE_DEFAULT_PAGE_SIZE 1024
#define SQLITE_MAX_LENGTH 100000

// 内存管理配置
#define SQLITE_ENABLE_MEMSYS5 1
#define SQLITE_DEFAULT_MEMSTATUS 0

// 文件系统适配
#define SQLITE_OS_OTHER 1 // 使用自定义VFS

// 编译命令
// gcc -c sqlite3.c \
// -DSQLITE_OS_OTHER \
// -DSQLITE_THREADSAFE=0 \
// -DSQLITE_OMIT_LOAD_EXTENSION \
// -include sqlite_config.h

// 内存分配器实现
static void *heap_memory = NULL;
static size_t heap_size = 0;
static size_t heap_used = 0;

void *custom_malloc(int n) {
if (heap_used + n > heap_size) return NULL;
void *p = (char*)heap_memory + heap_used;
heap_used += n;
return p;
}

void custom_free(void *p) {
// 简单分配器不支持释放
}

void *custom_realloc(void *p, int n) {
void *newp = custom_malloc(n);
if (newp && p) {
memcpy(newp, p, n); // 需要知道原大小
}
return newp;
}

// 配置sqlite使用自定义内存分配器
void sqlite3_config_memory(void *heap, size_t size) {
heap_memory = heap;
heap_size = size;
heap_used = 0;

sqlite3_config(SQLITE_CONFIG_MALLOC,
custom_malloc, custom_free, custom_realloc);
}

— 创建内存表
sqlite> CREATE TABLE memdb.fgedu_cache (
…> key TEXT PRIMARY KEY,
…> value TEXT,
…> expire_time INTEGER
…> );

— 插入缓存数据
sqlite> INSERT INTO memdb.fgedu_cache VALUES (‘user_001’, ‘{“name”:”风哥”}’, 1712505600);

— 查询缓存
sqlite> SELECT * FROM memdb.fgedu_cache;
user_001|{“name”:”风哥”}|1712505600

— 使用file:前缀创建共享内存数据库
sqlite> ATTACH DATABASE ‘file:memdb1?mode=memory&cache=shared’ AS shared_mem;

— 临时数据库
sqlite> CREATE TEMP TABLE temp_data (id INTEGER, data TEXT);

— 查看所有数据库
sqlite> .databases
main: /sqlite/fgdata/fgedudb.db
memdb:
temp:

C语言实现内存VFS：
/*
* memvfs.c – 内存VFS实现
* from:www.itpux.com.qq113257174.wx:itpux-com
* web: http://www.fgedu.net.cn
*/

typedef struct MemFile {
sqlite3_file base;
unsigned char *data;
sqlite3_int64 size;
sqlite3_int64 capacity;
} MemFile;

static int memWrite(sqlite3_file *pFile, const void *zBuf, int iAmt, sqlite3_int64 iOfst) {
MemFile *p = (MemFile*)pFile;
sqlite3_int64 end = iOfst + iAmt;

// 扩展容量
if (end > p->capacity) {
sqlite3_int64 newCap = end * 2;
unsigned char *newData = sqlite3_realloc(p->data, newCap);
if (!newData) return SQLITE_NOMEM;
p->data = newData;
p->capacity = newCap;
}

memcpy(p->data + iOfst, zBuf, iAmt);
if (end > p->size) p->size = end;

return SQLITE_OK;
}

static int memRead(sqlite3_file *pFile, void *zBuf, int iAmt, sqlite3_int64 iOfst) {
MemFile *p = (MemFile*)pFile;
if (iOfst >= p->size) {
memset(zBuf, 0, iAmt);
return SQLITE_IOERR_SHORT_READ;
}
if (iOfst + iAmt > p->size) {
int nRead = p->size – iOfst;
memcpy(zBuf, p->data + iOfst, nRead);
memset((char*)zBuf + nRead, 0, iAmt – nRead);
return SQLITE_IOERR_SHORT_READ;
}
memcpy(zBuf, p->data + iOfst, iAmt);
return SQLITE_OK;
}

1. VFS设计原则
├── 继承默认VFS
├── 只重写必要方法
├── 保持错误处理
└── 测试所有场景

2. 性能优化
├── 使用缓存
├── 批量操作
├── 减少系统调用
└── 异步IO

3. 安全考虑
├── 数据加密
├── 访问控制
├── 完整性校验
└── 审计日志

4. 嵌入式集成
├── 自定义内存管理
├── 适配文件系统
├── 裁剪不需要功能
└── 充分测试