sql/meta_table.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "sql/meta_table.h"
   6
   7 #include "base/logging.h"
   8 #include "base/metrics/histogram.h"
   9 #include "base/strings/string_util.h"
  10 #include "sql/connection.h"
  11 #include "sql/statement.h"
  12 #include "sql/transaction.h"
  13
  14 namespace {
  15
  16 // Key used in our meta table for version numbers.
  17 const char kVersionKey[] = "version";
  18 const char kCompatibleVersionKey[] = "last_compatible_version";
  19
  20 // Used to track success/failure of deprecation checks.
  21 enum DeprecationEventType {
  22   // Database has info, but no meta table.  This is probably bad.
  23   DEPRECATION_DATABASE_NOT_EMPTY = 0,
  24
  25   // No meta, unable to query sqlite_master.  This is probably bad.
  26   DEPRECATION_DATABASE_UNKNOWN,
  27
  28   // Failure querying meta table, corruption or similar problem likely.
  29   DEPRECATION_FAILED_VERSION,
  30
  31   // Version key not found in meta table.  Some sort of update error likely.
  32   DEPRECATION_NO_VERSION,
  33
  34   // Version was out-dated, database successfully razed.  Should only
  35   // happen once per long-idle user, low volume expected.
  36   DEPRECATION_RAZED,
  37
  38   // Version was out-dated, database raze failed.  This user's
  39   // database will be stuck.
  40   DEPRECATION_RAZE_FAILED,
  41
  42   // Always keep this at the end.
  43   DEPRECATION_EVENT_MAX,
  44 };
  45
  46 void RecordDeprecationEvent(DeprecationEventType deprecation_event) {
  47   UMA_HISTOGRAM_ENUMERATION("Sqlite.DeprecationVersionResult",
  48                             deprecation_event, DEPRECATION_EVENT_MAX);
  49 }
  50
  51 }  // namespace
  52
  53 namespace sql {
  54
  55 MetaTable::MetaTable() : db_(NULL) {
  56 }
  57
  58 MetaTable::~MetaTable() {
  59 }
  60
  61 // static
  62 bool MetaTable::DoesTableExist(sql::Connection* db) {
  63   DCHECK(db);
  64   return db->DoesTableExist("meta");
  65 }
  66
  67 // static
  68 void MetaTable::RazeIfDeprecated(Connection* db, int deprecated_version) {
  69   DCHECK_GT(deprecated_version, 0);
  70   DCHECK_EQ(0, db->transaction_nesting());
  71
  72   if (!DoesTableExist(db)) {
  73     sql::Statement s(db->GetUniqueStatement(
  74         "SELECT COUNT(*) FROM sqlite_master"));
  75     if (s.Step()) {
  76       if (s.ColumnInt(0) != 0) {
  77         RecordDeprecationEvent(DEPRECATION_DATABASE_NOT_EMPTY);
  78       }
  79       // NOTE(shess): Empty database at first run is expected, so
  80       // don't histogram that case.
  81     } else {
  82       RecordDeprecationEvent(DEPRECATION_DATABASE_UNKNOWN);
  83     }
  84     return;
  85   }
  86
  87   // TODO(shess): Share sql with PrepareGetStatement().
  88   sql::Statement s(db->GetUniqueStatement(
  89                        "SELECT value FROM meta WHERE key=?"));
  90   s.BindCString(0, kVersionKey);
  91   if (!s.Step()) {
  92     if (!s.Succeeded()) {
  93       RecordDeprecationEvent(DEPRECATION_FAILED_VERSION);
  94     } else {
  95       RecordDeprecationEvent(DEPRECATION_NO_VERSION);
  96     }
  97     return;
  98   }
  99
 100   int version = s.ColumnInt(0);
 101   s.Clear();  // Clear potential automatic transaction for Raze().
 102   if (version <= deprecated_version) {
 103     if (db->Raze()) {
 104       RecordDeprecationEvent(DEPRECATION_RAZED);
 105     } else {
 106       RecordDeprecationEvent(DEPRECATION_RAZE_FAILED);
 107     }
 108     return;
 109   }
 110
 111   // NOTE(shess): Successfully getting a version which is not
 112   // deprecated is expected, so don't histogram that case.
 113 }
 114
 115 bool MetaTable::Init(Connection* db, int version, int compatible_version) {
 116   DCHECK(!db_ && db);
 117   db_ = db;
 118
 119   // If values stored are null or missing entirely, 0 will be reported.
 120   // Require new clients to start with a greater initial version.
 121   DCHECK_GT(version, 0);
 122   DCHECK_GT(compatible_version, 0);
 123
 124   // Make sure the table is created an populated atomically.
 125   sql::Transaction transaction(db_);
 126   if (!transaction.Begin())
 127     return false;
 128
 129   if (!DoesTableExist(db)) {
 130     if (!db_->Execute("CREATE TABLE meta"
 131         "(key LONGVARCHAR NOT NULL UNIQUE PRIMARY KEY, value LONGVARCHAR)"))
 132       return false;
 133
 134     // Note: there is no index over the meta table. We currently only have a
 135     // couple of keys, so it doesn't matter. If we start storing more stuff in
 136     // there, we should create an index.
 137     SetVersionNumber(version);
 138     SetCompatibleVersionNumber(compatible_version);
 139   } else {
 140     db_->AddTaggedHistogram("Sqlite.Version", GetVersionNumber());
 141   }
 142   return transaction.Commit();
 143 }
 144
 145 void MetaTable::Reset() {
 146   db_ = NULL;
 147 }
 148
 149 void MetaTable::SetVersionNumber(int version) {
 150   DCHECK_GT(version, 0);
 151   SetValue(kVersionKey, version);
 152 }
 153
 154 int MetaTable::GetVersionNumber() {
 155   int version = 0;
 156   return GetValue(kVersionKey, &version) ? version : 0;
 157 }
 158
 159 void MetaTable::SetCompatibleVersionNumber(int version) {
 160   DCHECK_GT(version, 0);
 161   SetValue(kCompatibleVersionKey, version);
 162 }
 163
 164 int MetaTable::GetCompatibleVersionNumber() {
 165   int version = 0;
 166   return GetValue(kCompatibleVersionKey, &version) ? version : 0;
 167 }
 168
 169 bool MetaTable::SetValue(const char* key, const std::string& value) {
 170   Statement s;
 171   PrepareSetStatement(&s, key);
 172   s.BindString(1, value);
 173   return s.Run();
 174 }
 175
 176 bool MetaTable::SetValue(const char* key, int value) {
 177   Statement s;
 178   PrepareSetStatement(&s, key);
 179   s.BindInt(1, value);
 180   return s.Run();
 181 }
 182
 183 bool MetaTable::SetValue(const char* key, int64_t value) {
 184   Statement s;
 185   PrepareSetStatement(&s, key);
 186   s.BindInt64(1, value);
 187   return s.Run();
 188 }
 189
 190 bool MetaTable::GetValue(const char* key, std::string* value) {
 191   Statement s;
 192   if (!PrepareGetStatement(&s, key))
 193     return false;
 194
 195   *value = s.ColumnString(0);
 196   return true;
 197 }
 198
 199 bool MetaTable::GetValue(const char* key, int* value) {
 200   Statement s;
 201   if (!PrepareGetStatement(&s, key))
 202     return false;
 203
 204   *value = s.ColumnInt(0);
 205   return true;
 206 }
 207
 208 bool MetaTable::GetValue(const char* key, int64_t* value) {
 209   Statement s;
 210   if (!PrepareGetStatement(&s, key))
 211     return false;
 212
 213   *value = s.ColumnInt64(0);
 214   return true;
 215 }
 216
 217 bool MetaTable::DeleteKey(const char* key) {
 218   DCHECK(db_);
 219   Statement s(db_->GetUniqueStatement("DELETE FROM meta WHERE key=?"));
 220   s.BindCString(0, key);
 221   return s.Run();
 222 }
 223
 224 void MetaTable::PrepareSetStatement(Statement* statement, const char* key) {
 225   DCHECK(db_ && statement);
 226   statement->Assign(db_->GetCachedStatement(SQL_FROM_HERE,
 227       "INSERT OR REPLACE INTO meta (key,value) VALUES (?,?)"));
 228   statement->BindCString(0, key);
 229 }
 230
 231 bool MetaTable::PrepareGetStatement(Statement* statement, const char* key) {
 232   DCHECK(db_ && statement);
 233   statement->Assign(db_->GetCachedStatement(SQL_FROM_HERE,
 234       "SELECT value FROM meta WHERE key=?"));
 235   statement->BindCString(0, key);
 236   return statement->Step();
 237 }
 238
 239 }  // namespace sql