鸿蒙的数据库知识点学习

鸿蒙的数据库知识点学习

作为鸿蒙开发者，最近就深入学习了鸿蒙的数据库知识点，了解了存储机制并且尝试了使用，发现鸿蒙的数据库真的做到了应有尽有，操作还简单的地步。

鸿蒙关系型数据库

先来看看鸿蒙的关系型数据库（Relational Database，RDB）概念。

概念中一句话很重要，HarmonyOS 提供的关系型数据库功能更加完善，查询效率更高。

下面看看鸿蒙数据库的运作机制，了解机制才能了解数据库开发的核心，也有利于扩展。

运作机制

HarmonyOS 关系型数据库对外提供通用的操作接口，底层使用 SQLite 作为持久化存储引擎，支持 SQLite 具有的所有数据库特性，包括但不限于事务、索引、视图、触发器、外键、参数化查询和预编译 SQL 语句。

看到上面的鸿蒙数据库的运行机制不难发现，主要工作还是在 framework 层做的封装，然后调用 JNI，使用的还是 SQLite 组件。

不管底层怎么做的开发，只要功能完善，体验到位，鸿蒙应用端直接使用不是很香吗？

约束与限制

①数据库中连接池的最大数量是 4 个，用以管理用户的读写操作。

连接池的数量是有限制的 ，最大时 4 个，不过 4 个已经足够使用了。

②为保证数据的准确性，数据库同一时间只能支持一个写操作。

同一时间支持一个写操作时非常重要的，为了防止数据存储的正确性，鸿蒙做了这一个限制，但是作为多年的移动端开发者，一般这种多操作或者大数据操作，都会使用多线程，异步线程，或者放在线程池中，这样就更完美了。

数据库操作 DataAbility

鸿蒙在创建类的时候有一个 DataAbility，不知道各位开发者使用过了没，其实这个就是为了数据库操作而来的。

添加步骤很简单：添加类的时候选择 Empty DataAbility 即可。

①配置

添加类后，会自动生成如下配置：

{

“permissions”： ［

“com.huawei.codelab.DataAbilityShellProvider.PROVIDER”

］，

“name”： “com.hadiidbouk.databasemanager.database.DataAbility”，

“icon”： “$media:icon”，

“type”： “data”，

}

操作数据库需要权限信息：

“permissions”： ［

“com.huawei.codelab.DataAbilityShellProvider.PROVIDER”

］

需要配置 url，url 很重要，在进行数据库表操作的时候需要保持一致。

②DataAbility 操作内容

默认创建的 DataAbility 类会自动重写 数据库的增，删，改，查 几种操作的函数。

可以看下面：

添加 DataAbility 会自动重写四个接口函数，有关数据库的增，删，改，查。

该 DataAbility 在运行项目后会自行执行 onStart 方法进行数据库及其数据表的创建工作。

通过 RdbPredicates 数据库进行数据库关系的关联进行操作。

private static final HiLogLabel LABEL_LOG = new HiLogLabel（3， 0xD001100， “Demo”）;

private static final String DB_NAME = “persondataability.db”;

private static final String DB_TAB_NAME = “person”;

private static final String DB_COLUMN_PERSON_ID = “id”;

private static final String DB_COLUMN_NAME = “name”;

private static final String DB_COLUMN_GENDER = “gender”;

private static final String DB_COLUMN_AGE = “age”;

private static final int DB_VERSION = 1;

private StoreConfig config = StoreConfig.newDefaultConfig（DB_NAME）;

private RdbStore rdbStore;

private RdbOpenCallback rdbOpenCallback = new RdbOpenCallback（） {

@Override

public void onCreate（RdbStore store） {

store.executeSql（“create table if not exists ”

+ DB_TAB_NAME + “ （”

+ DB_COLUMN_PERSON_ID + “ integer primary key， ”

+ DB_COLUMN_NAME + “ text not null， ”

+ DB_COLUMN_GENDER + “ text not null， ”

+ DB_COLUMN_AGE + “ integer）”）;

}

@Override

public void onUpgrade（RdbStore store， int oldVersion， int newVersion） {

}

};

@Override

public void onStart（Intent intent） { //创建数据库操作

super.onStart（intent）;

HiLog.info（LABEL_LOG， “DataAbility onStart”）;

DatabaseHelper databaseHelper = new DatabaseHelper（this）;

rdbStore = databaseHelper.getRdbStore（config， DB_VERSION， rdbOpenCallback， null）;

}

