更新记录

1.0.0（2023-07-08）

首次提交

平台兼容性

原生插件通用使用流程：

1. 购买插件，选择该插件绑定的项目。
2. 在HBuilderX里找到项目，在manifest的app原生插件配置中勾选模块，如需要填写参数则参考插件作者的文档添加。
3. 根据插件作者的提供的文档开发代码，在代码中引用插件，调用插件功能。
4. 打包自定义基座，选择插件，得到自定义基座，然后运行时选择自定义基座，进行log输出测试。
5. 开发完毕后正式云打包

付费原生插件目前不支持离线打包。
Android 离线打包原生插件另见文档 https://nativesupport.dcloud.net.cn/NativePlugin/offline_package/android
iOS 离线打包原生插件另见文档 https://nativesupport.dcloud.net.cn/NativePlugin/offline_package/ios

注意事项：使用HBuilderX2.7.14以下版本，如果同一插件且同一appid下购买并绑定了多个包名，提交云打包界面提示包名绑定不一致时，需要在HBuilderX项目中manifest.json->“App原生插件配置”->”云端插件“列表中删除该插件重新选择

SQLCipher原生数据库

SQLCipher是啥 ？

SQLCipher是一个开源的加密数据库引擎，它提供了对SQLite数据库进行加密和解密的功能。SQLite是一种轻量级的嵌入式数据库引擎，而SQLCipher通过在SQLite的基础上添加加密层，为数据库添加了强大的数据保护能力。

一、插件API格式采用和sqlite官方接口基本一致的风格进行搭建和编写，实现功能包含：

• 增、删、改、查
• 数据库连接、断开、数据库文件位置、数据库版本
• 查看表等逻辑...

3、代码示例

<template>
    <view class="hd-container">
        <form-item title="数据库" value="sqlcipher" clear />
        <view class="hd-btn" @click="initDb">打开或创建数据库</view>
        <view class="hd-btn" @click="getVersion">查看版本</view>
        <view class="hd-btn" @click="getDatabaseFile">查询文件位置</view>
        <view class="hd-btn" @click="createTable">创建表</view>
        <view class="hd-btn" @click="getAllTables">获取表的信息</view>
        <view class="hd-btn" @click="deleteTable">删除表</view>
        <view class="hd-btn" @click="insertData">insert数据</view>
        <view class="hd-btn" @click="queryData">查询数据</view>
        <view class="hd-btn" @click="deleteDatabaseFile">删除数据库文件</view>
        <view class="hd-btn" @click="closeDb">关闭数据库</view>
        <view class="hd-dataResult" v-if="dataResult">{{dataResult}}</view>
    </view>
</template>

