HarmonyOS 数据库使用batchInsert添加不生效

参考示例：

import common from '@ohos.app.ability.common';
import relationalStore from '@ohos.data.relationalStore'; // 导入模块
import { BusinessError } from '@ohos.base';
import promptAction from '@ohos.promptAction';

let store: relationalStore.RdbStore | undefined = undefined;
let predicates = new relationalStore.RdbPredicates("EMPLOYEE");

const table_name: string = 'EMPLOYEE'

// 建表Sql语句
const SQL_CREATE_TABLE =
  `CREATE TABLE IF NOT EXISTS ${table_name} (` +
    'ID INTEGER PRIMARY KEY AUTOINCREMENT, ' +
    'NAME TEXT NOT NULL, AGE INTEGER, ' +
    'SALARY REAL, ' +
    'CODES BLOB' +
    ')';

@Entry
@Component
struct Index {
  @State message: string = 'Hello World';
  @State database_version: number = 0;
  @State database_name: string = '未创建';
  @State database_flag: number = -1;
  @State create_flag: number = -1
  @State table_name1: string = 'EMPLOYEE'
  context = getContext(this) as common.UIAbilityContext;

  build() {
    Column() {
      //1、数据库创建
      Row() {
        Text(`数据库名：${this.database_name}`)
          .textAlign(TextAlign.Start)
          .fontSize(12)//.border({ width: 1 })
          .padding(10)
          .width('50%')
      }
      .width('90%')
      .border({ width: 1 })

      //2、建表
      Row() {
        if (this.create_flag === 1) {
          Text(`表名：${this.table_name1}`)
            .textAlign(TextAlign.Start)
            .fontSize(12)
            .padding(10)
            .width('50%')
        } else {
          Text(`表名：未建表`)
            .textAlign(TextAlign.Start)
            .fontSize(12)
            .padding(10)
            .width('50%')
        }
      }
      .width('90%')
      .border({ width: 1 })

      Button('1、创建数据库')
        .onClick(() => {
          if (this.database_flag === -1) {
            this.getDataStore()
          } else {
            if (this.database_flag === 1) {
              promptAction.showToast({
                message: '数据库已创建'
              });
            }
          }
        })

      Button('2、建表')
        .onClick(() => {
          if (this.database_flag === -1) {
            promptAction.showToast({
              message: '数据库未创建，请先创建数据库'
            });
            return;
          }
          this.createDatabase()
        })

      Button('3、批量插入数据')
        .onClick(() => {
          this.insert_all()
        })

      Button('4、查询数据表')
        .onClick(() => {
          this.queryData()
        })
    }
  }

  //获取store,创建数据库
  getDataStore() {
    //设置数据库基本配置信息
    const STORE_CONFIG: relationalStore.StoreConfig = {
      name: "RdbTest.db", // 数据库文件名
      securityLevel: relationalStore.SecurityLevel.S1// 数据库安全级别
      // encrypt: false, // 可选参数，指定数据库是否加密，默认不加密
      // dataGroupId: 'dataGroupID', // 可选参数，仅可在Stage模型下使用，表示为应用组ID，需要向应用市场获取。指定在此Id对应的沙箱路径下创建实例，当此参数不填时，默认在本应用沙箱目录下创建。
      // customDir: 'customDir/subCustomDir' // 可选参数，数据库自定义路径。数据库将在如下的目录结构中被创建：context.databaseDir + '/rdb/' + customDir，其中context.databaseDir是应用沙箱对应的路径，'/rdb/'表示创建的是关系型数据库，customDir表示自定义的路径。当此参数不填时，默认在本应用沙箱目录下创建RdbStore实例
    };

    relationalStore.getRdbStore(this.context, STORE_CONFIG).then(async (rdbStore: relationalStore.RdbStore) => {
      store = rdbStore; //操作关系型数据库
      console.info('成功获取RdbStore：' + store)
      this.database_name = STORE_CONFIG.name
      this.database_flag = 1
    }).catch((err: BusinessError) => {
      console.error(`获取RdbStore失败, code is ${err.code},message is ${err.message}`);
    })
  }

