📖 鸿蒙NEXT开发实战系列 | 第24篇 | 进阶篇 🎯 适合人群：有鸿蒙数据库基础的开发者 ⏰ 阅读时间：约15分钟 | 💻 开发环境：DevEco Studio 5.0+

系列导航： 上一篇：第23篇 - RelationalStore数据库基础CRUD操作 | 返回系列目录 | 下一篇：第25篇 - 分布式数据管理

📑 目录

一、为什么需要进阶优化

在开发鸿蒙应用时，当数据量达到万级以上，普通的CRUD操作会面临严重的性能瓶颈：

问题场景

具体表现

查询缓慢

无索引的查询可能需要全表扫描，耗时数百毫秒

批量插入卡顿

逐条插入万级数据可能需要数十秒

分页加载超时

大offset值导致查询性能急剧下降

数据一致性问题

并发操作时可能出现数据不一致

本文将通过实战代码，帮你解决以上问题。

二、索引优化：让查询速度飞起来

2.1 什么是索引

索引类似于书籍的目录，通过建立索引可以快速定位数据，避免全表扫描。在RelationalStore中，索引存储在独立的数据结构中，指向原始数据的物理位置。

索引的优点：

  • 大幅提升查询速度

  • 加速排序和分组操作

  • 优化WHERE条件过滤

索引的代价：

  • 占用额外存储空间

  • 降低插入、更新、删除的速度（需要维护索引）

  • 不当的索引设计可能反而降低性能

2.2 单列索引的创建与使用

单列索引是最基本的索引类型，适用于经常作为查询条件的单个字段。

import { relationalStore } from '@kit.ArkData';

// 1. 创建数据库和表
function createTableWithIndex(context: Context): void {
  const STORE_CONFIG: relationalStore.StoreConfig = {
    name: 'performance_test.db',
    securityLevel: relationalStore.SecurityLevel.S1
  };

  relationalStore.getRdbStore(context, STORE_CONFIG, (err, store) => {
    if (err) {
      console.error(`创建数据库失败: ${err.message}`);
      return;
    }

    // 创建用户表
    const createTableSql = `
      CREATE TABLE IF NOT EXISTS users (
        id INTEGER PRIMARY KEY AUTOINCREMENT,
        name TEXT NOT NULL,
        email TEXT NOT NULL,
        age INTEGER,
        city TEXT,
        created_at TEXT
      )
    `;
    store.executeSql(createTableSql);

    // 2. 创建单列索引 - 对email字段创建唯一索引
    const createIndexSql = `
      CREATE UNIQUE INDEX IF NOT EXISTS idx_users_email 
      ON users(email)
    `;
    store.executeSql(createIndexSql);
    console.info('创建email唯一索引成功');

    // 3. 创建普通索引 - 对city字段创建索引
    const createCityIndexSql = `
      CREATE INDEX IF NOT EXISTS idx_users_city 
      ON users(city)
    `;
    store.executeSql(createCityIndexSql);
    console.info('创建city索引成功');

    // 4. 创建带排序的索引 - 对age字段创建升序索引
    const createAgeIndexSql = `
      CREATE INDEX IF NOT EXISTS idx_users_age_asc 
      ON users(age ASC)
    `;
    store.executeSql(createAgeIndexSql);
    console.info('创建age索引成功');
  });
}

使用索引查询的代码示例：

// 使用索引字段查询 - 会利用idx_users_email索引
function queryByEmail(store: relationalStore.RdbStore, email: string): void {
  const predicates = new relationalStore.RdbPredicates('users');
  predicates.equalTo('email', email);  // email有索引，查询速度快

  store.query(predicates, ['id', 'name', 'email', 'age'], (err, resultSet) => {
    if (err) {
      console.error(`查询失败: ${err.message}`);
      return;
    }

    while (resultSet.goToNextRow()) {
      const id = resultSet.getLong(resultSet.getColumnIndex('id'));
      const name = resultSet.getString(resultSet.getColumnIndex('name'));
      console.info(`查询结果: id=${id}, name=${name}`);
    }
    resultSet.close();
  });
}

