如何将sqlite3数据库文件嵌入CLI应用二进制并安全使用？

针对你遇到的把只读SQLite数据库嵌入CLI二进制、避免文件暴露且兼容sqlx的需求，这里有一个可靠的解决方案——利用mattn/go-sqlite3的自定义虚拟文件系统（VFS）能力，直接从嵌入的字节流中读取数据库，无需临时文件或内存数据库（避开多goroutine的已知问题）。

核心思路 #

1. 用Go的embed包（Go 1.16+）把SQLite数据库文件直接嵌入二进制，得到一个[]byte类型的数据库内容。
2. 实现一个自定义的SQLite VFS，让SQLite从这个嵌入的字节流中读取数据（因为是只读数据库，我们只需要实现读相关的VFS方法）。
3. 注册这个VFS后，用sqlx通过指定VFS的DSN连接数据库，全程不需要磁盘文件。

具体实现步骤 #

1. 嵌入数据库文件 #

首先用embed指令把你的SQLite数据库嵌入代码：

package main

import (
    "database/sql"
    "sync"

    "github.com/jmoiron/sqlx"
    "github.com/mattn/go-sqlite3"
)

//go:embed your_database.sqlite
var embeddedDB []byte

2. 实现自定义只读VFS #

我们需要实现sqlite3.VFS和sqlite3.File接口，只处理读操作：

// EmbeddedFile 模拟一个从内存字节流读取的文件
type EmbeddedFile struct {
    data []byte
    pos  int64
    mu   sync.Mutex
}

func (f *EmbeddedFile) Close() error {
    return nil
}

func (f *EmbeddedFile) Read(p []byte) (int, error) {
    f.mu.Lock()
    defer f.mu.Unlock()

    if f.pos >= int64(len(f.data)) {
        return 0, sql.ErrNoRows
    }
    n := copy(p, f.data[f.pos:])
    f.pos += int64(n)
    return n, nil
}

func (f *EmbeddedFile) Write(p []byte) (int, error) {
    // 只读数据库，返回错误
    return 0, sqlite3.ErrReadOnly
}

func (f *EmbeddedFile) Seek(offset int64, whence int) (int64, error) {
    f.mu.Lock()
    defer f.mu.Unlock()

    switch whence {
    case 0:
        f.pos = offset
    case 1:
        f.pos += offset
    case 2:
        f.pos = int64(len(f.data)) + offset
    }
    if f.pos < 0 {
        f.pos = 0
    }
    if f.pos > int64(len(f.data)) {
        f.pos = int64(len(f.data))
    }
    return f.pos, nil
}

func (f *EmbeddedFile) Truncate(size int64) error {
    return sqlite3.ErrReadOnly
}

func (f *EmbeddedFile) Sync() error {
    return nil
}

func (f *EmbeddedFile) FileSize() (int64, error) {
    return int64(len(f.data)), nil
}

// EmbeddedVFS 自定义VFS，用于加载嵌入的数据库
type EmbeddedVFS struct {
    data []byte
}

func (v *EmbeddedVFS) Open(name string, flags int, _ string) (sqlite3.File, error) {
    // 忽略name，直接返回我们的嵌入文件
    return &EmbeddedFile{data: v.data}, nil
}

func (v *EmbeddedVFS) Delete(name string, dirSync bool) error {
    return sqlite3.ErrReadOnly
}

func (v *EmbeddedVFS) Access(name string, flags int) error {
    // 模拟文件存在且可读
    return nil
}

func (v *EmbeddedVFS) FullPathname(name string) string {
    return name
}

func (v *EmbeddedVFS) DlOpen(filename string) (interface{}, error) {
    return nil, sqlite3.ErrNotImplemented
}

func (v *EmbeddedVFS) DlSym(handle interface{}, symbol string) (interface{}, error) {
    return nil, sqlite3.ErrNotImplemented
}

func (v *EmbeddedVFS) DlClose(handle interface{}) error {
    return nil
}

func (v *EmbeddedVFS) RandomBytes(n int) ([]byte, error) {
    return nil, sqlite3.ErrNotImplemented
}

func (v *EmbeddedVFS) Sleep(ms int) {
}

func (v *EmbeddedVFS) CurrentTime() float64 {
    return 0
}

func (v *EmbeddedVFS) GetLastError() error {
    return nil
}

3. 注册VFS并连接数据库 #

在程序初始化时注册自定义VFS，然后用sqlx连接：

func init() {
    // 注册自定义VFS，命名为"embedded_vfs"
    err := sqlite3.RegisterVFS("embedded_vfs", &EmbeddedVFS{data: embeddedDB})
    if err != nil {
        panic(err)
    }
}

func main() {
    // 使用自定义VFS连接数据库，指定只读模式
    dsn := "file:embedded_db?vfs=embedded_vfs&mode=ro&immutable=1"
    db, err := sqlx.Connect("sqlite3", dsn)
    if err != nil {
        panic(err)
    }
    defer db.Close()

    // 测试查询
    var count int
    err = db.Get(&count, "SELECT COUNT(*) FROM your_table")
    if err != nil {
        panic(err)
    }
    println("Total rows:", count)
}

为什么这个方案可行？ #

• 无文件暴露：数据库完全嵌入二进制，运行时只在内存中读取，不会写入任何磁盘文件。
• 兼容sqlx：通过自定义VFS，sqlx可以像连接普通文件一样使用标准DSN连接。
• 避开内存数据库问题：这个方案模拟了真实的文件读取，复用了SQLite原生的文件处理逻辑，不会遇到内存数据库在多goroutine下的表不存在等已知问题。

额外优化 #

• 添加immutable=1到DSN中，告诉SQLite数据库是只读的，会禁用一些不必要的锁和写入逻辑，提升性能。
• 确保自定义VFS的方法是线程安全的（比如示例中的EmbeddedFile用了sync.Mutex），避免多goroutine访问时的竞争问题。

内容的提问来源于stack exchange，提问作者ashishmohite