// 数据库 查询操作

@Override

public ResultSet query（Uri uri， String［］ columns， DataAbilityPredicates predicates） {

RdbPredicates rdbPredicates = DataAbilityUtils.createRdbPredicates（predicates， DB_TAB_NAME）;

ResultSet resultSet = rdbStore.query（rdbPredicates， columns）;

if （resultSet == null） {

HiLog.info（LABEL_LOG， “resultSet is null”）;

}

return resultSet;

}

// 数据库 插入操作

@Override

public int insert（Uri uri， ValuesBucket value） {

HiLog.info（LABEL_LOG， “DataAbility insert”）;

String path = uri.getLastPath（）;

if （！“person”.equals（path）） {

HiLog.info（LABEL_LOG， “DataAbility insert path is not matched”）;

return -1;

}

ValuesBucket values = new ValuesBucket（）;

values.putInteger（DB_COLUMN_PERSON_ID， value.getInteger（DB_COLUMN_PERSON_ID））;

values.putString（DB_COLUMN_NAME， value.getString（DB_COLUMN_NAME））;

values.putString（DB_COLUMN_GENDER， value.getString（DB_COLUMN_GENDER））;

values.putInteger（DB_COLUMN_AGE， value.getInteger（DB_COLUMN_AGE））;

int index = （int） rdbStore.insert（DB_TAB_NAME， values）;

DataAbilityHelper.creator（this， uri）.notifyChange（uri）;

return index;

}

// 数据库 删除操作

@Override

public int delete（Uri uri， DataAbilityPredicates predicates） {

RdbPredicates rdbPredicates = DataAbilityUtils.createRdbPredicates（predicates， DB_TAB_NAME）;

int index = rdbStore.delete（rdbPredicates）;

HiLog.info（LABEL_LOG， “delete： ” + index）;

DataAbilityHelper.creator（this， uri）.notifyChange（uri）;

return index;

}

// 数据库 更新操作

@Override

public int update（Uri uri， ValuesBucket value， DataAbilityPredicates predicates） {

RdbPredicates rdbPredicates = DataAbilityUtils.createRdbPredicates（predicates， DB_TAB_NAME）;

int index = rdbStore.update（value， rdbPredicates）;

HiLog.info（LABEL_LOG， “update： ” + index）;

DataAbilityHelper.creator（this， uri）.notifyChange（uri）;

return index;

}

@Override

public FileDescriptor openFile（Uri uri， String mode） {

return null;

}

@Override

public String［］ getFileTypes（Uri uri， String mimeTypeFilter） {

return new String［0］;

}

@Override

public PacMap call（String method， String arg， PacMap extras） {

return null;

}

@Override

public String getType（Uri uri） {

return null;

}

}

③数据库操作

这里的数据库操作时，开发需求做的数据库操作，可以通过自己的需求来开发数据库的调用操作，最终还是通过使用 DataAbility 直接调用系统的数据库。