2.3 复合索引的创建与使用

复合索引（组合索引）适用于经常需要多个字段组合查询的场景。

// 创建复合索引 - city和age组合索引
function createCompositeIndex(store: relationalStore.RdbStore): void {
  // 复合索引：先按city过滤，再按age排序
  const createCompositeIndexSql = `
    CREATE INDEX IF NOT EXISTS idx_users_city_age 
    ON users(city, age)
  `;
  store.executeSql(createCompositeIndexSql);
  console.info('创建city+age复合索引成功');
}

// 复合索引使用示例
function queryByCityAndAge(
  store: relationalStore.RdbStore,
  city: string,
  minAge: number,
  maxAge: number
): void {
  const predicates = new relationalStore.RdbPredicates('users');
  
  // 能利用复合索引的查询
  predicates.equalTo('city', city);           // 第一列
  predicates.greaterThanOrEqualTo('age', minAge);  // 第二列
  predicates.lessThanOrEqualTo('age', maxAge);     // 第二列

  store.query(predicates, ['id', 'name', 'age', 'city'], (err, resultSet) => {
    if (err) {
      console.error(`查询失败: ${err.message}`);
      return;
    }

    const results: object[] = [];
    while (resultSet.goToNextRow()) {
      results.push({
        id: resultSet.getLong(resultSet.getColumnIndex('id')),
        name: resultSet.getString(resultSet.getColumnIndex('name')),
        age: resultSet.getLong(resultSet.getColumnIndex('age')),
        city: resultSet.getString(resultSet.getColumnIndex('city'))
      });
    }
    resultSet.close();
    console.info(`查询到 ${results.length} 条记录`);
  });
}

复合索引使用原则（最左前缀原则）：

查询条件

能否使用索引

WHERE city = '北京'

✅ 能使用

WHERE city = '北京' AND age > 20

✅ 能使用

WHERE age > 20

❌ 不能使用

WHERE city = '北京' AND age = 25

✅ 能使用

2.4 索引的删除与重建

在某些场景下，需要删除索引（如批量导入数据前）或重建索引。

// 删除索引
function dropIndex(store: relationalStore.RdbStore): void {
  const dropIndexSql = `DROP INDEX IF EXISTS idx_users_city_age`;
  store.executeSql(dropIndexSql);
  console.info('删除复合索引成功');
}

// 重建索引（当数据发生大量变更后）
function rebuildIndex(store: relationalStore.RdbStore): void {
  // 先删除
  store.executeSql('DROP INDEX IF EXISTS idx_users_city');
  // 再重建
  store.executeSql('CREATE INDEX idx_users_city ON users(city)');
  console.info('重建city索引成功');
}

// 查看表的所有索引
function listIndexes(store: relationalStore.RdbStore): void {
  const sql = `PRAGMA index_list('users')`;
  store.querySql(sql, (err, resultSet) => {
    if (err) {
      console.error(`查询索引列表失败: ${err.message}`);
      return;
    }

    console.info('=== 索引列表 ===');
    while (resultSet.goToNextRow()) {
      const indexName = resultSet.getString(resultSet.getColumnIndex('name'));
      console.info(`索引: ${indexName}`);
    }
    resultSet.close();
  });
}

三、事务处理：保证数据一致性

3.1 事务的基本概念

事务是一组原子性的操作，要么全部成功，要么全部失败。在RelationalStore中，事务可以保证：

  • 原子性：所有操作要么全部完成，要么全部不执行

  • 一致性：数据库从一个一致状态转换到另一个一致状态

  • 隔离性：并发事务互不干扰

事务的核心API：

  • beginTransaction() - 开始事务

  • commit() - 提交事务

  • rollBack() - 回滚事务

3.2 批量插入的事务封装

