Expo SQLite

expo-sqlite 使你的应用可以访问一个可以通过 SQLite API 查询的数据库。该数据库在应用重启后仍会保留。

警告 在 Apple TV 上，底层数据库文件位于缓存目录中，而不是应用文档目录中，依据 Apple 平台指南。

安装

🌐 Installation

If you are installing this in an existing React Native app, make sure to install expo in your project.

应用配置中的配置

🌐 Configuration in app config

如果在项目中使用配置插件（连续原生生成 (CNG)），你可以使用内置的 配置插件 来为 expo-sqlite 进行高级配置。该插件允许你配置一些无法在运行时设置、需要生成新应用二进制文件才能生效的属性。如果你的应用不使用 CNG，则需要手动配置该库。

🌐 You can configure expo-sqlite for advanced configurations using its built-in config plugin if you use config plugins in your project (Continuous Native Generation (CNG)). The plugin allows you to configure various properties that cannot be set at runtime and require building a new app binary to take effect. If your app does not use CNG, then you'll need to manually configure the library.

Example app.json with config plugin

{
  "expo": {
    "plugins": [
      [
        "expo-sqlite",
        {
          "enableFTS": true,
          "useSQLCipher": true,
          "android": {
            // Override the shared configuration for Android
            "enableFTS": false,
            "useSQLCipher": false
          },
          "ios": {
            // You can also override the shared configurations for iOS
            "customBuildFlags": ["-DSQLITE_ENABLE_DBSTAT_VTAB=1 -DSQLITE_ENABLE_SNAPSHOT=1"]
          }
        }
      ]
    ]
  }
}

Configurable properties

Web 设置

🌐 Web setup

重要 Web 支持处于测试阶段，可能不稳定。如果遇到任何问题，请在 GitHub 上创建问题。

要在网页上使用 expo-sqlite，你需要配置 Metro 打包器以支持 wasm 文件，并添加 HTTP 头以允许使用 SharedArrayBuffer。

🌐 To use expo-sqlite on web, you need to configure Metro bundler to support wasm files and add HTTP headers to allow SharedArrayBuffer usage.

将以下配置添加到你的 metro.config.js 中。如果你还没有 metro.config.js，可以运行 npx expo customize metro.config.js。了解更多。

🌐 Add the following configuration to your metro.config.js. If you don't have the metro.config.js yet, you can run npx expo customize metro.config.js. Learn more.

如果你将应用部署到网络托管服务，你还需要在你的Web服务器中添加 Cross-Origin-Embedder-Policy 和 Cross-Origin-Opener-Policy 头。 了解有关 COEP、COOP 头以及 SharedArrayBuffer 的更多信息。

🌐 If you deploy your app to web hosting services, you will also need to add the Cross-Origin-Embedder-Policy and Cross-Origin-Opener-Policy headers to your web server. Learn more about the COEP, COOP headers, and SharedArrayBuffer.

用法

🌐 Usage

从 expo-sqlite 导入模块。

🌐 Import the module from expo-sqlite.

import * as SQLite from 'expo-sqlite';

基本 CRUD 操作

🌐 Basic CRUD operations

const db = await SQLite.openDatabaseAsync('databaseName');

// `execAsync()` is useful for bulk queries when you want to execute altogether.
// Note that `execAsync()` does not escape parameters and may lead to SQL injection.
await db.execAsync(`
PRAGMA journal_mode = WAL;
CREATE TABLE IF NOT EXISTS test (id INTEGER PRIMARY KEY NOT NULL, value TEXT NOT NULL, intValue INTEGER);
INSERT INTO test (value, intValue) VALUES ('test1', 123);
INSERT INTO test (value, intValue) VALUES ('test2', 456);
INSERT INTO test (value, intValue) VALUES ('test3', 789);
`);

// `runAsync()` is useful when you want to execute some write operations.
const result = await db.runAsync('INSERT INTO test (value, intValue) VALUES (?, ?)', 'aaa', 100);
console.log(result.lastInsertRowId, result.changes);
await db.runAsync('UPDATE test SET intValue = ? WHERE value = ?', 999, 'aaa'); // Binding unnamed parameters from variadic arguments
await db.runAsync('UPDATE test SET intValue = ? WHERE value = ?', [999, 'aaa']); // Binding unnamed parameters from array
await db.runAsync('DELETE FROM test WHERE value = $value', { $value: 'aaa' }); // Binding named parameters from object