  //建表
  createDatabase() {
    if (store != undefined) {
      (store as relationalStore.RdbStore).executeSql(SQL_CREATE_TABLE, (err) => {
        if (err) {
          console.error(`数据表创建失败, code is ${err.code},message is ${err.message}`);
          return;
        }
        console.info('数据表创建成功');
        this.create_flag = 1
        // 设置数据库版本
        if (store != undefined) {
          // this.database_version=(store as relationalStore.RdbStore).version+1;
          (store as relationalStore.RdbStore).version = 3;
          // 获取数据库版本
          console.info(`RdbStore version is ${store.version}`);
        }
      })
    }
  }

  insert_all() {
    let value1 = "Lisa";
    let value2 = 18;
    let value3 = 100.5;
    let value4 = new Uint8Array([1, 2, 3, 4, 5]);
    let value5 = "Jack";
    let value6 = 19;
    let value7 = 101.5;
    let value8 = new Uint8Array([6, 7, 8, 9, 10]);
    let value9 = "Tom";
    let value10 = 20;
    let value11 = 102.5;
    let value12 = new Uint8Array([11, 12, 13, 14, 15]);

    const valueBucket1: relationalStore.ValuesBucket = {
      'NAME': value1,
      'AGE': value2,
      'SALARY': value3,
      'CODES': value4,
    };
    const valueBucket2: relationalStore.ValuesBucket = {
      'NAME': value5,
      'AGE': value6,
      'SALARY': value7,
      'CODES': value8,
    };
    const valueBucket3: relationalStore.ValuesBucket = {
      'NAME': value9,
      'AGE': value10,
      'SALARY': value11,
      'CODES': value12,
    };

    let valueBuckets = new Array(valueBucket1, valueBucket2, valueBucket3);
    if (store != undefined) {
      try {
        let insertNum: number = (store as relationalStore.RdbStore).batchInsertSync("EMPLOYEE", valueBuckets);
        console.info(`成功插入 ${insertNum} 条数据`);
        promptAction.showToast({
          message: `成功插入 ${insertNum} 条数据`
        });
      } catch (err) {
        console.error(`batchInsert is failed, code is ${err.code},message is ${err.message}`);
      }
    }
  }

  queryData() {
    predicates = new relationalStore.RdbPredicates("EMPLOYEE");
    predicates.equalTo("NAME", "Lisa")
      .or()
      .equalTo("NAME", "Jack")
      .or()
      .equalTo("NAME", "Tom")
    if (store != undefined) {
      (store as relationalStore.RdbStore).query(predicates, (err, resultSet) => {
        if (err) {
          console.error(`查询失败, code is ${err.code},message is ${err.message}`);
          return;
        }
        console.log(`结果集：ResultSet column names: ${resultSet.columnNames}, column count: ${resultSet.columnCount}`);
        if (resultSet.rowCount === 0) {
          console.log(`结果集行数：${resultSet.rowCount}，没有查询到数据`)
          return;
        } else {
          console.log(`查询到：${resultSet.rowCount}行数据`)
        }

        let str: string = ''
        // resultSet是一个数据集合的游标，默认指向第-1个记录，有效的数据从0开始。
        while (resultSet.goToNextRow()) {
          const id = resultSet.getLong(resultSet.getColumnIndex("ID"));
          const name = resultSet.getString(resultSet.getColumnIndex("NAME"));
          const age = resultSet.getLong(resultSet.getColumnIndex("AGE"));
          const salary = resultSet.getDouble(resultSet.getColumnIndex("SALARY"));
          console.log(`查询结果：id=${id}, name=${name}, age=${age}, salary=${salary}`);
          str += `查询结果：id=${id}, name=${name}, age=${age}, salary=${salary}\n`
        }
        promptAction.showToast({
          message: str
        });
        // 释放数据集的内存
        resultSet.close();
      })
    }
  }
}