[sql] Consider fresh databases suitable for memory-mapped I/O.

sql/meta_table.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "sql/meta_table.h"
 
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/strings/string_util.h"
 #include "sql/connection.h"
 #include "sql/statement.h"
 #include "sql/transaction.h"
 
 namespace {
 
-// Key used in our meta table for version numbers.
+// Keys understood directly by sql:MetaTable.
 const char kVersionKey[] = "version";
 const char kCompatibleVersionKey[] = "last_compatible_version";
+const char kMmapStatusKey[] = "mmap_status";
 
 // Used to track success/failure of deprecation checks.
 enum DeprecationEventType {
   // Database has info, but no meta table.  This is probably bad.
   DEPRECATION_DATABASE_NOT_EMPTY = 0,
 
   // No meta, unable to query sqlite_master.  This is probably bad.
   DEPRECATION_DATABASE_UNKNOWN,
 
   // Failure querying meta table, corruption or similar problem likely.
@@ skipping 23 matching lines @@
 
 namespace sql {
 
 MetaTable::MetaTable() : db_(NULL) {
 }
 
 MetaTable::~MetaTable() {
 }
 
 // static
+int64_t MetaTable::kMmapFailure = -2;
+int64_t MetaTable::kMmapSuccess = -1;
+
+// static
 bool MetaTable::DoesTableExist(sql::Connection* db) {
   DCHECK(db);
   return db->DoesTableExist("meta");
 }
 
 // static
+bool MetaTable::GetMmapStatus(Connection* db, int64_t* status) {
+  const char* kMmapStatusSql = "SELECT value FROM meta WHERE key = ?";
+  Statement s(db->GetUniqueStatement(kMmapStatusSql));
+  if (!s.is_valid())
+    return false;
+
+  // It is fine for the status to be missing entirely, but any error prevents
+  // memory-mapping.
+  s.BindString(0, kMmapStatusKey);
+  *status = s.Step() ? s.ColumnInt64(0) : 0;
+  return s.Succeeded();
+}
+
+// static
+bool MetaTable::SetMmapStatus(Connection* db, int64_t status) {
+  DCHECK(status == kMmapFailure || status == kMmapSuccess || status >= 0);
+
+  const char* kMmapUpdateStatusSql = "REPLACE INTO meta VALUES (?, ?)";
+  Statement s(db->GetUniqueStatement(kMmapUpdateStatusSql));
+  s.BindString(0, kMmapStatusKey);
+  s.BindInt64(1, status);
+  return s.Run();
+}
+
+// static
 void MetaTable::RazeIfDeprecated(Connection* db, int deprecated_version) {
   DCHECK_GT(deprecated_version, 0);
   DCHECK_EQ(0, db->transaction_nesting());
 
   if (!DoesTableExist(db)) {
     sql::Statement s(db->GetUniqueStatement(
         "SELECT COUNT(*) FROM sqlite_master"));
     if (s.Step()) {
       if (s.ColumnInt(0) != 0) {
         RecordDeprecationEvent(DEPRECATION_DATABASE_NOT_EMPTY);
@@ skipping 46 matching lines @@
   // Make sure the table is created an populated atomically.
   sql::Transaction transaction(db_);
   if (!transaction.Begin())
     return false;
 
   if (!DoesTableExist(db)) {
     if (!db_->Execute("CREATE TABLE meta"
         "(key LONGVARCHAR NOT NULL UNIQUE PRIMARY KEY, value LONGVARCHAR)"))
       return false;
 
+    // Newly-created databases start out with mmap'ed I/O, but have no place to
+    // store the setting.  Set here so that later opens don't need to validate.
+    SetMmapStatus(db_, kMmapSuccess);
+
     // Note: there is no index over the meta table. We currently only have a
     // couple of keys, so it doesn't matter. If we start storing more stuff in
     // there, we should create an index.
     SetVersionNumber(version);
     SetCompatibleVersionNumber(compatible_version);
   } else {
     db_->AddTaggedHistogram("Sqlite.Version", GetVersionNumber());
   }
   return transaction.Commit();
 }
@@ skipping 86 matching lines @@
 
 bool MetaTable::PrepareGetStatement(Statement* statement, const char* key) {
   DCHECK(db_ && statement);
   statement->Assign(db_->GetCachedStatement(SQL_FROM_HERE,
       "SELECT value FROM meta WHERE key=?"));
   statement->BindCString(0, key);
   return statement->Step();
 }
 
 }  // namespace sql