devbox
繁依Fanyi0
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

uniapp安卓端使用SQLite保存网络文件至本地_uniapp 换机 sqllite迁移数据

作者：繁依Fanyi0 | 2024-03-19 07:30:05

赞

踩

uniapp 换机 sqllite迁移数据

开发环境：uniapp框架、vue2、安卓端

1、uniapp点击manifest.json，APP模块配置开启SQlite模块

2、 utils文件夹中创建sqlite.js文件

  1. module.exports = {
  2.   dbName: 'advs', // 数据库名称
  3.   dbPath: '_doc/advs.db', // 数据库地址,推荐以下划线为开头   _doc/xxx.db
  4.  
  5.   // 判断数据库是否打开
  6.   isOpen() {
  7.     // 数据库打开了就返回 true,否则返回 false
  8.     var open = plus.sqlite.isOpenDatabase({
  9.       name: this.dbName,  // 数据库名称
  10.       path: this.dbPath  // 数据库地址
  11.     })
  12.     return open;
  13.   },
  14.  
  15.   // 创建数据库 或 有该数据库就打开
  16.   openSqlite() {
  17.     return new Promise((resolve, reject) => {
  18.       // 打开数据库
  19.       plus.sqlite.openDatabase({
  20.         name: this.dbName,
  21.         path: this.dbPath,
  22.         success(e) {
  23.           resolve(e); // 成功回调
  24.         }, 
  25.         fail(e) {
  26.           reject(e);  // 失败回调
  27.         }
  28.       })
  29.     })
  30.   },
  31.  
  32.   // 关闭数据库
  33.   closeSqlite() {
  34.     return new Promise((resolve, reject) => {
  35.       plus.sqlite.closeDatabase({
  36.         name: this.dbName,
  37.         success(e) {
  38.           resolve(e);
  39.         },
  40.         fail(e) {
  41.           reject(e);
  42.         }
  43.       })
  44.     })
  45.   },
  46.  
  47.   // 数据库建表 sql:'CREATE TABLE IF NOT EXISTS dbTable("id" varchar(50),"name" TEXT) 
  48.   // 创建 CREATE TABLE IF NOT EXISTS 、 dbTable 是表名，不能用数字开头、括号里是表格的表头
  49.   createTable(dbTable, data) {
  50.     return new Promise((resolve, reject) => {
  51.       // executeSql: 执行增删改等操作的SQL语句
  52.       plus.sqlite.executeSql({
  53.         name: this.dbName,
  54.         sql: `CREATE TABLE IF NOT EXISTS ${dbTable}(${data})`,
  55.         success(e) {
  56.           resolve(e);
  57.         },
  58.         fail(e) {
  59.           reject(e);
  60.         }
  61.       })
  62.     })
  63.   },
  64.  
  65.   // 数据库删表 sql:'DROP TABLE dbTable'
  66.   dropTable(dbTable) {
  67.     return new Promise((resolve, reject) => {
  68.       plus.sqlite.executeSql({
  69.         name: this.dbName,
  70.         sql: `DROP TABLE ${dbTable}`,
  71.         success(e) {
  72.           resolve(e);
  73.         },
  74.         fail(e) {
  75.           reject(e);
  76.         }
  77.       })
  78.     })
  79.   },
  80.  
  81.   // 向表格里添加数据 sql:'INSERT INTO dbTable VALUES('x','x','x')'   对应新增
  82.   // 或者 sql:'INSERT INTO dbTable ('x','x','x') VALUES('x','x','x')'   具体新增
  83.   // 插入 INSERT INTO  、 dbTable 是表名、根据表头列名插入列值
  84.   insertTableData(dbTable, data, condition) {
  85.     // 判断有没有传参
  86.     if (dbTable !== undefined && data !== undefined) {
  87.       // 判断传的参是否有值
  88.       var bol = (JSON.stringify(data) == "{}");
  89.       if (!bol) {
  90.       	if (condition == undefined) {
  91.           var sql = `INSERT INTO ${dbTable} VALUES('${data}')`;
  92.         } else {
  93.           var sql = `INSERT INTO ${dbTable} (${condition}) VALUES(${data})`;
  94.         }
  95.         // console.log(sql);
  96.         return new Promise((resolve, reject) => {
  97.           // 表格添加数据
  98.           plus.sqlite.executeSql({
  99.             name: this.dbName,
  100.             sql: sql,
  101.             success(e) {
  102.               resolve(e);
  103.             },
  104.             fail(e) {
  105.               reject(e);
  106.             }
  107.           })
  108.         })
  109.       } else {
  110.         return new Promise((resolve, reject) => { reject("错误添加") })
  111.       }
  112.     } else {
  113.       return new Promise((resolve, reject) => { reject("错误添加") })
  114.     }
  115.   },
  116.   
  117.   // 根据条件向表格里添加数据  有数据更新、无数据插入
  118.   // (建表时需要设置主键) 例如 --- "roomid" varchar(50) PRIMARY KEY
  119.   insertOrReplaceData(dbTable, data, condition) {
  120.     // 判断有没有传参
  121.     if (dbTable !== undefined && data !== undefined) {
  122.         if (condition == undefined) {
  123.           var sql = `INSERT OR REPLACE INTO ${dbTable} VALUES('${data}')`;
  124.         } else {
  125.           var sql = `INSERT OR REPLACE INTO ${dbTable} (${condition}) VALUES(${data})`;
  126.         }
  127.         // console.log(sql);
  128.         return new Promise((resolve, reject) => {
  129.           // 表格添加数据
  130.           plus.sqlite.executeSql({
  131.             name: this.dbName,
  132.             sql: sql,
  133.             success(e) {
  134.               resolve(e);
  135.             },
  136.             fail(e) {
  137.               reject(e);
  138.             }
  139.           })
  140.       })
  141.     } else {
  142.       return new Promise((resolve, reject) => { reject("错误添加") })
  143.     }
  144.   },
  145.  
  146. // 查询获取数据库里的数据 sql:'SELECT * FROM dbTable WHERE lname = 'lvalue''
  147.   // 查询 SELECT * FROM 、 dbTable 是表名、 WHERE 查找条件 lname,lvalue 是查询条件的列名和列值
  148.   selectTableData(dbTable, lname, lvalue, cc, dd) {
  149.     if (dbTable !== undefined) {
  150.       // 第一个是表单名称，后两个参数是列表名，用来检索
  151.       if (lname !== undefined && cc !== undefined) {
  152.         // 两个检索条件
  153.         var sql = `SELECT * FROM ${dbTable} WHERE ${lname} = '${lvalue}' AND ${cc} = '${dd}'`;
  154.       }
  155.       if (lname !== undefined && cc == undefined) {
  156.         // 一个检索条件
  157.         var sql = `SELECT * FROM ${dbTable} WHERE ${lname} = '${lvalue}'`;
  158.         // console.log(sql);
  159.       }
  160.       if (lname == undefined) {
  161.         var sql = `SELECT * FROM ${dbTable}`;
  162.       }
  163.       return new Promise((resolve, reject) => {
  164.         // 表格查询数据  执行查询的SQL语句
  165.         plus.sqlite.selectSql({
  166.           name: this.dbName,
  167.           sql: sql,
  168.           success(e) {
  169.             resolve(e);
  170.           },
  171.           fail(e) {
  172.             reject(e);
  173.           }
  174.         })
  175.       })
  176.     } else {
  177.       return new Promise((resolve, reject) => { reject("错误查询") });
  178.     }
  179.   },
  180.  
  181.  
  182.   // 删除表里的数据 sql:'DELETE FROM dbTable WHERE lname = 'lvalue''
  183.   // 删除 DELETE FROM 、 dbTable 是表名、 WHERE 查找条件 lname,lvalue 是查询条件的列名和列值
  184.   deleteTableData(dbTable, lname, lvalue, ww, ee) {
  185.     if (dbTable !== undefined) {
  186.       if (lname == undefined) {
  187.         var sql = `DELETE FROM ${dbTable}`;
  188.       } else {
  189.         if (ww !== undefined) {
  190.           // 两个检索条件
  191.           var sql = `DELETE FROM ${dbTable} WHERE ${lname} = '${lvalue}' AND ${ww} = '${ee}'`;
  192.         } else {
  193.           // 一个检索条件
  194.           var sql = `DELETE FROM ${dbTable} WHERE ${lname} = '${lvalue}'`;
  195.         }
  196.       }
  197.       return new Promise((resolve, reject) => {
  198.         // 删除表数据
  199.         plus.sqlite.executeSql({
  200.           name: this.dbName,
  201.           sql: sql,
  202.           success(e) {
  203.             resolve(e);
  204.           },
  205.           fail(e) {
  206.             reject(e);
  207.           }
  208.         })
  209.       })
  210.     } else {
  211.       return new Promise((resolve, reject) => { reject("错误删除") });
  212.     }
  213.   },
  214.  
  215.   // 修改数据表里的数据 sql:"UPDATE dbTable SET 列名 = '列值',列名 = '列值' WHERE lname = 'lvalue'"
  216.   // 修改 UPDATE 、 dbTable 是表名, data: 要修改的列名=修改后列值, lname,lvalue 是查询条件的列名和列值
  217.   updateTableData(dbTable, data, lname, lvalue) {
  218.     if (lname == undefined) {
  219.       var sql = `UPDATE ${dbTable} SET ${data}`;
  220.     } else {
  221.       var sql = `UPDATE ${dbTable} SET ${data} WHERE ${lname} = '${lvalue}'`;
  222.     }
  223.     // WHERE 前面是要修改的列名、列值，后面是条件的列名、列值
  224.     return new Promise((resolve, reject) => {
  225.       // 修改表数据
  226.       plus.sqlite.executeSql({
  227.         name: this.dbName,
  228.         sql: sql,
  229.         success(e) {
  230.           resolve(e);
  231.         },
  232.         fail(e) {
  233.           reject(e);
  234.         }
  235.       })
  236.     })
  237.   },
  238.  
  239.   // 获取指定数据条数  sql:"SELECT * FROM dbTable ORDER BY 'id' DESC LIMIT 15 OFFSET 'num'"
  240.   // dbTable 表名, ORDER BY 代表排序默认正序, id 是排序的条件 DESC 代表倒序，从最后一条数据开始拿
  241.   // LIMIT 15 OFFSET '${num}',这句的意思是跳过 num 条拿 15 条数据, num 为跳过多少条数据是动态值
  242.   // 例 初始num设为0，就从最后的数据开始拿15条，下次不拿刚获取的数据，所以可以让num为15，这样就能一步一步的拿完所有的数据
  243.   pullSQL(dbTable, id, num) {
  244.     return new Promise((resolve, reject) => {
  245.       plus.sqlite.selectSql({
  246.         name: this.dbName,
  247.         sql: `SELECT * FROM ${dbTable} ORDER BY '${id}' DESC LIMIT 15 OFFSET '${num}'`,
  248.         success(e) {
  249.           resolve(e);
  250.         },
  251.         fail(e) {
  252.           reject(e);
  253.         }
  254.       })
  255.     })
  256.   }
  257. }
  258.  
  259.  
  260.

