• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1/*
2 * Copyright (c) 2022 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 *     http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16import fileio from '@ohos.fileio'
17import { LogUtil } from './LogUtil'
18import FolderUtil from './FolderUtil'
19import NoteUtil from './NoteUtil'
20import SysDefData from '../model/databaseModel/SysDefData'
21import FolderData from '../model/databaseModel/FolderData'
22import NoteData from '../model/databaseModel/NoteData'
23import {
24  TableSql,
25  TableName,
26  FolderTableColumn,
27  NoteTableColumn,
28  SysDefFolderUuid,
29  FolderType,
30  Delete,
31  Favorite,
32  NoteType,
33  Top
34} from '../model/databaseModel/EnumData';
35import relationalStore from '@ohos.data.relationalStore';
36import util from '@ohos.util';
37import { BusinessError, Callback } from '@ohos.base';
38import common from '@ohos.app.ability.common';
39
40const TAG: string = 'RdbStoreUtil';
41
42const FileMaxSize: number = 20 * 1024 * 1024;
43let rdbStore = AppStorage.Get<relationalStore.RdbStore>('rdbStore');
44
45/**
46 * db instance
47 */
48class RdbStoreUtil {
49  /**
50   * create db and table
51   */
52  createRdbStore(context: common.UIAbilityContext) {
53    try {
54      relationalStore.getRdbStore(context, SysDefData.dbInfo.db_name)
55        .then(async (store) => {
56          // add sys-def folder and note to AppStorage
57          let folderDataArray: FolderData[] = [];
58          let sysDefFolderArray = [SysDefData.sys_def_allNotes, SysDefData.sys_def_unClassified,
59            SysDefData.sys_def_myFavorites, SysDefData.sys_def_recentDeletes,
60            SysDefData.sys_def_personal, SysDefData.sys_def_life, SysDefData.sys_def_work];
61          sysDefFolderArray.forEach((sysDefFolder) => {
62            let folderData = new FolderData(sysDefFolder.id as number, sysDefFolder.name as string, sysDefFolder.uuid as string, sysDefFolder.color as string,
63              sysDefFolder.folder_type as FolderType, sysDefFolder.is_deleted as Delete, sysDefFolder.created_time as number,
64              sysDefFolder.modified_time as number);
65            folderDataArray.push(folderData);
66          })
67          LogUtil.info(TAG, "folderDataArray[sysdef] : " + folderDataArray.length);
68
69          let noteDataArray: NoteData[] = [];
70          let sysDefNoteArray = [SysDefData.sys_def_note1, SysDefData.sys_def_note2,
71            SysDefData.sys_def_note3, SysDefData.sys_def_note4];
72          sysDefNoteArray.forEach((sysDefNote) => {
73            let noteData = new NoteData(sysDefNote.id as number, sysDefNote.title as string, sysDefNote.uuid as string, sysDefNote.folder_uuid as string, sysDefNote.content_text as string,
74              sysDefNote.content_img as string, sysDefNote.note_type as NoteType, sysDefNote.is_top as Top, sysDefNote.is_favorite as Favorite,
75              sysDefNote.is_deleted as Delete, sysDefNote.created_time as number, sysDefNote.modified_time as number, sysDefNote.deleted_time as number, sysDefNote.slider_value as number);
76            noteDataArray.push(noteData);
77          })
78          LogUtil.info(TAG, "noteDataArray[sysdef] : " + noteDataArray.length)
79
80          AppStorage.SetOrCreate('AllFolderArray', folderDataArray)
81          AppStorage.SetOrCreate('AllNoteArray', noteDataArray)
82          LogUtil.info(TAG, "AppStorage[sysdef] set AllFolderArray and AllNoteArray success")
83
84          // save continue data
85          let isContinue = AppStorage.Get<boolean>('IsContinue');
86          LogUtil.info(TAG, "createRdbStore, isContinue is " + isContinue)
87          if (isContinue) {
88            let continueNote: string = AppStorage.Get('ContinueNote')!;
89            let continueSection: number = AppStorage.Get('ContinueSection')!;
90            let noteObj: NoteData = JSON.parse(continueNote);
91            let noteData: NoteData = new NoteData(noteObj.id, noteObj.title, noteObj.uuid, noteObj.folder_uuid,
92              noteObj.content_text, noteObj.content_img, noteObj.note_type, noteObj.is_top, noteObj.is_favorite,
93              noteObj.is_deleted, noteObj.created_time, noteObj.modified_time, noteObj.deleted_time, noteObj.slider_value);
94
95            // save img to FileDir
96            LogUtil.info(TAG, "createRdbStore, save img to FileDir")
97            let imgNameArray = this.getImgNameFromHtml(noteData)
98            imgNameArray.forEach((imgName: string) => {
99              this.writeToFileDir(imgName)
100            })
101
102            // if not exit this note
103            let exist = false
104            let folderUuid = ""
105            for (let note of noteDataArray) {
106              if (noteData.created_time == note.created_time) {
107                exist = true
108                folderUuid = note.folder_uuid
109                break
110              }
111            }
112            LogUtil.info(TAG, "createRdbStore, exist : " + exist)
113            if (!exist) {
114              // 迁移过来的笔记在本地不存在,则保存在未分类文件夹
115              noteData.folder_uuid = SysDefFolderUuid.UnClassified
116              noteDataArray.push(noteData)
117              AppStorage.SetOrCreate('AllNoteArray', noteDataArray)
118              this.insert(TableName.NoteTable, noteData.toNoteObject(), null);
119              AppStorage.SetOrCreate('Folder', FolderUtil.getFolderData(folderDataArray, SysDefFolderUuid.UnClassified))
120            } else {
121              // 迁移过来的笔记在本地存在,则进行修改
122              for (let i = 0; i < noteDataArray.length; i++) {
123                if (noteData.created_time == noteDataArray[i].created_time) {
124                  noteDataArray[i] = noteData
125                  LogUtil.info(TAG, "createRdbStore, update noteData in noteDataArray success")
126                  break
127                }
128              }
129              let predicates_note = this.getRdbPredicates(TableName.NoteTable)
130              predicates_note.equalTo(NoteTableColumn.CreatedTime, noteData.created_time)
131              this.update(noteData.toNoteObject(), predicates_note, null);
132              AppStorage.SetOrCreate('Folder', FolderUtil.getFolderData(folderDataArray, folderUuid))
133            }
134            AppStorage.SetOrCreate('Note', noteData)
135            AppStorage.SetOrCreate<string>('ContinueNote', JSON.stringify(noteData.toNoteObject()))
136            AppStorage.SetOrCreate('Section', continueSection)
137            AppStorage.SetOrCreate<NoteData>('NewNote', noteData)
138          } else {
139            LogUtil.info(TAG, "createRdbStore, IsContinue false")
140            AppStorage.SetOrCreate('Folder', (AppStorage.Get('AllFolderArray') as FolderData[])[0]);
141            let note = NoteUtil.getFirstNoteData(AppStorage.Get('AllNoteArray')!, SysDefFolderUuid.AllNotes);
142            AppStorage.SetOrCreate('Note', note)
143            if (note) {
144              AppStorage.SetOrCreate<string>('ContinueNote', JSON.stringify(note.toNoteObject()))
145            }
146            AppStorage.SetOrCreate('Section', 3)
147          }
148          AppStorage.SetOrCreate('DBQueryFinished', 1)
149          LogUtil.info(TAG, "createRdbStore, set DBQueryFinished 1")
150          LogUtil.info(TAG, "createRdbStore, store is " + store)
151          rdbStore = store;
152
153          // create table
154          rdbStore.executeSql(TableSql.FolderTableSQL.toString(), null);
155          rdbStore.executeSql(TableSql.NoteTableSQL.toString(), null);
156          rdbStore.executeSql(TableSql.AttachmentTableSQL.toString(), null);
157          rdbStore.executeSql(TableSql.FormTableSQL.toString(), null);
158          LogUtil.info(TAG, "create table success")
159          // insert system defined folder
160          await rdbStore.insert(TableName.FolderTable, SysDefData.sys_def_allNotes);
161          await rdbStore.insert(TableName.FolderTable, SysDefData.sys_def_unClassified);
162          await rdbStore.insert(TableName.FolderTable, SysDefData.sys_def_myFavorites);
163          await rdbStore.insert(TableName.FolderTable, SysDefData.sys_def_recentDeletes);
164          await rdbStore.insert(TableName.FolderTable, SysDefData.sys_def_personal);
165          await rdbStore.insert(TableName.FolderTable, SysDefData.sys_def_life);
166          await rdbStore.insert(TableName.FolderTable, SysDefData.sys_def_work);
167          LogUtil.info(TAG, "insert system defined folder success")
168          // insert system defined note and attachment
169          await rdbStore.insert(TableName.NoteTable, SysDefData.sys_def_note1);
170          await rdbStore.insert(TableName.NoteTable, SysDefData.sys_def_note2);
171          await rdbStore.insert(TableName.NoteTable, SysDefData.sys_def_note3);
172          await rdbStore.insert(TableName.NoteTable, SysDefData.sys_def_note4);
173          LogUtil.info(TAG, "insert system defined note and attachment success")
174        })
175    } catch (err) {
176      LogUtil.warn(TAG, "createRdbStore, error : " + err)
177    }
178  }
179
180  /**
181   * query folders and notes from the database, then save them to the AppStorage.
182   */
183  initAppStorage(context: common.UIAbilityContext) {
184    let folderDataArray: FolderData[] = [];
185    let noteDataArray: NoteData[] = [];
186    try {
187      relationalStore.getRdbStore(context, SysDefData.dbInfo.db_name)
188        .then(async (store) => {
189          LogUtil.info(TAG, "initAppStorage, store is " + store)
190          rdbStore = store;
191          // query folder
192          let columns_folder: string[] = [];
193          let predicates_folder = new relationalStore.RdbPredicates(TableName.FolderTable)
194          let resultSet_folder: relationalStore.ResultSet = await rdbStore.query(predicates_folder, columns_folder);
195          while (resultSet_folder.goToNextRow()) {
196            let id = resultSet_folder.getLong(resultSet_folder.getColumnIndex(FolderTableColumn.Id))
197            let name = resultSet_folder.getString(resultSet_folder.getColumnIndex(FolderTableColumn.Name))
198            let uuid = resultSet_folder.getString(resultSet_folder.getColumnIndex(FolderTableColumn.Uuid))
199            let color = resultSet_folder.getString(resultSet_folder.getColumnIndex(FolderTableColumn.Color))
200            let folder_type = resultSet_folder.getLong(resultSet_folder.getColumnIndex(FolderTableColumn.FolderType))
201            let is_deleted = resultSet_folder.getLong(resultSet_folder.getColumnIndex(FolderTableColumn.IsDeleted))
202            let created_time = resultSet_folder.getLong(resultSet_folder.getColumnIndex(FolderTableColumn.CreatedTime))
203            let modified_time = resultSet_folder.getLong(resultSet_folder.getColumnIndex(FolderTableColumn.ModifiedTime))
204            let folderData = new FolderData(id, name, uuid, color, folder_type, is_deleted, created_time, modified_time)
205            folderDataArray.push(folderData)
206          }
207          resultSet_folder.close();
208          LogUtil.info(TAG, "folderDataArray[query] : " + folderDataArray.length)
209          // query note
210          let columns_note: string[] = [];
211          let predicates_note = new relationalStore.RdbPredicates(TableName.NoteTable);
212          let resultSet_note: relationalStore.ResultSet = await rdbStore.query(predicates_note, columns_note);
213          while (resultSet_note.goToNextRow()) {
214            let id = resultSet_note.getLong(resultSet_note.getColumnIndex(NoteTableColumn.Id))
215            let title = resultSet_note.getString(resultSet_note.getColumnIndex(NoteTableColumn.Title))
216            let uuid = resultSet_note.getString(resultSet_note.getColumnIndex(NoteTableColumn.Uuid))
217            let folder_uuid = resultSet_note.getString(resultSet_note.getColumnIndex(NoteTableColumn.FolderUuid))
218            // 暂时规避备忘录二次打开白屏问题,后续数据库解决
219            let content_text = '';
220            let content_img = '';
221            try {
222              content_text = resultSet_note.getString(resultSet_note.getColumnIndex(NoteTableColumn.ContentText))
223              content_img = resultSet_note.getString(resultSet_note.getColumnIndex(NoteTableColumn.ContentImg))
224            } catch (err) {
225              LogUtil.error(TAG, "initAppStorage, content_img = error : " + err)
226            }
227            let noteType = resultSet_note.getLong(resultSet_note.getColumnIndex(NoteTableColumn.NoteType))
228            let is_top = resultSet_note.getLong(resultSet_note.getColumnIndex(NoteTableColumn.IsTop))
229            let is_favorite = resultSet_note.getLong(resultSet_note.getColumnIndex(NoteTableColumn.IsFavorite))
230            let is_deleted = resultSet_note.getLong(resultSet_note.getColumnIndex(NoteTableColumn.IsDeleted))
231            let created_time = resultSet_note.getLong(resultSet_note.getColumnIndex(NoteTableColumn.CreatedTime))
232            let modified_time = resultSet_note.getLong(resultSet_note.getColumnIndex(NoteTableColumn.ModifiedTime))
233            let deleted_time = resultSet_note.getLong(resultSet_note.getColumnIndex(NoteTableColumn.DeletedTime))
234            let slider_value = resultSet_note.getLong(resultSet_note.getColumnIndex(NoteTableColumn.SliderValue))
235            let noteData = new NoteData(id, title, uuid, folder_uuid, content_text, content_img, noteType, is_top, is_favorite, is_deleted, created_time, modified_time, deleted_time, slider_value)
236            noteDataArray.push(noteData)
237          }
238          resultSet_note.close();
239          LogUtil.info(TAG, "noteDataArray[query] : " + noteDataArray.length)
240          if (folderDataArray === null || folderDataArray === undefined || folderDataArray.length === 0) {
241            LogUtil.info(TAG, "folderDataArray is null")
242            let sysDefFolderArray = [SysDefData.sys_def_allNotes, SysDefData.sys_def_unClassified,
243              SysDefData.sys_def_myFavorites, SysDefData.sys_def_recentDeletes,
244              SysDefData.sys_def_personal, SysDefData.sys_def_life, SysDefData.sys_def_work];
245            sysDefFolderArray.forEach((sysDefFolder) => {
246              let folderData = new FolderData(sysDefFolder.id as number, sysDefFolder.name as string, sysDefFolder.uuid as string, sysDefFolder.color as string,
247                sysDefFolder.folder_type as FolderType, sysDefFolder.is_deleted as Delete, sysDefFolder.created_time as number,
248                sysDefFolder.modified_time as number);
249              folderDataArray.push(folderData)
250            })
251            LogUtil.info(TAG, "folderDataArray[query] : " + folderDataArray.length)
252          }
253          AppStorage.SetOrCreate('AllFolderArray', folderDataArray)
254          AppStorage.SetOrCreate('AllNoteArray', noteDataArray)
255          LogUtil.info(TAG, "AppStorage[query] set AllFolderArray and AllNoteArray success")
256
257          // save continue data
258          let isContinue = AppStorage.Get<boolean>('IsContinue');
259          LogUtil.info(TAG, "initAppStorage, isContinue is " + isContinue)
260          if (isContinue) {
261            let continueNote: string = AppStorage.Get('ContinueNote')!;
262            let continueSection: number = AppStorage.Get('ContinueSection')!;
263
264            let noteObj: NoteData = JSON.parse(continueNote);
265            let noteData: NoteData = new NoteData(noteObj.id, noteObj.title, noteObj.uuid, noteObj.folder_uuid,
266              noteObj.content_text, noteObj.content_img, noteObj.note_type, noteObj.is_top, noteObj.is_favorite,
267              noteObj.is_deleted, noteObj.created_time, noteObj.modified_time, noteObj.deleted_time, noteObj.slider_value);
268
269            // save img to FileDir
270            LogUtil.info(TAG, "initAppStorage, save img to FileDir")
271            let imgNameArray = this.getImgNameFromHtml(noteData)
272            imgNameArray.forEach((imgName: string) => {
273              this.writeToFileDir(imgName)
274            })
275
276            // if not exit this note
277            let exist = false
278            let folderUuid = ""
279            for (let note of noteDataArray) {
280              if (noteData.created_time == note.created_time) {
281                exist = true
282                folderUuid = note.folder_uuid
283                break
284              }
285            }
286            LogUtil.info(TAG, "initAppStorage, exist : " + exist)
287            if (!exist) {
288              // 迁移过来的笔记在本地不存在,则保存在未分类文件夹
289              noteData.folder_uuid = SysDefFolderUuid.UnClassified
290              noteDataArray.push(noteData)
291              AppStorage.SetOrCreate('AllNoteArray', noteDataArray)
292              this.insert(TableName.NoteTable, noteData.toNoteObject(), null);
293              AppStorage.SetOrCreate('Folder', FolderUtil.getFolderData(folderDataArray, SysDefFolderUuid.UnClassified))
294            } else {
295              // 迁移过来的笔记在本地存在,则进行修改
296              for (let i = 0; i < noteDataArray.length; i++) {
297                if (noteData.created_time == noteDataArray[i].created_time) {
298                  noteDataArray[i] = noteData
299                  LogUtil.info(TAG, "initAppStorage, update noteData in noteDataArray success")
300                  break
301                }
302              }
303              let predicates_note = this.getRdbPredicates(TableName.NoteTable)
304              predicates_note.equalTo(NoteTableColumn.CreatedTime, noteData.created_time)
305              this.update(noteData.toNoteObject(), predicates_note, null);
306              AppStorage.SetOrCreate('Folder', FolderUtil.getFolderData(folderDataArray, folderUuid))
307            }
308            AppStorage.SetOrCreate('Note', noteData)
309            AppStorage.SetOrCreate<string>('ContinueNote', JSON.stringify(noteData.toNoteObject()))
310            AppStorage.SetOrCreate('Section', continueSection)
311            AppStorage.SetOrCreate<NoteData>('NewNote', noteData)
312          } else {
313            LogUtil.info(TAG, "initAppStorage, IsContinue false")
314            AppStorage.SetOrCreate('Folder', (AppStorage.Get('AllFolderArray') as FolderData[])[0]);
315            let note = NoteUtil.getFirstNoteData(AppStorage.Get('AllNoteArray')!, SysDefFolderUuid.AllNotes);
316            AppStorage.SetOrCreate('Note', note)
317            if (note) {
318              AppStorage.SetOrCreate<string>('ContinueNote', JSON.stringify(note.toNoteObject()))
319            }
320            AppStorage.SetOrCreate('Section', 3)
321          }
322          AppStorage.SetOrCreate('DBQueryFinished', 1)
323          LogUtil.info(TAG, "initAppStorage, set DBQueryFinished 1")
324        })
325    } catch (err) {
326      LogUtil.error(TAG, "initAppStorage, error : " + err)
327    }
328  }
329
330  getImgNameFromHtml(noteData: NoteData): string[] {
331    let noteContext = AppStorage.Get<common.UIAbilityContext>('noteContext')!;
332    let newModuleName = 'file://' + noteContext.filesDir;
333    let imgNameArray: string[] = [];
334    if (noteData.content_text == undefined || noteData.content_text == null || noteData.content_text == "") {
335      LogUtil.info(TAG, "noteData.content_text is null or undefined")
336      return imgNameArray
337    }
338    let base64regex = new RegExp('/^([0-9a-zA-Z+/]{4})*(([0-9a-zA-Z+/]{2}==)|([0-9a-zA-Z+/]{3}=))?$/');
339    let html: string = '';
340    if (base64regex.test(noteData.content_text)) {
341      let base64 = new util.Base64Helper
342      html = base64.decodeSync(noteData.content_text).toString()
343    } else {
344      html = noteData.content_text
345    }
346    if (html == undefined || html == null || html == "") {
347      return imgNameArray
348    }
349    let imgReg = new RegExp('/<img[^>]+>/g');
350    let srcReg = new RegExp('/src=[\'\"]?([^\'\"]*)[\'\"]?/i');
351    let imgArray = html.match(imgReg)
352    if (imgArray != null) {
353      let hasFirstImg: boolean = false
354      for (let i = 0; i < imgArray.length; i++) {
355        let src = imgArray[i].match(srcReg)
356        if (src != null && src.length > 1) {
357          LogUtil.info(TAG, "getImgNameFromHtml, src[1] : " + src[1])
358          let lastIndex = src[1].lastIndexOf('/')
359          if (lastIndex != -1) {
360            let oldModuleName = src[1].substring(0, lastIndex)
361            let imgName = src[1].substring(lastIndex + 1)
362            noteData.content_text = noteData.content_text.replace(oldModuleName, newModuleName)
363            if (!hasFirstImg) {
364              noteData.content_img = newModuleName + "/" + imgName
365              hasFirstImg = true
366            }
367            imgNameArray.push(imgName)
368          }
369        }
370      }
371    }
372    return imgNameArray
373  }
374
375  writeToFileDir(fileName: string) {
376    LogUtil.info(TAG, "writeToFileDir fileName : " + fileName)
377    let noteContext = AppStorage.Get<common.UIAbilityContext>('noteContext')!;
378    let desPath = noteContext.filesDir + '/' + fileName;
379    LogUtil.info(TAG, "desPath : " + desPath)
380    try {
381      fileio.accessSync(desPath)
382      LogUtil.info(TAG, "desPath has existed, return")
383      return
384    } catch (err) {
385      LogUtil.warn(TAG, "desPath has not existed, need to write")
386    }
387    let srcPath: string = '';
388    let size: number = 0;
389    try {
390      srcPath = noteContext.distributedFilesDir + '/' + fileName;
391      LogUtil.info(TAG, "srcPath : " + srcPath)
392      size = fileio.statSync(srcPath).size
393      LogUtil.info(TAG, "srcPath size : " + size)
394      if (size > FileMaxSize) {
395        LogUtil.warn(TAG, "srcPath size more then FileMaxSize, return")
396        return
397      }
398    }
399    catch (err) {
400      LogUtil.warn(TAG, "desPath has not existed, need to write two")
401      return
402    }
403
404
405    let srcFd: number = 0;
406    try {
407      srcFd = fileio.openSync(srcPath, 0o0)
408      LogUtil.info(TAG, "open srcPath success : " + srcFd)
409    } catch (err) {
410      LogUtil.warn(TAG, "open srcPath failed : " + err)
411      return
412    }
413
414    let desFd: number = 0;
415    try {
416      desFd = fileio.openSync(desPath, 0o2 | 0o100, 0o400 | 0o200 | 0o040 | 0o020)
417      LogUtil.info(TAG, "open desPath success : " + srcFd)
418    } catch (err) {
419      LogUtil.warn(TAG, "open desPath failed : " + err)
420      return
421    }
422
423    let buf = new ArrayBuffer(size)
424    try {
425      let readNum = fileio.readSync(srcFd, buf)
426      LogUtil.info(TAG, "readNum : " + readNum)
427      let writeNum = fileio.writeSync(desFd, buf)
428      LogUtil.info(TAG, "writeNum : " + writeNum)
429    } catch (err) {
430      LogUtil.warn(TAG, "read or write error : " + err)
431    }
432  }
433
434  /**
435   * insert
436   * @param tableName
437   * @param valueBucket
438   * @param callback
439   */
440  insert(tableName: string, valueBucket: relationalStore.ValuesBucket, callback: Callback<number> | null) {
441    rdbStore!.insert(tableName, valueBucket).then((rowId: number) => {
442      LogUtil.info(TAG, "insert success, rowId is " + rowId)
443      if (callback != null) {
444        callback(rowId)
445      }
446    }).catch((err: BusinessError) => {
447      LogUtil.error(TAG, 'insert error:' + err);
448    })
449  }
450
451  /**
452   * delete
453   * @param predicates
454   * @param callback
455   */
456  delete(predicates: relationalStore.RdbPredicates, callback: Callback<number> | null) {
457    rdbStore!.delete(predicates).then((affectedRowCount: number) => {
458      LogUtil.info(TAG, "delete success, affectedRowCount is " + affectedRowCount)
459      if (callback != null) {
460        callback(affectedRowCount)
461      }
462    }).catch((err: BusinessError) => {
463      LogUtil.warn(TAG, "delete error : " + err)
464    })
465  }
466
467  /**
468   * update
469   * @param valueBucket
470   * @param predicates
471   * @param callback
472   */
473  update(valueBucket: relationalStore.ValuesBucket, predicates: relationalStore.RdbPredicates,
474         callback: Callback<number> | null) {
475    if (!rdbStore) {
476      return;
477    }
478    rdbStore!.update(valueBucket, predicates).then((affectedRowCount: number) => {
479      LogUtil.info(TAG, "update success, affectedRowCount is " + affectedRowCount)
480      if (callback != null) {
481        callback(affectedRowCount)
482      }
483    }).catch((err: BusinessError) => {
484      LogUtil.warn(TAG, "update error : " + err)
485    })
486  }
487
488  /**
489   * query
490   * @param columns
491   * @param predicates
492   * @param callback
493   */
494  query(columns: string[], predicates: relationalStore.RdbPredicates, callback: Callback<relationalStore.ResultSet>) {
495    rdbStore!.query(predicates, columns).then((resultSet: relationalStore.ResultSet) => {
496      LogUtil.info(TAG, "query success, row count : " + resultSet.rowCount)
497      if (callback != null) {
498        callback(resultSet)
499      }
500    }).catch((err: BusinessError) => {
501      LogUtil.warn(TAG, "query error : " + err)
502    })
503  }
504
505  /**
506   * get RdbPredicates by table name
507   * @param tableName
508   */
509  getRdbPredicates(tableName: string) {
510    return new relationalStore.RdbPredicates(tableName)
511  }
512
513  updataNoteImage(noteData: NoteData): string {
514    let content_img = ""
515    let imgNameArray = this.getImgNameFromHtml(noteData)
516    if (imgNameArray.length == 0) {
517      return content_img
518    }
519    if (imgNameArray[0] == 'shuxue.png' || imgNameArray[0] == 'cake.png') {
520      content_img = "/res/" + imgNameArray[0]
521    } else {
522      content_img = noteData.content_img
523    }
524    LogUtil.info(TAG, "updataNoteImage, content_img : " + content_img)
525    return content_img
526  }
527}
528
529export default new RdbStoreUtil();