[Sync] Add support for loading, updating and querying delete journals in

sync/syncable/directory_backing_store.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 "sync/syncable/directory_backing_store.h"
 
 #include "build/build_config.h"
 
 #include <limits>
 
@@ skipping 22 matching lines @@
 
 namespace syncer {
 namespace syncable {
 
 // This just has to be big enough to hold an UPDATE or INSERT statement that
 // modifies all the columns in the entry table.
 static const string::size_type kUpdateStatementBufferSize = 2048;
 
 // Increment this version whenever updating DB tables.
 extern const int32 kCurrentDBVersion;  // Global visibility for our unittest.
-const int32 kCurrentDBVersion = 83;
+const int32 kCurrentDBVersion = 84;
 
 // Iterate over the fields of |entry| and bind each to |statement| for
 // updating.  Returns the number of args bound.
 void BindFields(const EntryKernel& entry,
                 sql::Statement* statement) {
   int index = 0;
   int i = 0;
   for (i = BEGIN_FIELDS; i < INT64_FIELDS_END; ++i) {
     statement->BindInt64(index++, entry.ref(static_cast<Int64Field>(i)));
   }
@@ skipping 111 matching lines @@
 DirectoryBackingStore::DirectoryBackingStore(const string& dir_name,
                                              sql::Connection* db)
   : db_(db),
     dir_name_(dir_name),
     needs_column_refresh_(false) {
 }
 
 DirectoryBackingStore::~DirectoryBackingStore() {
 }
 
-bool DirectoryBackingStore::DeleteEntries(const MetahandleSet& handles) {
+bool DirectoryBackingStore::DeleteEntries(DeleteFrom from,
+                                          const MetahandleSet& handles) {
   if (handles.empty())
     return true;
 
-  sql::Statement statement(db_->GetCachedStatement(
+  sql::Statement statement;
+  // Call GetCachedStatement() separately to get different statements for
+  // different tables.
+  switch (from) {
+    case DELETE_FROM_METAS:
+      statement.Assign(db_->GetCachedStatement(
           SQL_FROM_HERE, "DELETE FROM metas WHERE metahandle = ?"));
+      break;
+    case DELETE_FROM_JOURNAL:
+      statement.Assign(db_->GetCachedStatement(
+          SQL_FROM_HERE, "DELETE FROM deleted_metas WHERE metahandle = ?"));
+      break;
+  }
 
   for (MetahandleSet::const_iterator i = handles.begin(); i != handles.end();
        ++i) {
     statement.BindInt64(0, *i);
     if (!statement.Run())
       return false;
     statement.Reset(true);
   }
   return true;
 }
 
 bool DirectoryBackingStore::SaveChanges(
     const Directory::SaveChangesSnapshot& snapshot) {
   DCHECK(CalledOnValidThread());
   DCHECK(db_->is_open());
 
   // Back out early if there is nothing to write.
   bool save_info =
     (Directory::KERNEL_SHARE_INFO_DIRTY == snapshot.kernel_info_status);
-  if (snapshot.dirty_metas.size() < 1 && !save_info)
+  if (snapshot.dirty_metas.empty() && snapshot.metahandles_to_purge.empty() &&
+      snapshot.delete_journals.empty() &&
+      snapshot.delete_journals_to_purge.empty() && !save_info) {
     return true;
+  }
 
   sql::Transaction transaction(db_.get());
   if (!transaction.Begin())
     return false;
 
+  PrepareSaveEntryStatement("metas", &save_meta_statment_);
   for (EntryKernelSet::const_iterator i = snapshot.dirty_metas.begin();
        i != snapshot.dirty_metas.end(); ++i) {
-    DCHECK(i->is_dirty());
-    if (!SaveEntryToDB(*i))
+    DCHECK((*i)->is_dirty());
+    if (!SaveEntryToDB(&save_meta_statment_, **i))
       return false;
   }
 
-  if (!DeleteEntries(snapshot.metahandles_to_purge))
+  if (!DeleteEntries(DELETE_FROM_METAS, snapshot.metahandles_to_purge))
+    return false;
+
+  PrepareSaveEntryStatement("deleted_metas", &save_delete_journal_statment_);
+  for (EntryKernelSet::const_iterator i = snapshot.delete_journals.begin();
+       i != snapshot.delete_journals.end(); ++i) {
+    if (!SaveEntryToDB(&save_delete_journal_statment_, **i))
+      return false;
+  }
+
+  if (!DeleteEntries(DELETE_FROM_JOURNAL, snapshot.delete_journals_to_purge))
     return false;
 
   if (save_info) {
     const Directory::PersistedKernelInfo& info = snapshot.kernel_info;
     sql::Statement s1(db_->GetCachedStatement(
             SQL_FROM_HERE,
             "UPDATE share_info "
             "SET store_birthday = ?, "
             "next_id = ?, "
             "notification_state = ?, "
@@ skipping 132 matching lines @@
     if (MigrateVersion81To82())
       version_on_disk = 82;
   }
 
   // Version 83 migration added transaction_version column per sync entry.
   if (version_on_disk == 82) {
     if (MigrateVersion82To83())
       version_on_disk = 83;
   }
 
+  // Version 84 migration added deleted_metas table.
+  if (version_on_disk == 83) {
+    if (MigrateVersion83To84())
+      version_on_disk = 84;
+  }
+
   // If one of the migrations requested it, drop columns that aren't current.
   // It's only safe to do this after migrating all the way to the current
   // version.
   if (version_on_disk == kCurrentDBVersion && needs_column_refresh_) {
     if (!RefreshColumns())
       version_on_disk = 0;
   }
 
   // A final, alternative catch-all migration to simply re-sync everything.
   //
@@ skipping 76 matching lines @@
 
   SafeDropTable("share_info");
   if (!db_->Execute("ALTER TABLE temp_share_info RENAME TO share_info"))
     return false;
 
   needs_column_refresh_ = false;
   return true;
 }
 
 bool DirectoryBackingStore::LoadEntries(MetahandlesIndex* entry_bucket) {
-  string select;
-  select.reserve(kUpdateStatementBufferSize);
-  select.append("SELECT ");
-  AppendColumnList(&select);
-  select.append(" FROM metas ");
+  return LoadEntriesInternal("metas", entry_bucket);
+}
 
-  sql::Statement s(db_->GetUniqueStatement(select.c_str()));
-
-  while (s.Step()) {
-    scoped_ptr<EntryKernel> kernel = UnpackEntry(&s);
-    // A null kernel is evidence of external data corruption.
-    if (!kernel.get())
-      return false;
-    entry_bucket->insert(kernel.release());
-  }
-  return s.Succeeded();
+bool DirectoryBackingStore::LoadDeleteJournals(
+    IdsIndex* delete_journals) {
+  return LoadEntriesInternal("deleted_metas", delete_journals);
 }
 
 bool DirectoryBackingStore::LoadInfo(Directory::KernelLoadInfo* info) {
   {
     sql::Statement s(
         db_->GetUniqueStatement(
             "SELECT store_birthday, next_id, cache_guid, notification_state, "
             "bag_of_chips "
             "FROM share_info"));
     if (!s.Step())
@@ skipping 39 matching lines @@
 
     info->max_metahandle = s.ColumnInt64(0);
 
     // Verify only one row was returned.
     DCHECK(!s.Step());
     DCHECK(s.Succeeded());
   }
   return true;
 }
 
-bool DirectoryBackingStore::SaveEntryToDB(const EntryKernel& entry) {
-  // This statement is constructed at runtime, so we can't use
-  // GetCachedStatement() to let the Connection cache it.   We will construct
-  // and cache it ourselves the first time this function is called.
-  if (!save_entry_statement_.is_valid()) {
-    string query;
-    query.reserve(kUpdateStatementBufferSize);
-    query.append("INSERT OR REPLACE INTO metas ");
-    string values;
-    values.reserve(kUpdateStatementBufferSize);
-    values.append("VALUES ");
-    const char* separator = "( ";
-    int i = 0;
-    for (i = BEGIN_FIELDS; i < FIELD_COUNT; ++i) {
-      query.append(separator);
-      values.append(separator);
-      separator = ", ";
-      query.append(ColumnName(i));
-      values.append("?");
-    }
-    query.append(" ) ");
-    values.append(" )");
-    query.append(values);
-
-    save_entry_statement_.Assign(
-        db_->GetUniqueStatement(query.c_str()));
-  } else {
-    save_entry_statement_.Reset(true);
-  }
-
-  BindFields(entry, &save_entry_statement_);
-  return save_entry_statement_.Run();
+/* static */
+bool DirectoryBackingStore::SaveEntryToDB(sql::Statement* save_statement,
+                                          const EntryKernel& entry) {
+  save_statement->Reset(true);
+  BindFields(entry, save_statement);
+  return save_statement->Run();
 }
 
 bool DirectoryBackingStore::DropDeletedEntries() {
   if (!db_->Execute("DELETE FROM metas "
                     "WHERE is_del > 0 "
                     "AND is_unsynced < 1 "
                     "AND is_unapplied_update < 1")) {
     return false;
   }
   if (!db_->Execute("DELETE FROM metas "
@@ skipping 504 matching lines @@
       "ALTER TABLE metas ADD COLUMN transaction_version BIGINT default 0"))
     return false;
   sql::Statement update(db_->GetUniqueStatement(
       "UPDATE metas SET transaction_version = 0"));
   if (!update.Run())
     return false;
   SetVersion(83);
   return true;
 }
 
+bool DirectoryBackingStore::MigrateVersion83To84() {
+  // Version 84 added deleted_metas table to store deleted metas until we know
+  // for sure that the deletions are persisted in native models.
+  string query = "CREATE TABLE deleted_metas ";
+  query.append(ComposeCreateTableColumnSpecs());
+  if (!db_->Execute(query.c_str()))
+    return false;
+  SetVersion(84);
+  return true;
+}
+
 bool DirectoryBackingStore::CreateTables() {
   DVLOG(1) << "First run, creating tables";
   // Create two little tables share_version and share_info
   if (!db_->Execute(
           "CREATE TABLE share_version ("
           "id VARCHAR(128) primary key, data INT)")) {
     return false;
   }
 
   {
@@ skipping 58 matching lines @@
     s.BindBlob(2, ord.data(), ord.length());
 
     if (!s.Run())
       return false;
   }
 
   return true;
 }
 
 bool DirectoryBackingStore::CreateMetasTable(bool is_temporary) {
-  const char* name = is_temporary ? "temp_metas" : "metas";
   string query = "CREATE TABLE ";
-  query.append(name);
+  query.append(is_temporary ? "temp_metas" : "metas");
+  query.append(ComposeCreateTableColumnSpecs());
+  if (!db_->Execute(query.c_str()))
+    return false;
+
+  // Create a deleted_metas table to save copies of deleted metas until the
+  // deletions are persisted. For simplicity, don't try to migrate existing
+  // data because it's rarely used.
+  SafeDropTable("deleted_metas");
+  query = "CREATE TABLE deleted_metas ";
   query.append(ComposeCreateTableColumnSpecs());
   return db_->Execute(query.c_str());
 }
 
 bool DirectoryBackingStore::CreateV71ModelsTable() {
   // This is an old schema for the Models table, used from versions 71 to 74.
   return db_->Execute(
       "CREATE TABLE models ("
       "model_id BLOB primary key, "
       "last_download_timestamp INT, "
@@ skipping 79 matching lines @@
        it != index.end(); ++it) {
     EntryKernel* entry = *it;
     bool prev_exists = (ids_set.find(entry->ref(PREV_ID).value()) != end);
     bool parent_exists = (ids_set.find(entry->ref(PARENT_ID).value()) != end);
     bool next_exists = (ids_set.find(entry->ref(NEXT_ID).value()) != end);
     is_ok = is_ok && prev_exists && parent_exists && next_exists;
   }
   return is_ok;
 }
 
+template<class T>
+bool DirectoryBackingStore::LoadEntriesInternal(const std::string& table,
+                                                T* bucket) {
+  string select;
+  select.reserve(kUpdateStatementBufferSize);
+  select.append("SELECT ");
+  AppendColumnList(&select);
+  select.append(" FROM " + table);
+
+  sql::Statement s(db_->GetUniqueStatement(select.c_str()));
+
+  while (s.Step()) {
+    scoped_ptr<EntryKernel> kernel = UnpackEntry(&s);
+    // A null kernel is evidence of external data corruption.
+    if (!kernel.get())
+      return false;
+    bucket->insert(kernel.release());
+  }
+  return s.Succeeded();
+}
+
+void DirectoryBackingStore::PrepareSaveEntryStatement(
+    const std::string& table, sql::Statement* save_statement) {
+  if (save_statement->is_valid())
+    return;
+
+  string query;
+  query.reserve(kUpdateStatementBufferSize);
+  query.append("INSERT OR REPLACE INTO " + table);
+  string values;
+  values.reserve(kUpdateStatementBufferSize);
+  values.append(" VALUES ");
+  const char* separator = "( ";
+  int i = 0;
+  for (i = BEGIN_FIELDS; i < FIELD_COUNT; ++i) {
+    query.append(separator);
+    values.append(separator);
+    separator = ", ";
+    query.append(ColumnName(i));
+    values.append("?");
+  }
+  query.append(" ) ");
+  values.append(" )");
+  query.append(values);
+  save_statement->Assign(db_->GetUniqueStatement(
+      base::StringPrintf(query.c_str(), "metas").c_str()));
+}
+
 }  // namespace syncable
 }  // namespace syncer