3、在需要使用sqlite的vue中引入js文件   

import DB from "../../utils/sqlite.js"

4、vue methods方法中编写方法

我创建的数据表结构：id 、network_path（网络地址）、local_path（本地地址）

  1. onLoad()
  2. {
  3.     //#ifdef APP-PLUS
  4.     this.openSQL()
  5.     //#endif
  6. },
  7. methods: {
  8.     //#ifdef APP-PLUS
  9.     // -----------------------------------------数据库 start-----------------------------------------
  10.     // 打开数据库
  11.     openSQL()
  12.     {
  13.         // 这个是查询有没有打开数据库
  14.         let open = DB.isOpen();
  15.         console.log("数据库状态", open ? "开启" : "关闭");
  16.         if (!open) {
  17.             DB.openSqlite()
  18.                 .then(res => {
  19.                     console.log("数据库已打开");
  20.                     this.createTable()
  21.                 })
  22.                 .catch(error => {
  23.                     console.log("数据库开启失败");
  24.                 });
  25.         }
  26.     },
  27.     // 创建表
  28.     createTable()
  29.     {
  30.         let open = DB.isOpen();
  31.         if (open) {
  32.             // DB.deleteTableData('advs')
  33.             this.openSQL();
  34.             let sql = '"id" INTEGER PRIMARY KEY AUTOINCREMENT,"network_path" varchar,"local_path" varchar';
  35.             // "key" varchar,
  36.             // 创建表 DB.createTable(表名, 表的列)
  37.             DB.createTable("advs", sql)
  38.                 .then(res => {
  39.                     console.log("创建advs表成功");
  40.                 })
  41.                 .catch(error => {
  42.                     console.log("创建表失败");
  43.                 });
  44.         } else {
  45.             console.log("数据库未打开");
  46.         }
  47.     },
  48.     // -----------------------------------------数据库 end-----------------------------------------
  49.     //#endif
  50. }