public class DataBaseAbilitySlice extends AbilitySlice {

private static final HiLogLabel LABEL_LOG = new HiLogLabel（3， 0xD001100， “Demo”）;

private DataAbilityHelper databaseHelper;

private static final String BASE_URI = “dataability:///com.huawei.codelab.PersonDataAbility”;

private static final String DATA_PATH = “/person”;

private static final String DB_COLUMN_PERSON_ID = “id”;

private static final String DB_COLUMN_NAME = “name”;

private static final String DB_COLUMN_GENDER = “gender”;

private static final String DB_COLUMN_AGE = “age”;

@Override

public void onStart（Intent intent） {

super.onStart（intent）;

super.setUIContent（ResourceTable.Layout_ability_data_base）;

databaseHelper = DataAbilityHelper.creator（this）;

text.setClickedListener（new Component.ClickedListener（） {

@Override

public void onClick（Component component） {

query（）;

insert（100， “Tom”， “male”， 20）;

insert（101， “Jerry”， “female”， 21）;

insert（102， “Bob”， “male”， 22）;

query（）; // 查看插入后的结果

update（）;

query（）; // 查看更新后的结果

delete（）;

query（）; // 查看删除后的结果

}

}）;

}

@Override

public void onActive（） {

super.onActive（）;

}

@Override

public void onForeground（Intent intent） {

super.onForeground（intent）;

}

private void insert（int id， String name， String gender， int age） {

ValuesBucket valuesBucket = new ValuesBucket（）;

valuesBucket.putInteger（DB_COLUMN_PERSON_ID， id）;

valuesBucket.putString（DB_COLUMN_NAME， name）;

valuesBucket.putString（DB_COLUMN_GENDER， gender）;

valuesBucket.putInteger（DB_COLUMN_AGE， age）;

try {

if （databaseHelper.insert（Uri.parse（BASE_URI + DATA_PATH）， valuesBucket） ！= -1） {

// if （databaseHelper.insert（Uri.parse（BASE_URI + DATA_PATH）， valuesBucket） ！= -1） {

HiLog.info（LABEL_LOG， “insert successful”）;

}

} catch （DataAbilityRemoteException | IllegalStateException exception） {

HiLog.error（LABEL_LOG， “insert： dataRemote exception|illegalStateException”）;

}

}

private void delete（） {

DataAbilityPredicates predicates = new DataAbilityPredicates（）

.equalTo（DB_COLUMN_PERSON_ID， 100）;

try {

if （databaseHelper.delete（Uri.parse（BASE_URI + DATA_PATH）， predicates） ！= -1） {

HiLog.info（LABEL_LOG， “delete successful”）;

}

} catch （DataAbilityRemoteException | IllegalStateException exception） {

HiLog.error（LABEL_LOG， “delete： dataRemote exception | illegalStateException”）;

}

}

private void update（） {

DataAbilityPredicates predicates = new DataAbilityPredicates（）;

predicates.equalTo（DB_COLUMN_PERSON_ID， 102）;

ValuesBucket valuesBucket = new ValuesBucket（）;

valuesBucket.putString（DB_COLUMN_NAME， “ZhangSanPlus”）;

valuesBucket.putInteger（DB_COLUMN_AGE， 28）;

try {

if （databaseHelper.update（Uri.parse（BASE_URI + DATA_PATH）， valuesBucket， predicates） ！= -1） {

HiLog.info（LABEL_LOG， “update successful”）;

}

} catch （DataAbilityRemoteException | IllegalStateException exception） {

HiLog.error（LABEL_LOG， “update： dataRemote exception | illegalStateException”）;

}

}

private void query（） {

String［］ columns = new String［］ {DB_COLUMN_PERSON_ID，

DB_COLUMN_NAME， DB_COLUMN_GENDER， DB_COLUMN_AGE};

// 构造查询条件

DataAbilityPredicates predicates = new DataAbilityPredicates（）;

predicates.between（DB_COLUMN_AGE， 15， 40）; // 查询时间段

try {

ResultSet resultSet = databaseHelper.query（Uri.parse（BASE_URI + DATA_PATH），

columns， predicates）;

if （resultSet == null || resultSet.getRowCount（） == 0） {

HiLog.info（LABEL_LOG， “query： resultSet is null or no result found”）;

return;

}

resultSet.goToFirstRow（）;

do {

int id = resultSet.getInt（resultSet.getColumnIndexForName（DB_COLUMN_PERSON_ID））;

String name = resultSet.getString（resultSet.getColumnIndexForName（DB_COLUMN_NAME））;

String gender = resultSet.getString（resultSet.getColumnIndexForName（DB_COLUMN_GENDER））;

int age = resultSet.getInt（resultSet.getColumnIndexForName（DB_COLUMN_AGE））;

HiLog.info（LABEL_LOG， “query： Id ：” + id + “ Name ：” + name + “ Gender ：” + gender + “ Age ：” + age）;

} while （resultSet.goToNextRow（））;

} catch （DataAbilityRemoteException | IllegalStateException exception） {

HiLog.error（LABEL_LOG， “query： dataRemote exception | illegalStateException”）;

}

}

}

数据插入使用对象类 ValuesBucket；使用 DataAbilityPredicates 实例进行数据查询的条件设置。

到此有关数据库的关系型数据库操作基本就完成了，是不是非常，非常简单，可以直接拿来主义验证一下。

版权声明：本文内容由网络用户投稿，版权归原作者所有，本站不拥有其著作权，亦不承担相应法律责任。如果您发现本站中有涉嫌抄袭或描述失实的内容，请联系我们jiasou666@gmail.com 处理，核实后本网站将在24小时内删除侵权内容。