// `getFirstAsync()` is useful when you want to get a single row from the database.
const firstRow = await db.getFirstAsync('SELECT * FROM test');
console.log(firstRow.id, firstRow.value, firstRow.intValue);

// `getAllAsync()` is useful when you want to get all results as an array of objects.
const allRows = await db.getAllAsync('SELECT * FROM test');
for (const row of allRows) {
  console.log(row.id, row.value, row.intValue);
}

// `getEachAsync()` is useful when you want to iterate SQLite query cursor.
for await (const row of db.getEachAsync('SELECT * FROM test')) {
  console.log(row.id, row.value, row.intValue);
}

准备好的报表

🌐 Prepared statements

预处理语句允许你将 SQL 查询编译一次，并使用不同的参数多次执行。它们会自动转义输入参数，以防止 SQL 注入攻击，并且推荐用于包含用户输入的查询。你可以通过在数据库实例上调用 prepareAsync() 或 prepareSync() 方法来获取预处理语句。该预处理语句可以通过调用 executeAsync() 或 executeSync() 方法来完成 CRUD 操作。

🌐 Prepared statements allow you to compile your SQL query once and execute it multiple times with different parameters. They automatically escape input parameters to defend against SQL injection attacks, and are recommended for queries that include user input. You can get a prepared statement by calling prepareAsync() or prepareSync() method on a database instance. The prepared statement can fulfill CRUD operations by calling executeAsync() or executeSync() method.

注意： 使用完准备好的语句后，记得调用 finalizeAsync() 或 finalizeSync() 方法来释放准备好的语句。建议使用 try-finally 块以确保准备好的语句被正确终结。

const statement = await db.prepareAsync(
  'INSERT INTO test (value, intValue) VALUES ($value, $intValue)'
);
try {
  let result = await statement.executeAsync({ $value: 'bbb', $intValue: 101 });
  console.log('bbb and 101:', result.lastInsertRowId, result.changes);

  result = await statement.executeAsync({ $value: 'ccc', $intValue: 102 });
  console.log('ccc and 102:', result.lastInsertRowId, result.changes);

  result = await statement.executeAsync({ $value: 'ddd', $intValue: 103 });
  console.log('ddd and 103:', result.lastInsertRowId, result.changes);
} finally {
  await statement.finalizeAsync();
}

const statement2 = await db.prepareAsync('SELECT * FROM test WHERE intValue >= $intValue');
try {
  const result = await statement2.executeAsync<{ value: string; intValue: number }>({
    $intValue: 100,
  });

  // `getFirstAsync()` is useful when you want to get a single row from the database.
  const firstRow = await result.getFirstAsync();
  console.log(firstRow.id, firstRow.value, firstRow.intValue);

  // Reset the SQLite query cursor to the beginning for the next `getAllAsync()` call.
  await result.resetAsync();

  // `getAllAsync()` is useful when you want to get all results as an array of objects.
  const allRows = await result.getAllAsync();
  for (const row of allRows) {
    console.log(row.value, row.intValue);
  }

  // Reset the SQLite query cursor to the beginning for the next `for-await-of` loop.
  await result.resetAsync();

  // The result object is also an async iterable. You can use it in `for-await-of` loop to iterate SQLite query cursor.
  for await (const row of result) {
    console.log(row.value, row.intValue);
  }
} finally {
  await statement2.finalizeAsync();
}

useSQLiteContext() 钩

🌐 useSQLiteContext() hook

import { SQLiteProvider, useSQLiteContext, type SQLiteDatabase } from 'expo-sqlite';
import { useEffect, useState } from 'react';
import { View, Text, StyleSheet } from 'react-native';

export default function App() {
  return (
    <View style={styles.container}>
      <SQLiteProvider databaseName="test.db" onInit={migrateDbIfNeeded}>
        <Header />
        <Content />
      </SQLiteProvider>
    </View>
  );
}

export function Header() {
  const db = useSQLiteContext();
  const [version, setVersion] = useState('');
  useEffect(() => {
    async function setup() {
      const result = await db.getFirstAsync<{ 'sqlite_version()': string }>(
        'SELECT sqlite_version()'
      );
      setVersion(result['sqlite_version()']);
    }
    setup();
  }, []);
  return (
    <View style={styles.headerContainer}>
      <Text style={styles.headerText}>SQLite version: {version}</Text>
    </View>
  );
}