// 批量插入数据的事务封装
async function batchInsertWithTransaction(
  store: relationalStore.RdbStore,
  users: object[]
): Promise<boolean> {
  try {
    // 1. 开始事务
    store.beginTransaction();

    const insertSql = `
      INSERT INTO users (name, email, age, city, created_at) 
      VALUES (?, ?, ?, ?, ?)
    `;

    // 2. 批量执行插入
    for (const user of users) {
      const valuesBucket: relationalStore.ValuesBucket = {
        name: user['name'],
        email: user['email'],
        age: user['age'],
        city: user['city'],
        created_at: new Date().toISOString()
      };
      await store.insert('users', valuesBucket);
    }

    // 3. 提交事务
    store.commit();
    console.info(`事务提交成功，插入 ${users.length} 条数据`);
    return true;

  } catch (error) {
    // 4. 出错回滚
    store.rollBack();
    console.error(`事务回滚: ${error}`);
    return false;
  }
}

// 调用示例
async function demo(): Promise<void> {
  const usersToInsert = [
    { name: '张三', email: 'zhangsan@example.com', age: 25, city: '北京' },
    { name: '李四', email: 'lisi@example.com', age: 30, city: '上海' },
    { name: '王五', email: 'wangwu@example.com', age: 28, city: '广州' }
  ];

  const store = await getRdbStore();  // 获取数据库实例
  const success = await batchInsertWithTransaction(store, usersToInsert);
  console.info(`批量插入结果: ${success ? '成功' : '失败'}`);
}

3.3 批量更新的事务封装

// 批量更新的事务封装
interface UpdateRecord {
  id: number;
  field: string;
  value: string | number;
}

async function batchUpdateWithTransaction(
  store: relationalStore.RdbStore,
  updates: UpdateRecord[]
): Promise<boolean> {
  try {
    store.beginTransaction();

    for (const update of updates) {
      const predicates = new relationalStore.RdbPredicates('users');
      predicates.equalTo('id', update.id);

      const valuesBucket: relationalStore.ValuesBucket = {};
      valuesBucket[update.field] = update.value;

      await store.update(valuesBucket, predicates);
    }

    store.commit();
    console.info(`批量更新成功，更新 ${updates.length} 条记录`);
    return true;

  } catch (error) {
    store.rollBack();
    console.error(`批量更新失败，已回滚: ${error}`);
    return false;
  }
}

// 通用事务执行器
async function executeInTransaction(
  store: relationalStore.RdbStore,
  operations: (() => Promise<void>)[]
): Promise<boolean> {
  try {
    store.beginTransaction();

    for (const operation of operations) {
      await operation();
    }

    store.commit();
    return true;

  } catch (error) {
    store.rollBack();
    console.error(`事务执行失败: ${error}`);
    return false;
  }
}

四、分页查询：优雅处理大数据量

4.1 分页查询原理

分页查询使用 LIMIT 和 OFFSET 子句实现：

  • LIMIT：限制返回的记录数

  • OFFSET：跳过指定数量的记录

分页公式： OFFSET = (page - 1) * pageSize

注意事项：

  • 大的OFFSET值会导致性能下降

  • 建议使用游标分页（基于ID或时间戳）替代OFFSET分页

4.2 分页查询实现

// 基础分页查询实现
function queryByPage(
  store: relationalStore.RdbStore,
  page: number,
  pageSize: number
): Promise<object[]> {
  return new Promise((resolve, reject) => {
    const offset = (page - 1) * pageSize;
    const sql = `
      SELECT id, name, email, age, city 
      FROM users 
      ORDER BY id ASC 
      LIMIT ? OFFSET ?
    `;

    store.querySql(sql, [pageSize, offset], (err, resultSet) => {
      if (err) {
        reject(err);
        return;
      }

      const results: object[] = [];
      while (resultSet.goToNextRow()) {
        results.push({
          id: resultSet.getLong(resultSet.getColumnIndex('id')),
          name: resultSet.getString(resultSet.getColumnIndex('name')),
          email: resultSet.getString(resultSet.getColumnIndex('email')),
          age: resultSet.getLong(resultSet.getColumnIndex('age')),
          city: resultSet.getString(resultSet.getColumnIndex('city'))
        });
      }
      resultSet.close();
      resolve(results);
    });
  });
}

