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  
16  #include "net_stats_database_helper.h"
17  
18  #include <cstdlib>
19  #include <filesystem>
20  
21  #include "net_manager_constants.h"
22  #include "net_mgr_log_wrapper.h"
23  #include "net_stats_constants.h"
24  #include "net_stats_database_defines.h"
25  #include "net_stats_info.h"
26  
27  namespace OHOS {
28  namespace NetManagerStandard {
29  using namespace NetStatsDatabaseDefines;
30  namespace {
__anon93d5b41a0202(void *notUsed, int argc, char **argv, char **colName) 31  NetStatsDatabaseHelper::SqlCallback sqlCallback = [](void *notUsed, int argc, char **argv, char **colName) {
32      std::string data;
33      for (int i = 0; i < argc; i++) {
34          data.append(colName[i]).append(" = ").append(argv[i] ? argv[i] : "nullptr\n");
35      }
36      NETMGR_LOG_D("Recv data: %{public}s", data.c_str());
37      return 0;
38  };
39  
CheckFilePath(const std::string & fileName)40  bool CheckFilePath(const std::string &fileName)
41  {
42      char tmpPath[PATH_MAX] = {0};
43      const auto pos = fileName.find_last_of('/');
44      const auto dir = fileName.substr(0, pos);
45      if (!realpath(dir.c_str(), tmpPath)) {
46          NETMGR_LOG_E("Get realPath failed error: %{public}d, %{public}s", errno, strerror(errno));
47          return false;
48      }
49      if (strcmp(tmpPath, dir.c_str()) != 0) {
50          NETMGR_LOG_E("file name is illegal fileName: %{public}s, tmpPath: %{public}s", fileName.c_str(), tmpPath);
51          return false;
52      }
53      return true;
54  }
55  } // namespace
56  
NetStatsDatabaseHelper(const std::string & path)57  NetStatsDatabaseHelper::NetStatsDatabaseHelper(const std::string &path)
58  {
59      if (!CheckFilePath(path)) {
60          return;
61      }
62      Open(path);
63  }
64  
~NetStatsDatabaseHelper()65  NetStatsDatabaseHelper::~NetStatsDatabaseHelper()
66  {
67      Close();
68      sqlite_ = nullptr;
69  }
70  
ExecSql(const std::string & sql,void * recv,SqlCallback callback)71  int32_t NetStatsDatabaseHelper::ExecSql(const std::string &sql, void *recv, SqlCallback callback)
72  {
73      char *errMsg = nullptr;
74      int32_t ret = sqlite3_exec(sqlite_, sql.c_str(), callback, recv, &errMsg);
75      NETMGR_LOG_D("EXEC SQL : %{public}s", sql.c_str());
76      if (errMsg != nullptr) {
77          NETMGR_LOG_E("Exec sql failed err:%{public}s", errMsg);
78          sqlite3_free(errMsg);
79      }
80      return ret == SQLITE_OK ? NETMANAGER_SUCCESS : NETMANAGER_ERROR;
81  }
82  
CreateTable(const std::string & tableName,const std::string & tableInfo)83  int32_t NetStatsDatabaseHelper::CreateTable(const std::string &tableName, const std::string &tableInfo)
84  {
85      std::string sql = "CREATE TABLE IF NOT EXISTS " + tableName + "(" + tableInfo + ");";
86      int32_t ret = ExecSql(sql, nullptr, sqlCallback);
87      if (ret != NETMANAGER_SUCCESS) {
88          return STATS_ERR_CREATE_TABLE_FAIL;
89      }
90      return NETMANAGER_SUCCESS;
91  }
92  
Open(const std::string & path)93  int32_t NetStatsDatabaseHelper::Open(const std::string &path)
94  {
95      int32_t ret = sqlite3_open_v2(path.c_str(), &sqlite_,
96                                    SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE | SQLITE_OPEN_FULLMUTEX, nullptr);
97      return ret == SQLITE_OK ? NETMANAGER_SUCCESS : NETMANAGER_ERROR;
98  }
99  
InsertData(const std::string & tableName,const std::string & paramList,const NetStatsInfo & info)100  int32_t NetStatsDatabaseHelper::InsertData(const std::string &tableName, const std::string &paramList,
101                                             const NetStatsInfo &info)
102  {
103      std::string params;
104      int32_t paramCount = count(paramList.begin(), paramList.end(), ',') + 1;
105      for (int32_t i = 0; i < paramCount; ++i) {
106          params += "?";
107          if (i != paramCount - 1) {
108              params += ",";
109          }
110      }
111      std::string sql = "INSERT INTO " + tableName + " (" + paramList + ") " + "VALUES" + " (" + params + ") ";
112      int32_t ret = statement_.Prepare(sqlite_, sql);
113      if (ret != SQLITE_OK) {
114          NETMGR_LOG_E("Prepare failed ret:%{public}d", ret);
115          return STATS_ERR_WRITE_DATA_FAIL;
116      }
117      int32_t idx = 1;
118      if (paramCount == UID_PARAM_NUM) {
119          statement_.BindInt32(idx, info.uid_);
120          ++idx;
121      }
122      statement_.BindText(idx, info.iface_);
123      statement_.BindInt64(++idx, info.date_);
124      statement_.BindInt64(++idx, info.rxBytes_);
125      statement_.BindInt64(++idx, info.rxPackets_);
126      statement_.BindInt64(++idx, info.txBytes_);
127      statement_.BindInt64(++idx, info.txPackets_);
128      if (paramCount == UID_PARAM_NUM) {
129          statement_.BindText(++idx, info.ident_);
130      }
131      statement_.BindInt64(++idx, info.flag_);
132      ret = statement_.Step();
133      statement_.ResetStatementAndClearBindings();
134      if (ret != SQLITE_DONE) {
135          NETMGR_LOG_E("Step failed ret:%{public}d", ret);
136          return STATS_ERR_WRITE_DATA_FAIL;
137      }
138      return NETMANAGER_SUCCESS;
139  }
140  
SelectData(std::vector<NetStatsInfo> & infos,const std::string & tableName,uint64_t start,uint64_t end)141  int32_t NetStatsDatabaseHelper::SelectData(std::vector<NetStatsInfo> &infos, const std::string &tableName,
142                                             uint64_t start, uint64_t end)
143  {
144      infos.clear();
145      std::string sql = "SELECT * FROM " + tableName + " t WHERE 1=1 AND t.Date >= ?" + " AND t.Date <= ?";
146      int32_t ret = statement_.Prepare(sqlite_, sql);
147      if (ret != SQLITE_OK) {
148          NETMGR_LOG_E("Prepare failed ret:%{public}d", ret);
149          return STATS_ERR_READ_DATA_FAIL;
150      }
151      int32_t idx = 1;
152      ret = statement_.BindInt64(idx, start);
153      if (ret != SQLITE_OK) {
154          NETMGR_LOG_E("Bind int64 failed ret:%{public}d", ret);
155          return STATS_ERR_READ_DATA_FAIL;
156      }
157      ret = statement_.BindInt64(++idx, end);
158      if (ret != SQLITE_OK) {
159          NETMGR_LOG_E("Bind int64 failed ret:%{public}d", ret);
160          return STATS_ERR_READ_DATA_FAIL;
161      }
162      return Step(infos);
163  }
164  
SelectData(const uint32_t uid,uint64_t start,uint64_t end,std::vector<NetStatsInfo> & infos)165  int32_t NetStatsDatabaseHelper::SelectData(const uint32_t uid, uint64_t start, uint64_t end,
166                                             std::vector<NetStatsInfo> &infos)
167  {
168      infos.clear();
169      std::string sql = "SELECT * FROM " + std::string(UID_TABLE) + " t WHERE 1=1 AND t.UID == ?" + " AND t.Date >= ?" +
170                        " AND t.Date <= ?";
171      int32_t ret = statement_.Prepare(sqlite_, sql);
172      if (ret != SQLITE_OK) {
173          NETMGR_LOG_E("Prepare failed ret:%{public}d", ret);
174          return STATS_ERR_READ_DATA_FAIL;
175      }
176      int32_t idx = 1;
177      ret = statement_.BindInt32(idx, uid);
178      if (ret != SQLITE_OK) {
179          NETMGR_LOG_E("Bind int32 failed ret:%{public}d", ret);
180          return STATS_ERR_READ_DATA_FAIL;
181      }
182      ret = BindInt64(idx, start, end);
183      if (ret != SQLITE_OK) {
184          return ret;
185      }
186      return Step(infos);
187  }
188  
SelectData(const std::string & iface,uint64_t start,uint64_t end,std::vector<NetStatsInfo> & infos)189  int32_t NetStatsDatabaseHelper::SelectData(const std::string &iface, uint64_t start, uint64_t end,
190                                             std::vector<NetStatsInfo> &infos)
191  {
192      infos.clear();
193      std::string sql = "SELECT * FROM " + std::string(IFACE_TABLE) + " t WHERE 1=1 AND t.IFace = ?" +
194                        " AND t.Date >= ?" + " AND t.Date <= ?";
195      int32_t ret = statement_.Prepare(sqlite_, sql);
196      if (ret != SQLITE_OK) {
197          NETMGR_LOG_E("Prepare failed ret:%{public}d", ret);
198          return STATS_ERR_READ_DATA_FAIL;
199      }
200      int32_t idx = 1;
201      ret = statement_.BindText(idx, iface);
202      if (ret != SQLITE_OK) {
203          NETMGR_LOG_E("Bind text failed ret:%{public}d", ret);
204          return STATS_ERR_READ_DATA_FAIL;
205      }
206      ret = BindInt64(idx, start, end);
207      if (ret != SQLITE_OK) {
208          return ret;
209      }
210      return Step(infos);
211  }
212  
SelectData(const std::string & iface,const uint32_t uid,uint64_t start,uint64_t end,std::vector<NetStatsInfo> & infos)213  int32_t NetStatsDatabaseHelper::SelectData(const std::string &iface, const uint32_t uid, uint64_t start, uint64_t end,
214                                             std::vector<NetStatsInfo> &infos)
215  {
216      infos.clear();
217      std::string sql = "SELECT * FROM " + std::string(UID_TABLE) + " t WHERE 1=1 AND t.UID = ?" + " AND t.IFace = ?" +
218                        " AND t.Date >= ?" + " AND t.Date <= ?";
219      int32_t ret = statement_.Prepare(sqlite_, sql);
220      if (ret != SQLITE_OK) {
221          NETMGR_LOG_E("Prepare failed ret:%{public}d", ret);
222          return STATS_ERR_READ_DATA_FAIL;
223      }
224      int32_t idx = 1;
225      ret = statement_.BindInt32(idx, uid);
226      if (ret != SQLITE_OK) {
227          NETMGR_LOG_E("bind int32 ret:%{public}d", ret);
228          return STATS_ERR_READ_DATA_FAIL;
229      }
230      ret = statement_.BindText(++idx, iface);
231      if (ret != SQLITE_OK) {
232          NETMGR_LOG_E("Bind text failed ret:%{public}d", ret);
233          return STATS_ERR_READ_DATA_FAIL;
234      }
235      ret = BindInt64(idx, start, end);
236      if (ret != SQLITE_OK) {
237          return ret;
238      }
239      return Step(infos);
240  }
241  
QueryData(const std::string & tableName,const std::string & ident,uint64_t start,uint64_t end,std::vector<NetStatsInfo> & infos)242  int32_t NetStatsDatabaseHelper::QueryData(const std::string &tableName, const std::string &ident, uint64_t start,
243                                            uint64_t end, std::vector<NetStatsInfo> &infos)
244  {
245      infos.clear();
246      std::string sql =
247          "SELECT * FROM " + tableName + " t WHERE 1=1 AND t.Ident = ?" + " AND t.Date >= ?" + " AND t.Date <= ?";
248      int32_t ret = statement_.Prepare(sqlite_, sql);
249      if (ret != SQLITE_OK) {
250          NETMGR_LOG_E("Prepare failed ret:%{public}d", ret);
251          return STATS_ERR_READ_DATA_FAIL;
252      }
253      int32_t idx = 1;
254      ret = statement_.BindText(idx, ident);
255      if (ret != SQLITE_OK) {
256          NETMGR_LOG_E("bind text ret:%{public}d", ret);
257          return STATS_ERR_READ_DATA_FAIL;
258      }
259      ret = BindInt64(idx, start, end);
260      if (ret != SQLITE_OK) {
261          return ret;
262      }
263      return Step(infos);
264  }
265  
QueryData(const std::string & tableName,const uint32_t uid,const std::string & ident,uint64_t start,uint64_t end,std::vector<NetStatsInfo> & infos)266  int32_t NetStatsDatabaseHelper::QueryData(const std::string &tableName, const uint32_t uid, const std::string &ident,
267                                            uint64_t start, uint64_t end, std::vector<NetStatsInfo> &infos)
268  {
269      infos.clear();
270      std::string sql = "SELECT * FROM " + tableName + " t WHERE 1=1 AND T.UID = ? AND t.Ident = ?" + " AND t.Date >= ?" +
271                        " AND t.Date <= ?";
272      int32_t ret = statement_.Prepare(sqlite_, sql);
273      if (ret != SQLITE_OK) {
274          NETMGR_LOG_E("Prepare failed ret:%{public}d", ret);
275          return STATS_ERR_READ_DATA_FAIL;
276      }
277      int32_t idx = 1;
278      ret = statement_.BindInt32(idx, uid);
279      if (ret != SQLITE_OK) {
280          NETMGR_LOG_E("bind int32 ret:%{public}d", ret);
281          return STATS_ERR_READ_DATA_FAIL;
282      }
283      ret = statement_.BindText(++idx, ident);
284      if (ret != SQLITE_OK) {
285          NETMGR_LOG_E("bind text ret:%{public}d", ret);
286          return STATS_ERR_READ_DATA_FAIL;
287      }
288      ret = BindInt64(idx, start, end);
289      if (ret != SQLITE_OK) {
290          return ret;
291      }
292      return Step(infos);
293  }
294  
DeleteData(const std::string & tableName,uint64_t start,uint64_t end)295  int32_t NetStatsDatabaseHelper::DeleteData(const std::string &tableName, uint64_t start, uint64_t end)
296  {
297      std::string sql =
298          "DELETE FROM " + tableName + " WHERE Date >= " + std::to_string(start) + " AND Date <= " + std::to_string(end);
299      return ExecSql(sql, nullptr, sqlCallback);
300  }
301  
DeleteData(const std::string & tableName,uint64_t uid)302  int32_t NetStatsDatabaseHelper::DeleteData(const std::string &tableName, uint64_t uid)
303  {
304      std::string sql = "DELETE FROM " + tableName + " WHERE UID = ?";
305      int32_t ret = statement_.Prepare(sqlite_, sql);
306      if (ret != SQLITE_OK) {
307          NETMGR_LOG_E("Prepare failed ret:%{public}d", ret);
308          return STATS_ERR_WRITE_DATA_FAIL;
309      }
310      int32_t idx = 1;
311      statement_.BindInt32(idx, static_cast<int32_t>(uid));
312      ret = statement_.Step();
313      statement_.ResetStatementAndClearBindings();
314      if (ret != SQLITE_DONE) {
315          NETMGR_LOG_E("Step failed ret:%{public}d", ret);
316          return STATS_ERR_WRITE_DATA_FAIL;
317      }
318      return NETMANAGER_SUCCESS;
319  }
320  
Close()321  int32_t NetStatsDatabaseHelper::Close()
322  {
323      int32_t ret = sqlite3_close_v2(sqlite_);
324      return ret == SQLITE_OK ? NETMANAGER_SUCCESS : NETMANAGER_ERROR;
325  }
326  
ClearData(const std::string & tableName)327  int32_t NetStatsDatabaseHelper::ClearData(const std::string &tableName)
328  {
329      std::string sql = "DELETE FROM " + tableName;
330      std::string shrinkMemSql = "PRAGMA shrink_memory";
331      int32_t execSqlRet = ExecSql(sql, nullptr, sqlCallback);
332      if (execSqlRet != NETMANAGER_SUCCESS) {
333          NETMGR_LOG_E("Delete data failed");
334          return execSqlRet;
335      }
336      execSqlRet = ExecSql(shrinkMemSql, nullptr, sqlCallback);
337      if (execSqlRet != NETMANAGER_SUCCESS) {
338          NETMGR_LOG_E("Delete data failed");
339          return execSqlRet;
340      }
341      sql = "VACUUM";
342      execSqlRet = ExecSql(sql, nullptr, sqlCallback);
343      if (execSqlRet != NETMANAGER_SUCCESS) {
344          NETMGR_LOG_E("Delete data failed");
345          return execSqlRet;
346      }
347      return ExecSql(shrinkMemSql, nullptr, sqlCallback);
348  }
349  
Step(std::vector<NetStatsInfo> & infos)350  int32_t NetStatsDatabaseHelper::Step(std::vector<NetStatsInfo> &infos)
351  {
352      int32_t rc = statement_.Step();
353      NETMGR_LOG_I("Step result:%{public}d", rc);
354      while (rc != SQLITE_DONE) {
355          if (rc != SQLITE_ROW) {
356              NETMGR_LOG_E("sqlite step error: %{public}d", rc);
357              statement_.ResetStatementAndClearBindings();
358              return STATS_ERR_READ_DATA_FAIL;
359          }
360          int32_t i = 0;
361          NetStatsInfo info;
362          if (statement_.GetColumnCount() == UID_PARAM_NUM) {
363              statement_.GetColumnInt(i, info.uid_);
364              ++i;
365          }
366          statement_.GetColumnString(i, info.iface_);
367          statement_.GetColumnLong(++i, info.date_);
368          statement_.GetColumnLong(++i, info.rxBytes_);
369          statement_.GetColumnLong(++i, info.rxPackets_);
370          statement_.GetColumnLong(++i, info.txBytes_);
371          statement_.GetColumnLong(++i, info.txPackets_);
372          if (statement_.GetColumnCount() == UID_PARAM_NUM) {
373              statement_.GetColumnString(++i, info.ident_);
374          }
375          statement_.GetColumnInt(++i, info.flag_);
376          infos.emplace_back(info);
377          rc = statement_.Step();
378          NETMGR_LOG_D("Step result:%{public}d", rc);
379      }
380      statement_.ResetStatementAndClearBindings();
381      return NETMANAGER_SUCCESS;
382  }
383  
BindInt64(int32_t idx,uint64_t start,uint64_t end)384  int32_t NetStatsDatabaseHelper::BindInt64(int32_t idx, uint64_t start, uint64_t end)
385  {
386      int32_t ret = statement_.BindInt64(++idx, start);
387      if (ret != SQLITE_OK) {
388          NETMGR_LOG_E("Bind int64 failed ret:%{public}d", ret);
389          return STATS_ERR_READ_DATA_FAIL;
390      }
391      ret = statement_.BindInt64(++idx, end);
392      if (ret != SQLITE_OK) {
393          NETMGR_LOG_E("Bind int64 failed ret:%{public}d", ret);
394          return STATS_ERR_READ_DATA_FAIL;
395      }
396  
397      return ret;
398  }
399  
Upgrade()400  int32_t NetStatsDatabaseHelper::Upgrade()
401  {
402      auto ret = ExecTableUpgrade(UID_TABLE, Version_1);
403      if (ret != NETMANAGER_SUCCESS) {
404          NETMGR_LOG_E("Upgrade db failed. table is %{public}s, version is %{public}d", UID_TABLE, Version_1);
405      }
406      ret = ExecTableUpgrade(UID_SIM_TABLE, Version_2);
407      if (ret != NETMANAGER_SUCCESS) {
408          NETMGR_LOG_E("Upgrade db failed. table is %{public}s, version is %{public}d", UID_SIM_TABLE, Version_2);
409      }
410      ret = ExecTableUpgrade(UID_TABLE, Version_3);
411      if (ret != NETMANAGER_SUCCESS) {
412          NETMGR_LOG_E("Upgrade db failed. table is %{public}s, version is %{public}d", UID_TABLE, Version_3);
413      }
414      ret = ExecTableUpgrade(UID_SIM_TABLE, Version_3);
415      if (ret != NETMANAGER_SUCCESS) {
416          NETMGR_LOG_E("Upgrade db failed. table is %{public}s, version is %{public}d", UID_SIM_TABLE, Version_3);
417      }
418      return ret;
419  }
420  
ExecTableUpgrade(const std::string & tableName,TableVersion newVersion)421  int32_t NetStatsDatabaseHelper::ExecTableUpgrade(const std::string &tableName, TableVersion newVersion)
422  {
423      TableVersion oldVersion;
424      auto ret = GetTableVersion(oldVersion, tableName);
425      if (ret != SQLITE_OK) {
426          NETMGR_LOG_E("ExecTableUpgrade getTableVersion failed. ret = %{public}d", ret);
427          return NETMANAGER_ERROR;
428      }
429      if (oldVersion == newVersion) {
430          return NETMANAGER_SUCCESS;
431      }
432      NETMGR_LOG_I("ExecTableUpgrade tableName = %{public}s, oldVersion = %{public}d, newVersion = %{public}d",
433                   tableName.c_str(), oldVersion, newVersion);
434      if (oldVersion < Version_1 && newVersion >= Version_1) {
435          std::string sql = "ALTER TABLE " + tableName + " ADD COLUMN Ident CHAR(100) NOT NULL DEFAULT '';";
436          ret = ExecSql(sql, nullptr, sqlCallback);
437          if (ret != SQLITE_OK) {
438              NETMGR_LOG_E("ExecTableUpgrade version_1 failed. ret = %{public}d", ret);
439          }
440          oldVersion = Version_1;
441      }
442      if (oldVersion < Version_2 && newVersion >= Version_2) {
443          ret = DeleteData(tableName, Sim_UID);
444          if (ret != SQLITE_OK) {
445              NETMGR_LOG_E("ExecTableUpgrade Version_2 failed. ret = %{public}d", ret);
446          }
447          oldVersion = Version_2;
448      }
449      if (oldVersion < Version_3 && newVersion >= Version_3) {
450          std::string sql = "ALTER TABLE " + tableName + " ADD COLUMN Flag INTEGER NOT NULL DEFAULT 0;";
451          ret = ExecSql(sql, nullptr, sqlCallback);
452          if (ret != SQLITE_OK) {
453              NETMGR_LOG_E("ExecTableUpgrade version_3 failed. ret = %{public}d", ret);
454          }
455          oldVersion = Version_3;
456      }
457      if (oldVersion != newVersion) {
458          NETMGR_LOG_E("ExecTableUpgrade error. oldVersion = %{public}d, newVersion = %{public}d",
459                       oldVersion, newVersion);
460          return NETMANAGER_ERROR;
461      }
462      ret = UpdateTableVersion(oldVersion, tableName);
463      if (ret != NETMANAGER_SUCCESS) {
464          NETMGR_LOG_E("ExecTableUpgrade updateVersion failed. ret = %{public}d", ret);
465          return NETMANAGER_ERROR;
466      }
467      return NETMANAGER_SUCCESS;
468  }
469  
GetTableVersion(TableVersion & version,const std::string & tableName)470  int32_t NetStatsDatabaseHelper::GetTableVersion(TableVersion &version, const std::string &tableName)
471  {
472      std::string sql = "SELECT * FROM " + std::string(VERSION_TABLE) + " WHERE Name = ?;";
473      int32_t ret = statement_.Prepare(sqlite_, sql);
474      if (ret != SQLITE_OK) {
475          NETMGR_LOG_E("Prepare failed ret:%{public}d", ret);
476          return STATS_ERR_READ_DATA_FAIL;
477      }
478      int32_t idx = 1;
479      ret = statement_.BindText(idx, tableName);
480      if (ret != SQLITE_OK) {
481          NETMGR_LOG_E("bind text ret:%{public}d", ret);
482          return STATS_ERR_READ_DATA_FAIL;
483      }
484      int32_t rc = statement_.Step();
485      auto v = static_cast<uint32_t>(Version_0);
486      while (rc != SQLITE_DONE) {
487          int32_t i = 1;
488          statement_.GetColumnInt(i, v);
489          rc = statement_.Step();
490      }
491      statement_.ResetStatementAndClearBindings();
492      version = static_cast<TableVersion>(v);
493      return NETMANAGER_SUCCESS;
494  }
495  
UpdateTableVersion(TableVersion version,const std::string & tableName)496  int32_t NetStatsDatabaseHelper::UpdateTableVersion(TableVersion version, const std::string &tableName)
497  {
498      std::string sql = "INSERT OR REPLACE INTO "+ std::string(VERSION_TABLE) + "(Name, Version) VALUES('" +
499                        tableName + "', " + std::to_string(version) + ");";
500      return ExecSql(sql, nullptr, sqlCallback);
501  }
502  
UpdateStatsFlag(const std::string & tableName,uint32_t uid,uint32_t flag)503  int32_t NetStatsDatabaseHelper::UpdateStatsFlag(const std::string &tableName, uint32_t uid, uint32_t flag)
504  {
505      std::string sql = "UPDATE " + tableName + " SET Flag = " + std::to_string(flag) +
506                        " WHERE UID = " + std::to_string(uid);
507      return ExecSql(sql, nullptr, sqlCallback);
508  }
509  } // namespace NetManagerStandard
510  } // namespace OHOS
511