<script>
    // #ifdef APP-PLUS
    const sqlcipher = uni.requireNativePlugin('plugin-sqlcipherModule')
    // #endif
    const tableName = `sqlcipher`
    const dbName = `sqlcipher`
    const password = `sqlcipher123`
    const columnDefs =
        'create table if not exists sqlcipher (code INTEGER, name TEXT, email TEXT, phone TEXT)'
    export default {
        data() {
            return {
                dataResult: ""
            }
        },
        onLoad(){
            console.log('sqlcipher---',JSON.stringify(sqlcipher))
        },
        methods: {
            /**
             * 初始化数据库
             * @param {string} dbName - 数据库名称
             * @param {string} password - 数据库密码
             * @param {function} callback - 回调函数，接收一个参数表示操作结果
             */
            initDb() {
                sqlcipher.InitDb(dbName, password, (result) => {
                    console.log('数据库初始化成功', JSON.stringify(result));
                    if (result['code'] == 200) {
                        uni.showToast({
                            title: '数据库初始化成功!',
                            icon: 'none'
                        });
                    } else {
                        console.error('数据库初始化失败');
                        uni.showToast({
                            title: '数据库初始化失败: ' + result.message,
                            icon: 'none'
                        });
                    }
                });
            },
            /**
             * 获取数据库版本信息
             * @param {function} callback - 回调函数，接收一个参数表示操作结果和版本信息
             */
            getVersion(callback) {
                sqlcipher.getVersion((result) => {
                    if (result['code'] === 200) {
                        this.dataResult = ''
                        // 处理查询结果
                        this.dataResult = result['data']
                    } else {
                        console.error('获取数据库版本信息失败');
                        uni.showToast({
                            title: '获取数据库版本信息失败: ' + result.message,
                            icon: 'none'
                        });
                    }
                });
            },
            /**
             * 获取数据库位置信息
             * @param {function} callback - 回调函数，接收一个参数表示操作结果和版本信息
             */
            getDatabaseFile(callback) {
                sqlcipher.getDatabaseFile(dbName, (result) => {
                    if (result['code'] === 200) {
                        this.dataResult = ''
                        // 处理查询结果
                        this.dataResult = JSON.stringify(result['data'])
                    } else {
                        console.error('获取数据库位置信息失败');
                        uni.showToast({
                            title: '获取数据库位置信息失败: ' + result.message,
                            icon: 'none'
                        });
                    }
                });
            },
            /**
             * 删除数据库文件
             * @param {string} dbName - 数据库名称
             * @param {function} callback - 回调函数，接收一个参数表示操作结果和版本信息
             */
            deleteDatabaseFile(callback) {
                sqlcipher.deleteDatabaseFile(dbName, (result) => {
                    if (result['code'] === 200) {
                        uni.showToast({
                            title: '删除数据库成功',
                            icon: 'none'
                        });
                    } else {
                        console.error('获取数据库版本信息失败');
                        uni.showToast({
                            title: '获取数据库版本信息失败: ' + result.message,
                            icon: 'none'
                        });
                    }
                });
            },

            /**
             * 执行SQL语句
             * @param {string} sql - 要执行的SQL语句
             * @param {Array} bindArgs - 绑定的参数（可选）
             * @param {function} callback - 回调函数，接收一个参数表示操作结果
             */
            executeSql(sql, bindArgs, callback) {
                sqlcipher.executeSql(sql, bindArgs, function(result) {
                    if (result['code'] === 200) {
                        console.log('SQL语句执行成功');
                        uni.showToast({
                            title: '语句执行成功 ' + result.message,
                            icon: 'none'
                        });
                    } else {
                        console.error(result);
                        uni.showToast({
                            title: 'SQL语句执行失败 ' + result.message,
                            icon: 'none'
                        });
                    }
                });

                // 示例1：有绑定参数（bindArgs）的SQL语句执行
                // this.executeSql("UPDATE users SET name = ?, age = ? WHERE id = ?", ['John', 30, 1], function(result) {
                // 处理执行结果
                // });

                // 示例2：没有绑定参数（bindArgs）的SQL语句执行
                // this.executeSql("DELETE FROM users WHERE id = 1", null, function(result) {
                // 处理执行结果
                //});
            },
            /**
             * 创建数据库表格
             * @param {string} tableName - 表格名称
             * @param {string} columnDefs - sql"
             */
            createTable() { //创建表
                sqlcipher.executeSql(columnDefs, (result) => {
                    if (result['code'] == 200) {
                        console.log('Table created successfully');
                        uni.showToast({
                            title: 'SQLTable created successfully ' + result.message,
                            icon: 'none'
                        });
                    } else {
                        console.error('Failed to create table: ' + result.message);
                        uni.showToast({
                            title: 'Failed to create table: ' + result.message,
                            icon: 'none'
                        });
                    }
                });
            },
            /**
             * 获取指定表的表结构信息
             * @param {string} tableName - 表名
             * @param {function} callback - 回调函数，接收一个参数表示操作结果
             */
            getTableSchema() {
                sqlcipher.getTableSchema(tableName, (result) => {
                    if (result.code === 200) {
                        this.dataResult = ''
                        // 处理查询结果
                        this.dataResult = JSON.stringify(result['data'])
                    } else {
                        console.error('获取所有表失败:', result.message);
                        uni.showToast({
                            title: '删除表失败：' + result.message,
                            icon: 'none'
                        });
                    }
                });
            },
            /**
             * 删除指定表的表信息
             * @param {string} tableName - 表名
             * @param {function} callback - 回调函数，接收一个参数表示操作结果
             */
            deleteTable() {
                sqlcipher.deleteTable(tableName, (result) => {
                    if (result.code === 200) {
                        uni.showToast({
                            title: '删除表成功：' + result.message,
                            icon: 'none'
                        });
                    } else {
                        console.error('删除表失败:', result.message);
                        uni.showToast({
                            title: '删除表失败：' + result.message,
                            icon: 'none'
                        });
                    }
                });
            },

            /**
             * 获取指定表的信息
             * @param {function} callback - 回调函数，接收一个参数表示操作结果
             */
            getAllTables() {
                sqlcipher.getAllTables((result) => {
                    if (result.code === 200) {
                        this.dataResult = ''
                        // 处理查询结果
                        this.dataResult = JSON.stringify(result['data'])
                        uni.showToast({
                            title: '获取表成功：' + result.message,
                            icon: 'none'
                        });
                    } else {
                        console.error('获取所有表失败:', result.message);
                        uni.showToast({
                            title: '获取表失败：' + result.message,
                            icon: 'none'
                        });
                    }
                });
            },

            /**
             * 批量删除数据
             * @param {string} tableName - 表名
             * @param {string} whereClause - 删除条件语句
             * @param {Array} whereArgs - 删除条件参数数组
             * @param {function} callback - 回调函数，接收一个参数表示操作结果
             * @description 删除名为users的表中满足条件age > 30的数据
             */
            deleteBatch() {
                let whereClause = 'age > ?';
                let whereArgs = [30];
                sqlcipher.deleteBatch(tableName, whereClause, whereArgs, function(result) {
                    // 处理删除结果
                });
            },
            /**
             * 批量更新数据
             * @param {string} tableName - 表名
             * @param {array} values - 包含要更新的数据的数组，每个元素是一个包含列名和对应值的对象
             * @param {string} whereClause - 更新条件语句
             * @param {array} whereArgs - 更新条件的参数数组
             * @param {function} callback - 回调函数，接收一个参数表示操作结果
             */
            updateDataBatch() {
                let values = [{
                        name: 'John',
                        age: 35
                    },
                    {
                        name: 'Jane',
                        age: 32
                    }
                ];
                let whereClause = 'age > ?';
                let whereArgs = ['30'];
                sqlcipher.updateBatch(tableName, values, whereClause, whereArgs, function(result) {
                    // 处理更新结果
                });
            },
            // 示例用法：删除表
            deleteTable() {
                sqlcipher.deleteTable(tableName, function(result) {
                    if (result.code === 200) {
                        console.log('表删除成功');
                        // 处理删除成功的情况
                        uni.showToast({
                            title: '表删除成功',
                            icon: 'none'
                        });
                    } else {
                        console.error('删除表失败：', result.message);
                        uni.showToast({
                            title: '删除表失败：' + result.message,
                            icon: 'none'
                        });
                        // 处理删除失败的情况
                    }
                });
            },
            /**
             * 插入数据到指定表
             * @param {string} tableName - 表名
             * @param {object} values - 要插入的数据，键值对形式表示字段名和对应的值
             * @param {function} callback - 回调函数，接收一个参数表示操作结果
             */
            insertData() {
                let values = {
                    'code': 20230630,
                    'name': 'Hd-小小的Vlog',
                    'email': 'petalmail.com',
                    'phone': '1992147681'
                };
                let sql = `select  code, name, phone, email from sqlcipher`
                // 示例：插入数据到表中
                sqlcipher.insertData(tableName, values, function(result) {
                    // 处理插入结果
                    if (result.code === 200) {
                        console.log('插入数据成功');
                        uni.showToast({
                            title: '插入数据 successfully ',
                            icon: 'none'
                        });
                        // 处理删除成功的情况
                    } else {
                        console.error('插入数据失败：', result.message);
                        uni.showToast({
                            title: '插入数据失败 ' + result.message,
                            icon: 'none'
                        });
                        // 处理删除失败的情况
                    }
                });
            },
            /**
             * 根据自定义SQL查询数据
             * @param {string} sql - 自定义SQL语句
             * @param {array} selectionArgs - 查询条件的参数数组
             * @param {function} callback - 回调函数，接收一个参数表示操作结果
             */
            queryDataBySql() {
                // 示例：调用queryDataBySql方法查询名为users的表中年龄大于30的数据
                let sql2 = "SELECT * FROM users WHERE age > ?";
                let sql3 = "SELECT name, code, phone, email FROM " + tableName + " ORDER BY code ASC";
                let sql = "SELECT name, code, phone, email FROM sqlcipher ORDER BY code ASC";

                let selectionArgs = ['30'];
                sqlcipher.executeSql(sql, function(result) {
                    // 处理查询结果
                    console.log(result);
                    if (result.code === 200) {
                        console.log('查询数据成功');
                        // 处理查询结果
                        this.dataResult = JSON.stringify(result.data);
                    } else {
                        console.error('查询数据失败');
                        uni.showToast({
                            title: '查询失败：' + result.message,
                            icon: 'none'
                        });
                    }
                });
            },
            /**
             * 查询数据
             * @param {string} tableName - 表名
             * @param {array} columns - 查询的列名数组
             * @param {string} selection - 查询条件
             * @param {array} selectionArgs - 查询条件的参数数组
             * @param {string} groupBy - 分组方式
             * @param {string} having - 过滤条件
             * @param {string} orderBy - 排序方式
             * @param {function} callback - 回调函数，接收一个参数表示操作结果
             * @return {object} - 返回查询结果的游标对象
             */
            queryData2() {
                // 示例：调用queryData方法查询名为users的表中年龄大于30的数据
                let columns = ['name', 'code', 'phone'];
                let selection = 'code > ?';
                let selectionArgs = ['1'];
                let groupBy = null;
                let having = null;
                let orderBy = 'code ASC';
                let sql = `select  code, name, phone, email from sqlcipher`
                /* 
                在示例中，orderBy被设置为'age ASC'，其中age是表中的一个列名，ASC表示按照升序进行排序。

                因此，该示例将查询结果按照年龄列（age）的升序排列，即从小到大排列。

                如果要按照降序排列，可以将ASC改为DESC，例如：orderBy = 'age DESC'，则查询结果将按照年龄列的降序排列，即从大到小排列。 
                 */
                sqlcipher.queryData(tableName, columns, selection, selectionArgs, groupBy, having, orderBy, (result) => {
                    console.log(result);
                    if (result['code'] === 200) {
                        console.log('数据删除成功');
                        // 处理查询结果
                        this.dataResult = JSON.stringify(result['data'])
                    } else {
                        console.error('数据删除失败');
                        uni.showToast({
                            title: '查询失败' + result.message,
                            icon: 'none'
                        });
                    }
                });
            },
            queryData() {
                let columns = ['name', 'code'];
                let selection = null;
                let selectionArgs = null;
                let groupBy = null;
                let having = null;
                let orderBy = 'code ASC';
                sqlcipher.queryData(tableName, columns, selection, selectionArgs, groupBy, having, orderBy, (result) => {
                    console.log(result);
                    if (result.code === 200) {
                        console.log('查询数据成功');
                        // 处理查询结果
                        this.dataResult = JSON.stringify(result.data);
                    } else {
                        console.error('查询数据失败');
                        uni.showToast({
                            title: '查询失败：' + result.message,
                            icon: 'none'
                        });
                    }
                });
            },
            /**
             * 删除数据
             * @param {string} tableName - 表名
             * @param {string} whereClause - 删除条件
             * @param {Array} whereArgs - 删除条件参数
             * @param {function} callback - 回调函数，接收一个参数表示操作结果
             */
            deleteDataExample() {
                let tableName = 'users';
                let whereClause = 'age < ?';
                let whereArgs = ['18'];
                sqlcipher.deleteData(tableName, whereClause, whereArgs, function(result) {
                    if (result['code'] === 200) {
                        console.log('数据删除成功');
                        uni.showToast({
                            title: '数据删除成功',
                            icon: 'success'
                        });
                    } else {
                        console.error('数据删除失败');
                        uni.showToast({
                            title: '数据删除失败',
                            icon: 'none'
                        });
                    }
                });
            },
            /**
             * 关闭数据库连接
             * @param {function} callback - 回调函数，接收一个参数表示操作结果
             */
            closeDb() {
                sqlcipher.close(function(result) {
                    if (result['code'] === 200) {
                        console.log('数据库连接已关闭');
                        uni.showToast({
                            title: '数据库已关闭',
                            icon: 'success'
                        });
                    } else {
                        console.error('关闭数据库连接失败');
                        uni.showToast({
                            title: '关闭数据库失败',
                            icon: 'none'
                        });
                    }
                });
            }
        }
    }
</script>

需要了解其他方法、联系作者、有些方法文档没有写 、懒的写！！！

作者 wx:petalmailo qq 860987228