// 游标分页查询（推荐，性能更好）
function queryByCursor(
  store: relationalStore.RdbStore,
  lastId: number,
  pageSize: number
): Promise<object[]> {
  return new Promise((resolve, reject) => {
    const sql = `
      SELECT id, name, email, age, city 
      FROM users 
      WHERE id > ?
      ORDER BY id ASC 
      LIMIT ?
    `;

    store.querySql(sql, [lastId, pageSize], (err, resultSet) => {
      if (err) {
        reject(err);
        return;
      }

      const results: object[] = [];
      while (resultSet.goToNextRow()) {
        results.push({
          id: resultSet.getLong(resultSet.getColumnIndex('id')),
          name: resultSet.getString(resultSet.getColumnIndex('name')),
          email: resultSet.getString(resultSet.getColumnIndex('email')),
          age: resultSet.getLong(resultSet.getColumnIndex('age')),
          city: resultSet.getString(resultSet.getColumnIndex('city'))
        });
      }
      resultSet.close();
      resolve(results);
    });
  });
}

// 带条件的分页查询
function queryByPageWithCondition(
  store: relationalStore.RdbStore,
  city: string,
  minAge: number,
  page: number,
  pageSize: number
): Promise<object[]> {
  return new Promise((resolve, reject) => {
    const offset = (page - 1) * pageSize;
    
    // 使用Predicates构建查询条件
    const predicates = new relationalStore.RdbPredicates('users');
    predicates.equalTo('city', city);
    predicates.greaterThanOrEqualTo('age', minAge);
    predicates.orderByAsc('id');
    predicates.limitAs(pageSize);
    predicates.offsetAs(offset);

    store.query(predicates, ['id', 'name', 'email', 'age', 'city'], (err, resultSet) => {
      if (err) {
        reject(err);
        return;
      }

      const results: object[] = [];
      while (resultSet.goToNextRow()) {
        results.push({
          id: resultSet.getLong(resultSet.getColumnIndex('id')),
          name: resultSet.getString(resultSet.getColumnIndex('name')),
          email: resultSet.getString(resultSet.getColumnIndex('email')),
          age: resultSet.getLong(resultSet.getColumnIndex('age')),
          city: resultSet.getString(resultSet.getColumnIndex('city'))
        });
      }
      resultSet.close();
      resolve(results);
    });
  });
}

// 获取总记录数
async function getTotalCount(
  store: relationalStore.RdbStore,
  city?: string
): Promise<number> {
  return new Promise((resolve, reject) => {
    let sql = 'SELECT COUNT(*) as total FROM users';
    const params: (string | number)[] = [];

    if (city) {
      sql += ' WHERE city = ?';
      params.push(city);
    }

    store.querySql(sql, params, (err, resultSet) => {
      if (err) {
        reject(err);
        return;
      }

      if (resultSet.goToNextRow()) {
        const total = resultSet.getLong(resultSet.getColumnIndex('total'));
        resultSet.close();
        resolve(total);
      } else {
        resultSet.close();
        resolve(0);
      }
    });
  });
}

五、性能测试对比

5.1 测试环境说明

项目

配置

设备

HarmonyOS NEXT 设备

数据库

RelationalStore

数据量

10,000条记录

测试字段

city (字符串), age (整数)

5.2 查询性能对比数据

以下是10,000条数据的查询性能对比：

查询场景

无索引耗时

有单列索引耗时

有复合索引耗时

性能提升

按city查询

150ms

15ms

15ms

10x

按age范围查询

120ms

20ms

20ms

6x

按city+age查询

180ms

25ms

12ms

15x

按email精确查询

160ms

5ms