5、vue methods方法中编写储存方法

传入data数据，data数据格式为网络地址的一维数组 ['网络地址1','网络地址2']

  1. // 新增表数据 并且 将网络文件缓存本地
  2. insertTableData(data){
  3.     return new Promise((resolve, reject) => {
  4.         let open = DB.isOpen();
  5.         if (open) {
  6.  
  7.             var insertData = Promise.all(data.map((value) => {
  8.                 new Promise((resolve, reject) => {
  9.                     DB.selectTableData("advs", "network_path", value)
  10.                         .then(res => {
  11.                             if (typeof (res[0]) !== 'undefined') {
  12.                                 reject('数据已存在')
  13.                             } else {
  14.                                 resolve('可以新增数据')
  15.                             }
  16.                         })
  17.                         .catch(error => {
  18.                             resolve('不存在')
  19.                         });
  20.                 }).then(res => {
  21.                     //这步downloadFile是下载文件到本地，但是读取不到，需要再执行下边的saveImageToPhotosAlbum存到图库中
  22.                     return new Promise((resolve, reject) => {
  23.                         uni.downloadFile({
  24.                             url: value,
  25.                             success(res1) {
  26.                                 resolve(res1.tempFilePath)
  27.                             },
  28.                         })
  29.                     })
  30.                 }).then(res => {
  31.                     //存到图库中,可以读取到文件了 res1.path 就是本地图库的文件地址
  32.                     return new Promise((resolve, reject) => {
  33.                         uni.saveImageToPhotosAlbum({
  34.                             filePath: res,
  35.                             success: (res1) => {
  36.                                 resolve(res1.path)
  37.                             }
  38.                         })
  39.                     })
  40.                 }).then(res => {
  41.                     return new Promise((resolve, reject) => {
  42.                         let sql =
  43.                             `'${value}','${res}'`;
  44.                         let condition = "'network_path','local_path'";
  45.                         // 新增 DB.insertTableData(表名, 对应表头列的数据)
  46.                         DB.insertTableData("advs", sql, condition)
  47.                             .then(res => {
  48.                                 resolve("新增数据成功");
  49.                             })
  50.                             .catch(error => {
  51.                                 console.log(error)
  52.                                 resolve("新增数据失败");
  53.                             });
  54.                     })
  55.                 }).then(res => {
  56.                     console.log(res)
  57.                     return res
  58.                 })
  59.             })).then(() => {
  60.  
  61.                 resolve('成功')
  62.             })
  63.         } else {
  64.             reject("数据库未打开");
  65.             console.log("数据库未打开");
  66.         }
  67.     })
  68. }

