Implement sql::Connection::Raze() in terms of sqlite3_backup API.

sql/connection.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/connection.h"
 
 #include <string.h>
 
 #include "base/file_path.h"
 #include "base/logging.h"
@@ skipping 150 matching lines @@
   if (!dummy.Step())
     return;
 
 #if !defined(USE_SYSTEM_SQLITE)
   // This function is only defined in Chromium's version of sqlite.
   // Do not call it when using system sqlite.
   sqlite3_preload(db_);
 #endif
 }
 
+// Create an in-memory database with the existing database's page
+// size, then backup that database over the existing database.
+bool Connection::Raze() {
+  if (!db_) {
+    DLOG(FATAL) << "Cannot raze null db";
+    return false;
+  }
+
+  if (transaction_nesting_ > 0) {
+    DLOG(FATAL) << "Cannot raze within a transaction";
+    return false;
+  }
+
+  sql::Connection null_db;
+  if (!null_db.OpenInMemory()) {
+    DLOG(FATAL) << "Unable to open in-memory database.";
+    return false;
+  }
+
+  // Propagate the page size to the new database.

[Greg Billock, 2012/03/31 01:23:50]

Maybe say that this gets the page_size from the current connection, and the next
stanze propagates it.

How likely is the DB to respond to this PRAGMA if it is totally goofed up?

[Scott Hess - ex-Googler, 2012/04/04 01:28:25]

OK.
AFAICT, 'PRAGMA page_size' only returns info from the connection structure.  So
this would imply that the database could not even be opened.  In that case, this
approach won't work and something else would need to happen.

+  Statement s(GetUniqueStatement("PRAGMA page_size"));
+  if (!s.Step())
+    return false;
+
+  const std::string sql = StringPrintf("PRAGMA page_size=%d", s.ColumnInt(0));
+  if (!null_db.Execute(sql.c_str()))
+    return false;
+
+  // At this point the null database has no pages.  Force it to have
+  // one.  The backup API tracks the original schema from the

[Greg Billock, 2012/03/31 01:23:50]

so the new DB after the backup will have schema_version = 2?

[Scott Hess - ex-Googler, 2012/04/04 01:28:25]

The backup API restores the backup destination's schema_version and adds one. 
This guarantees that other readers see a schema change.

I'll clarify the comment.  It needs to force the null database to have a page,
otherwise it will back up zero pages, in which case it won't honor the existing
page_size.

+  // destination database and writes it back (incremented once) after
+  // the backup.
+  if (!null_db.Execute("PRAGMA schema_version = 1"))
+    return false;
+
+  sqlite3_backup* backup = sqlite3_backup_init(db_, "main",
+                                               null_db.db_, "main");
+  if (!backup) {
+    DLOG(FATAL) << "Unable to start sqlite3_backup().";
+    return false;
+  }
+
+  ScopedBusyTimeout busy_timeout(db_);
+  busy_timeout.SetTimeout(base::TimeDelta::FromSeconds(1));

[Greg Billock, 2012/03/31 01:23:50]

Just rely on callers to use RazeWithTimeout here?

[Scott Hess - ex-Googler, 2012/04/04 01:28:25]

That is a really good suggestion.  I must have been testing or otherwise
distracted!

+
+  int rc = sqlite3_backup_step(backup, 1);

[Greg Billock, 2012/03/31 01:23:50]

doc says pass -1 to copy all remaining pages. Would that be better?

[Scott Hess - ex-Googler, 2012/04/04 01:28:25]

Partly because I must have missed the -1 setting.  Even so, I'm mixed.  If more
than one page is backed up, I don't know what that would mean, so I am somewhat
inclined to be conservative.

[Scott Hess - ex-Googler, 2012/04/04 19:26:54]

I modified this code to use sqlite3_backup_pagecount() and a DCHECK.

+  sqlite3_backup_finish(backup);
+
+  // The destination database was locked.
+  if (rc == SQLITE_BUSY) {

[Greg Billock, 2012/03/31 01:23:50]

Is there a way to force it open? Presumably something might be wedged hard when
this method is called, right?

[Scott Hess - ex-Googler, 2012/04/04 01:28:25]

Unfortunately, there's no way to force it open without the possibility of the
other writer writing crap over it.  If this is a problem in practice, the
w/timeout version would be reasonable to try.  I think it might be best to try
it out, histogram the results, and see what happened.  Profile databases are
exclusive-access for the most part, and the caller should know that.

+    return false;
+  }
+
+  // There should only be a single page to copy.

[Greg Billock, 2012/03/31 01:23:50]

Using -1 would mean you don't need this, I think.

+  if (rc != SQLITE_DONE) {
+    DLOG(FATAL) << "Unable to copy entire null database.";
+    return false;
+  }
+
+  return true;
+}
+bool Connection::RazeWithTimout(base::TimeDelta timeout) {
+  if (!db_) {
+    DLOG(FATAL) << "Cannot raze null db";
+    return false;
+  }
+
+  ScopedBusyTimeout busy_timeout(db_);
+  busy_timeout.SetTimeout(timeout);
+  return Raze();
+}
+
 bool Connection::BeginTransaction() {
   if (needs_rollback_) {
     DCHECK_GT(transaction_nesting_, 0);
 
     // When we're going to rollback, fail on this begin and don't actually
     // mark us as entering the nested transaction.
     return false;
   }
 
   bool success = true;
@@ skipping 303 matching lines @@
 
 int Connection::OnSqliteError(int err, sql::Statement *stmt) {
   if (error_delegate_.get())
     return error_delegate_->OnError(err, this, stmt);
   // The default handling is to assert on debug and to ignore on release.
   DLOG(FATAL) << GetErrorMessage();
   return err;
 }
 
 }  // namespace sql