5ms

32x

分页查询(第1页)

50ms

45ms

45ms

1.1x

分页查询(第100页)

800ms

200ms

150ms

5x

性能测试代码：

// 性能测试工具函数
async function performanceTest(
  store: relationalStore.RdbStore,
  testName: string,
  queryFn: () => Promise<void>,
  iterations: number = 100
): Promise<number> {
  const startTime = Date.now();
  
  for (let i = 0; i < iterations; i++) {
    await queryFn();
  }
  
  const endTime = Date.now();
  const avgTime = (endTime - startTime) / iterations;
  
  console.info(`[${testName}] 平均耗时: ${avgTime.toFixed(2)}ms (${iterations}次平均)`);
  return avgTime;
}

// 测试无索引查询
async function testWithoutIndex(store: relationalStore.RdbStore): Promise<void> {
  // 先删除索引
  store.executeSql('DROP INDEX IF EXISTS idx_users_city');

  await performanceTest(store, '无索引-按city查询', async () => {
    const predicates = new relationalStore.RdbPredicates('users');
    predicates.equalTo('city', '北京');
    await store.query(predicates, ['id', 'name']);
  });
}

// 测试有索引查询
async function testWithIndex(store: relationalStore.RdbStore): Promise<void> {
  // 创建索引
  store.executeSql('CREATE INDEX IF NOT EXISTS idx_users_city ON users(city)');

  await performanceTest(store, '有索引-按city查询', async () => {
    const predicates = new relationalStore.RdbPredicates('users');
    predicates.equalTo('city', '北京');
    await store.query(predicates, ['id', 'name']);
  });
}

5.3 批量操作性能对比

操作场景

无事务耗时

有事务耗时

性能提升

插入1000条数据

8000ms

500ms

16x

更新1000条数据

6000ms

400ms

15x

删除1000条数据

5000ms

300ms

17x

六、最佳实践与常见错误

6.1 最佳实践

1. 索引设计原则

// ✅ 推荐：为常用查询字段创建索引
store.executeSql('CREATE INDEX idx_users_email ON users(email)');

// ✅ 推荐：复合索引字段顺序与查询条件一致
store.executeSql('CREATE INDEX idx_city_age ON users(city, age)');

// ❌ 避免：为低选择性字段创建索引（如性别字段）
// CREATE INDEX idx_gender ON users(gender)  -- 效果不佳

2. 事务使用原则

// ✅ 推荐：批量操作使用事务
async function goodBatchInsert(): Promise<void> {
  store.beginTransaction();
  try {
    // 批量操作...
    store.commit();
  } catch (e) {
    store.rollBack();
  }
}

// ❌ 避免：单条操作也使用事务
// 事务有开销，单条操作不需要事务

3. 分页查询优化

// ✅ 推荐：游标分页
function cursorPagination(lastId: number, pageSize: number): void {
  const sql = 'SELECT * FROM users WHERE id > ? ORDER BY id LIMIT ?';
  store.querySql(sql, [lastId, pageSize]);
}

// ❌ 避免：大offset分页
function badPagination(page: number, pageSize: number): void {
  const offset = (page - 1) * pageSize;  // page很大时offset也很大
  const sql = `SELECT * FROM users LIMIT ? OFFSET ?`;
  store.querySql(sql, [pageSize, offset]);  // 性能差
}

4. 数据库连接管理

// ✅ 推荐：使用单例模式管理数据库连接
class DatabaseHelper {
  private static instance: DatabaseHelper;
  private store: relationalStore.RdbStore | null = null;

  static getInstance(): DatabaseHelper {
    if (!DatabaseHelper.instance) {
      DatabaseHelper.instance = new DatabaseHelper();
    }
    return DatabaseHelper.instance;
  }

  async getStore(context: Context): Promise<relationalStore.RdbStore> {
    if (!this.store) {
      const config: relationalStore.StoreConfig = {
        name: 'app.db',
        securityLevel: relationalStore.SecurityLevel.S1
      };
      this.store = await relationalStore.getRdbStore(context, config);
    }
    return this.store;
  }
}