或者说直接传单个文件地址

  1. // 新增表数据 并且 将网络文件缓存本地
  2. // data:文件的网络地址
  3. insertTableData(data)
  4. {
  5.     let open = DB.isOpen();
  6.     if (open) {
  7.         new Promise((resolve, reject) => {
  8.             DB.selectTableData("advs", "network_path", data)
  9.                 .then(res => {
  10.                     if (typeof (res[0]) !== 'undefined') {
  11.                         reject('数据已存在')
  12.                     } else {
  13.                         resolve('可以新增数据')
  14.                     }
  15.                 })
  16.                 .catch(error => {
  17.                     resolve('不存在')
  18.                 });
  19.         }).then(res => {
  20.             //这步downloadFile是下载文件到本地，但是读取不到，需要再执行下边的saveImageToPhotosAlbum存到图库中
  21.             return new Promise((resolve, reject) => {
  22.                 uni.downloadFile({
  23.                     url: data,
  24.                     success(res1) {
  25.                         resolve(res1.tempFilePath)
  26.                     },
  27.                 })
  28.             })
  29.         }).then(res => {
  30.             //存到图库中,可以读取到文件了 res1.path 就是本地图库的文件地址
  31.             return new Promise((resolve, reject) => {
  32.                 uni.saveImageToPhotosAlbum({
  33.                     filePath: res,
  34.                     success: (res1) => {
  35.                         resolve(res1.path)
  36.                     }
  37.                 })
  38.             })
  39.         }).then(res => {
  40.             return new Promise((resolve, reject) => {
  41.                 let sql =
  42.                     `'${data}','${res}'`;
  43.                 let condition = "'network_path','local_path'";
  44.                 // 新增 DB.insertTableData(表名, 对应表头列的数据)
  45.                 DB.insertTableData("advs", sql, condition)
  46.                     .then(res => {
  47.                         resolve("新增数据成功");
  48.                     })
  49.                     .catch(error => {
  50.                         console.log(error)
  51.                         resolve("新增数据失败");
  52.                     });
  53.             })
  54.         }).then(res => {
  55.             console.log(res)
  56.             return res
  57.         })
  58.     }
  59. }

6、在需要使用地址的地方编写以下方法

  1. //生命周期 - 创建完成（可以访问当前this实例） 
  2. created() {
  3.     //#ifdef APP-PLUS
  4.     DB.selectTableData("advs","network_path",'你的网络地址')
  5.         .then(res => {
  6.             if (res) {
  7.                 //如果数据库中可以查到数据，src 就用本地缓存的地址
  8.                 this.src = res[0].local_path
  9.             }
  10.         })
  11.         .catch(error => {
  12.             //如果数据库中查不到数据，src 就用网络地址
  13.             this.src = '你的网络地址'
  14.         });
  15.     // #endif
  16. },

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/繁依Fanyi0/article/detail/267236
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号