interface Todo {
  value: string;
  intValue: number;
}

export function Content() {
  const db = useSQLiteContext();
  const [todos, setTodos] = useState<Todo[]>([]);

  useEffect(() => {
    async function setup() {
      const result = await db.getAllAsync<Todo>('SELECT * FROM todos');
      setTodos(result);
    }
    setup();
  }, []);

  return (
    <View style={styles.contentContainer}>
      {todos.map((todo, index) => (
        <View style={styles.todoItemContainer} key={index}>
          <Text>{`${todo.intValue} - ${todo.value}`}</Text>
        </View>
      ))}
    </View>
  );
}

async function migrateDbIfNeeded(db: SQLiteDatabase) {
  const DATABASE_VERSION = 1;
  let { user_version: currentDbVersion } = await db.getFirstAsync<{ user_version: number }>(
    'PRAGMA user_version'
  );
  if (currentDbVersion >= DATABASE_VERSION) {
    return;
  }
  if (currentDbVersion === 0) {
    await db.execAsync(`
PRAGMA journal_mode = 'wal';
CREATE TABLE todos (id INTEGER PRIMARY KEY NOT NULL, value TEXT NOT NULL, intValue INTEGER);
`);
    await db.runAsync('INSERT INTO todos (value, intValue) VALUES (?, ?)', 'hello', 1);
    await db.runAsync('INSERT INTO todos (value, intValue) VALUES (?, ?)', 'world', 2);
    currentDbVersion = 1;
  }
  // if (currentDbVersion === 1) {
  //   Add more migrations
  // }
  await db.execAsync(`PRAGMA user_version = ${DATABASE_VERSION}`);
}

const styles = StyleSheet.create({
  // Your styles...
});

useSQLiteContext() 钩 React.Suspense

🌐 useSQLiteContext() hook with React.Suspense

与 useSQLiteContext() 钩子类似，你也可以将 SQLiteProvider 与 React.Suspense 集成，以在数据库准备好之前显示一个备用组件。要启用此集成，请将 useSuspense 属性传递给 SQLiteProvider 组件。

🌐 As with the useSQLiteContext() hook, you can also integrate the SQLiteProvider with React.Suspense to show a fallback component until the database is ready. To enable the integration, pass the useSuspense prop to the SQLiteProvider component.

import { SQLiteProvider, useSQLiteContext } from 'expo-sqlite';
import { Suspense } from 'react';
import { View, Text, StyleSheet } from 'react-native';

export default function App() {
  return (
    <View style={styles.container}>
      <Suspense fallback={<Fallback />}>
        <SQLiteProvider databaseName="test.db" onInit={migrateDbIfNeeded} useSuspense>
          <Header />
          <Content />
        </SQLiteProvider>
      </Suspense>
    </View>
  );
}

在异步事务中执行查询

🌐 Executing queries within an async transaction

const db = await SQLite.openDatabaseAsync('databaseName');

await db.withTransactionAsync(async () => {
  const result = await db.getFirstAsync('SELECT COUNT(*) FROM USERS');
  console.log('Count:', result.rows[0]['COUNT(*)']);
});

由于 async/await 的特性，事务激活期间运行的任何查询都会被包含在事务中。这包括传递给 withTransactionAsync() 的作用域函数之外的查询语句，这可能会导致意外行为。例如，下面的测试用例在传递给 withTransactionAsync() 的作用域函数的内部和外部运行查询。然而，由于第二个 UPDATE 查询在事务完成之前运行，所有查询都会在实际的 SQL 事务中执行。

🌐 Due to the nature of async/await, any query that runs while the transaction is active will be included in the transaction. This includes query statements that are outside of the scope function passed to withTransactionAsync() and may be surprising behavior. For example, the following test case runs queries inside and outside of a scope function passed to withTransactionAsync(). However, all of the queries will run within the actual SQL transaction because the second UPDATE query runs before the transaction finishes.