6.2 常见错误与解决方案

错误1：索引失效

// ❌ 错误：索引字段使用函数会导致索引失效
const sql = `SELECT * FROM users WHERE UPPER(city) = 'BEIJING'`;

// ✅ 正确：保持索引字段的原始形式
const predicates = new relationalStore.RdbPredicates('users');
predicates.equalTo('city', 'beijing');  // 数据存储时统一大小写

错误2：事务未正确关闭

// ❌ 错误：事务可能未正确关闭
function badTransaction(): void {
  store.beginTransaction();
  // 某些操作可能抛出异常
  store.executeSql('INSERT INTO users ...');
  store.commit();  // 如果上面抛异常，这里不会执行
}

// ✅ 正确：使用try-finally确保事务关闭
function goodTransaction(): void {
  store.beginTransaction();
  try {
    store.executeSql('INSERT INTO users ...');
    store.commit();
  } catch (e) {
    store.rollBack();
    throw e;
  }
}

错误3：ResultSet未关闭

// ❌ 错误：ResultSet未关闭导致内存泄漏
function badQuery(): void {
  store.query(predicates, columns, (err, resultSet) => {
    while (resultSet.goToNextRow()) {
      // 处理数据
    }
    // 忘记关闭resultSet
  });
}

// ✅ 正确：确保ResultSet关闭
function goodQuery(): void {
  store.query(predicates, columns, (err, resultSet) => {
    try {
      while (resultSet.goToNextRow()) {
        // 处理数据
      }
    } finally {
      resultSet.close();  // 确保关闭
    }
  });
}

七、总结

通过本文的学习，你已经掌握了RelationalStore的进阶用法：

技术点

核心要点

索引优化

合理创建单列索引和复合索引，遵循最左前缀原则

事务处理

批量操作使用事务保证数据一致性，提升性能

分页查询

优先使用游标分页，避免大offset查询

性能优化

万级数据量下，索引可提升6-32倍查询性能

关键建议：

  1. 根据实际查询场景设计索引，避免过度索引

  2. 批量操作必须使用事务，可提升15倍以上性能

  3. 大数据量分页使用游标分页，避免offset分页

  4. 始终关闭ResultSet，避免内存泄漏

📚 系列文章推荐

🏷️ 标签

RelationalStore 数据库优化 鸿蒙数据库 索引 事务 分页查询 性能优化 ArkTS HarmonyOS NEXT

📝 作者提示：如果本文对你有帮助，欢迎点赞收藏！如有疑问，欢迎在评论区交流讨论。

# wpf # 数据库 # 性能优化 # harmonyos
Logo
人工智能6S服务平台

作为“人工智能6S店”的官方数字引擎，为AI开发者与企业提供一个覆盖软硬件全栈、一站式门户。

更多推荐

cover

HarmonyOS APP＜＜古今职鉴定＞＞开源教程第3篇：ArkTS 语言基础：TypeScript 的鸿蒙进化

avatar 人工智能6S服务平台

一天一个昇腾Agent-Skills小技巧：MindSpeed适配Mamba3模型，解锁SSM模型新潜能

作为基于昇腾生态的专业大模型训练框架，MindSpeed LLM已内置支持百余个业界常用稠密、MOE及SSM类模型，具备分布式预训练、微调、推理等全流程能力。此次Mamba3适配的完成，将进一步丰富框架的模型生态，为开发者提供更高效、更灵活的技术工具，助力SSM类模型在更多行业场景中快速落地，推动大模型技术从实验室走向实际应用，解锁更多技术创新与业务价值。社区共建：欢迎开发者贡献新模型支持与优化建

avatar 人工智能6S服务平台
cover

【鸿蒙PC三方库移植适配框架解读系列】第二篇：Lycium 项目结构与适配目录创建

avatar 人工智能6S服务平台