Promise.all([
  // 1. A new transaction begins
  db.withTransactionAsync(async () => {
    // 2. The value "first" is inserted into the test table and we wait 2
    //    seconds
    await db.execAsync('INSERT INTO test (data) VALUES ("first")');
    await sleep(2000);

    // 4. Two seconds in, we read the latest data from the table
    const row = await db.getFirstAsync<{ data: string }>('SELECT data FROM test');

    // ❌ The data in the table will be "second" and this expectation will fail.
    //    Additionally, this expectation will throw an error and roll back the
    //    transaction, including the `UPDATE` query below since it ran within
    //    the transaction.
    expect(row.data).toBe('first');
  }),
  // 3. One second in, the data in the test table is updated to be "second".
  //    This `UPDATE` query runs in the transaction even though its code is
  //    outside of it because the transaction happens to be active at the time
  //    this query runs.
  sleep(1000).then(async () => db.execAsync('UPDATE test SET data = "second"')),
]);

[withExclusiveTransactionAsync()](#withexclusivetransactionasynctask) 函数可以解决这个问题。只有在传递给 withExclusiveTransactionAsync() 的作用域函数中运行的查询才会在实际的 SQL 事务中执行。

🌐 The withExclusiveTransactionAsync() function addresses this. Only queries that run within the scope function passed to withExclusiveTransactionAsync() will run within the actual SQL transaction.

执行 PRAGMA 查询

🌐 Executing PRAGMA queries

const db = await SQLite.openDatabaseAsync('databaseName');
await db.execAsync('PRAGMA journal_mode = WAL');
await db.execAsync('PRAGMA foreign_keys = ON');

信息 提示： 创建新数据库时启用 WAL 日志模式 可提高整体性能。

导入现有数据库

🌐 Import an existing database

要使用已有的 .db 文件打开一个新的 SQLite 数据库，你可以使用 SQLiteProvider 配合 assetSource。

🌐 To open a new SQLite database using an existing .db file you already have, you can use the SQLiteProvider with assetSource.

import { SQLiteProvider, useSQLiteContext } from 'expo-sqlite';
import { View, Text, StyleSheet } from 'react-native';

export default function App() {
  return (
    <View style={styles.container}>
      <SQLiteProvider databaseName="test.db" assetSource={{ assetId: require('./assets/test.db') }}>
        <Header />
        <Content />
      </SQLiteProvider>
    </View>
  );
}

与多个应用共享模块

🌐 Sharing a database between apps/extensions (iOS)

要与同一应用组中的其他应用/扩展共享数据库，你可以按照以下步骤使用共享容器：

🌐 To share a database with other apps/extensions in the same App Group, you can use shared containers by following the steps below:

{
  "expo": {
    "ios": {
      "bundleIdentifier": "com.myapp",
      "entitlements": {
        "com.apple.security.application-groups": ["group.com.myapp"]
      }
    }
  }
}

import { SQLiteProvider, defaultDatabaseDirectory } from 'expo-sqlite';
import { Paths } from 'expo-file-system';
import { useMemo } from 'react';
import { Platform, View } from 'react-native';

export default function App() {
  const dbDirectory = useMemo(() => {
    if (Platform.OS === 'ios') {
      return Object.values(Paths.appleSharedContainers)?.[0]?.uri;
      // or `Paths.appleSharedContainers['group.com.myapp']?.uri` to choose specific container
    }
    return defaultDatabaseDirectory;
  }, []);

  return (
    <View style={styles.container}>
      <SQLiteProvider databaseName="test.db" directory={dbDirectory}>
        <Header />
        <Content />
      </SQLiteProvider>
    </View>
  );
}

传输二进制数据

🌐 Passing binary data

使用 Uint8Array 将二进制数据传递给数据库：

🌐 Use Uint8Array to pass binary data to the database:

await db.execAsync(`
DROP TABLE IF EXISTS blobs;
CREATE TABLE IF NOT EXISTS blobs (id INTEGER PRIMARY KEY NOT NULL, data BLOB);
`);

const blob = new Uint8Array([0x00, 0x01, 0x02, 0x03, 0x04, 0x05]);
await db.runAsync('INSERT INTO blobs (data) VALUES (?)', blob);

const row = await db.getFirstAsync<{ data: Uint8Array }>('SELECT * FROM blobs');
expect(row.data).toEqual(blob);

浏览设备上的数据库

🌐 Browse an on-device database

你可以检查数据库、对其执行查询，并使用 drizzle-studio-expo 开发工具插件 探索数据。该插件使你能够直接从 Expo CLI 启动连接到应用中数据库的 Drizzle Studio。该插件可以与任何 expo-sqlite 配置一起使用。它不要求你在应用中使用 Drizzle ORM。了解如何安装和使用该插件。

🌐 You can inspect a database, execute queries against it, and explore data with the drizzle-studio-expo dev tools plugin. This plugin enables you to launch Drizzle Studio, connected to a database in your app, directly from Expo CLI. This plugin can be used with any expo-sqlite configuration. It does not require that you use Drizzle ORM in your app. Learn how to install and use the plugin.

键值存储

🌐 Key-value storage

expo-sqlite 库提供了 Storage 作为 @react-native-async-storage/async-storage 库的可替换方案。这个键值存储由 SQLite 支持。如果你的项目已经使用 expo-sqlite，你可以利用 expo-sqlite/kv-store 而无需添加其他依赖。

🌐 The expo-sqlite library provides Storage as a drop-in replacement for the @react-native-async-storage/async-storage library. This key-value store is backed by SQLite. If your project already uses expo-sqlite, you can leverage expo-sqlite/kv-store without needing to add another dependency.

Storage 提供与 @react-native-async-storage/async-storage 相同的 API：

// The storage API is the default export, you can call it Storage, AsyncStorage, or whatever you prefer.
import Storage from 'expo-sqlite/kv-store';

await Storage.setItem('key', JSON.stringify({ entity: 'value' }));
const value = await Storage.getItem('key');
const entity = JSON.parse(value);
console.log(entity); // { entity: 'value' }

使用 expo-sqlite/kv-store 的一个主要好处是增加了同步 API，以提供更多便利性：

🌐 A key benefit of using expo-sqlite/kv-store is the addition of synchronous APIs for added convenience:

// The storage API is the default export, you can call it Storage, AsyncStorage, or whatever you prefer.
import Storage from 'expo-sqlite/kv-store';

Storage.setItemSync('key', 'value');
const value = Storage.getItemSync('key');

如果你目前在项目中使用 @react-native-async-storage/async-storage，切换到 expo-sqlite/kv-store 只需更改导入语句即可：

🌐 If you're currently using @react-native-async-storage/async-storage in your project, switching to expo-sqlite/kv-store is as simple as changing the import statement:

- import AsyncStorage from '@react-native-async-storage/async-storage';
+ import AsyncStorage from 'expo-sqlite/kv-store';

localStorage API

🌐 The localStorage API

expo-sqlite/localStorage/install 模块提供了 localStorage API 的直接可用实现。如果你已经熟悉这个 API 在网页端的使用，或者你希望能够在网页和其他平台之间共享存储代码，这可能会很有用。要使用它，你只需要导入 expo-sqlite/localStorage/install 模块：

🌐 The expo-sqlite/localStorage/install module provides a drop-in implementation for the localStorage API. If you're already familiar with this API from the web, or you would like to be able to share storage code between web and other platforms, this may be useful. To use it, you just need to import the expo-sqlite/localStorage/install module:

注意： import 'expo-sqlite/localStorage/install'; 在网页上是无操作的，并且会被排除在生产环境的 JS 包之外。

import 'expo-sqlite/localStorage/install';

globalThis.localStorage.setItem('key', 'value');
console.log(globalThis.localStorage.getItem('key')); // 'value'

安全

🌐 Security

SQL 注入是一类漏洞，攻击者会诱使你的应用执行用户输入的 SQL 代码。你必须对传递给 SQLite 的所有用户输入进行转义，以防止 SQL 注入。预处理语句 是应对这一问题的有效防护措施。它们明确地将 SQL 查询的逻辑与输入参数分开，并且在执行预处理语句时，SQLite 会自动对输入进行转义。

🌐 SQL injections are a class of vulnerabilities where attackers trick your app into executing user input as SQL code. You must escape all user input passed to SQLite to defend against SQL injections. Prepared statements are an effective defense against this problem. They explicitly separate a SQL query's logic from its input parameters, and SQLite automatically escapes inputs when executing prepared statements.

第三方库集成

🌐 Third-party library integrations

expo-sqlite 库旨在成为一个可靠的 SQLite 基础。它支持与第三方库进行更广泛的集成，从而实现更高级的高级功能。以下是一些可以与 expo-sqlite 配合使用的库。

🌐 The expo-sqlite library is designed to be a solid SQLite foundation. It enables broader integrations with third-party libraries for more advanced higher-level features. Here are some of the libraries that you can use with expo-sqlite.

Drizzle ORM

Drizzle 是一个 “有头的无头 TypeScript ORM”。它可以运行在 Node.js、Bun、Deno 和 React Native 上。它还有一个名为 drizzle-kit 的 CLI 工具，用于生成 SQL 迁移。

查看 Drizzle ORM 文档 和 expo-sqlite 集成指南 以了解更多详情。

🌐 Check out the Drizzle ORM documentation and the expo-sqlite integration guide for more details.

Knex.js

[Knex.js]（https://knex.nodejs.cn/） 是一款 SQL 查询构建器，具有“灵活、可移植且使用乐趣！”。（https://github.com/knex/knex）

请查看expo-sqlite集成指南以获取更多详细信息。

🌐 Check out the expo-sqlite integration guide for more details.

SQLCipher

注意： SQLCipher 不支持 Expo Go。

SQLCipher 是 SQLite 的一个分支，为数据库增加了加密和认证功能。expo-sqlite 库支持 Android、iOS 和 macOS 的 SQLCipher。要使用 SQLCipher，你需要将 useSQLCipher 配置添加到你的 app.json 中，如 应用配置中的配置 部分所示，并运行 npx expo prebuild。

在你打开数据库后，需要使用 PRAGMA key = 'password' 语句为数据库设置密码。

🌐 Right after you open a database, you need to set a password for the database using the PRAGMA key = 'password' statement.

const db = await SQLite.openDatabaseAsync('databaseName');
await db.execAsync(`PRAGMA key = 'password'`);

应用接口

🌐 API

常用 API 速查表

🌐 Cheatsheet for the common API

下表总结了 SQLiteDatabase 和 SQLiteStatement 类的常用 API：

🌐 The following table summarizes the common API for SQLiteDatabase and SQLiteStatement classes:

Component

assetSource={{ assetId: require('./assets/db.db') }}

export default function App() {
  return (
    <Suspense fallback={<Text>Loading...</Text>}>
      <SQLiteProvider databaseName="test.db" useSuspense={true}>
        <Main />
      </SQLiteProvider>
    </Suspense>
  );
}

Constants

Hooks

export default function App() {
  return (
    <SQLiteProvider databaseName="test.db">
      <Main />
    </SQLiteProvider>
  );
}

export function Main() {
  const db = useSQLiteContext();
  console.log('sqlite version', db.getFirstSync('SELECT sqlite_version()'));
  return <View />
}

Classes

// For unnamed parameters, you pass values in an array.
db.getAllAsync('SELECT * FROM test WHERE intValue = ? AND name = ?', [1, 'Hello']);

// For unnamed parameters, you pass values in variadic arguments.
db.getAllAsync('SELECT * FROM test WHERE intValue = ? AND name = ?', 1, 'Hello');

// For named parameters, you should pass values in object.
db.getAllAsync('SELECT * FROM test WHERE intValue = $intValue AND name = $name', { $intValue: 1, $name: 'Hello' });

// Load `sqlite-vec` from `bundledExtensions`. You need to enable `withSQLiteVecExtension` to include `sqlite-vec`.
const extension = SQLite.bundledExtensions['sqlite-vec'];
await db.loadExtensionAsync(extension.libPath, extension.entryPoint);

// You can also load a custom extension.
await db.loadExtensionAsync('/path/to/extension');

// Load `sqlite-vec` from `bundledExtensions`. You need to enable `withSQLiteVecExtension` to include `sqlite-vec`.
const extension = SQLite.bundledExtensions['sqlite-vec'];
db.loadExtensionSync(extension.libPath, extension.entryPoint);

// You can also load a custom extension.
db.loadExtensionSync('/path/to/extension');

db.withExclusiveTransactionAsync(async (txn) => {
  await txn.execAsync('UPDATE test SET name = "aaa"');
});

db.withTransactionAsync(async () => {
  await db.execAsync('UPDATE test SET name = "aaa"');

  //
  // We cannot control the order of async/await order, so order of execution is not guaranteed.
  // The following UPDATE query out of transaction may be executed here and break the expectation.
  //

  const result = await db.getFirstAsync<{ name: string }>('SELECT name FROM Users');
  expect(result?.name).toBe('aaa');
});
db.execAsync('UPDATE test SET name = "bbb"');