Changed DB to store node positions as Ordinals.

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>
 
 #include "base/base64.h"
 #include "base/debug/trace_event.h"
 #include "base/file_util.h"
 #include "base/hash_tables.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/rand_util.h"
 #include "base/stl_util.h"
 #include "base/string_number_conversions.h"
 #include "base/stringprintf.h"
 #include "base/time.h"
 #include "sql/connection.h"
 #include "sql/statement.h"
 #include "sql/transaction.h"
+#include "sync/internal_api/public/base/node_ordinal.h"
 #include "sync/protocol/bookmark_specifics.pb.h"
 #include "sync/protocol/sync.pb.h"
 #include "sync/syncable/syncable-inl.h"
 #include "sync/syncable/syncable_columns.h"
 #include "sync/util/time.h"
 
 using std::string;
 
 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 = 80;
+const int32 kCurrentDBVersion = 81;
 
 // 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)));
   }
   for ( ; i < TIME_FIELDS_END; ++i) {
     statement->BindInt64(index++,
                          TimeToProtoTime(
                              entry.ref(static_cast<TimeField>(i))));
   }
   for ( ; i < ID_FIELDS_END; ++i) {
     statement->BindString(index++, entry.ref(static_cast<IdField>(i)).s_);
   }
   for ( ; i < BIT_FIELDS_END; ++i) {
     statement->BindInt(index++, entry.ref(static_cast<BitField>(i)));
   }
   for ( ; i < STRING_FIELDS_END; ++i) {
     statement->BindString(index++, entry.ref(static_cast<StringField>(i)));
   }
   std::string temp;
   for ( ; i < PROTO_FIELDS_END; ++i) {
     entry.ref(static_cast<ProtoField>(i)).SerializeToString(&temp);
     statement->BindBlob(index++, temp.data(), temp.length());
   }
+  for( ; i < ORDINAL_FIELDS_END; ++i) {
+    temp = entry.ref(static_cast<OrdinalField>(i)).ToInternalValue();
+    statement->BindBlob(index++, temp.data(), temp.length());
+  }
 }
 
 // The caller owns the returned EntryKernel*.  Assumes the statement currently
-// points to a valid row in the metas table.
+// points to a valid row in the metas table. Returns null to indicate that
+// it detected a corruption in the data on unpacking.
 EntryKernel* UnpackEntry(sql::Statement* statement) {
   EntryKernel* kernel = new EntryKernel();
   DCHECK_EQ(statement->ColumnCount(), static_cast<int>(FIELD_COUNT));
   int i = 0;
   for (i = BEGIN_FIELDS; i < INT64_FIELDS_END; ++i) {
     kernel->put(static_cast<Int64Field>(i), statement->ColumnInt64(i));
   }
   for ( ; i < TIME_FIELDS_END; ++i) {
     kernel->put(static_cast<TimeField>(i),
                 ProtoTimeToTime(statement->ColumnInt64(i)));
   }
   for ( ; i < ID_FIELDS_END; ++i) {
     kernel->mutable_ref(static_cast<IdField>(i)).s_ =
         statement->ColumnString(i);
   }
   for ( ; i < BIT_FIELDS_END; ++i) {
     kernel->put(static_cast<BitField>(i), (0 != statement->ColumnInt(i)));
   }
   for ( ; i < STRING_FIELDS_END; ++i) {
     kernel->put(static_cast<StringField>(i),
                 statement->ColumnString(i));
   }
   for ( ; i < PROTO_FIELDS_END; ++i) {
     kernel->mutable_ref(static_cast<ProtoField>(i)).ParseFromArray(
         statement->ColumnBlob(i), statement->ColumnByteLength(i));
   }
+  for( ; i < ORDINAL_FIELDS_END; ++i) {
+    std::string temp;
+    statement->ColumnBlobAsString(i, &temp);
+    NodeOrdinal unpacked_ord(temp);
+
+    // Its safe to assume that an invalid ordinal is a sign that
+    // some external corruption has occurred. Return null to force
+    // a re-download of the sync data.
+    if(!unpacked_ord.IsValid()) {
+      DVLOG(1) <<"Unpacked invalid ordinal. Signaling that the DB is corrupt";
+      return NULL;
+    }
+    kernel->mutable_ref(static_cast<OrdinalField>(i)) = unpacked_ord;
+  }
   return kernel;
 }
 
 namespace {
 
 string ComposeCreateTableColumnSpecs() {
   const ColumnSpec* begin = g_metas_columns;
   const ColumnSpec* end = g_metas_columns + arraysize(g_metas_columns);
   string query;
   query.reserve(kUpdateStatementBufferSize);
@@ skipping 204 matching lines @@
     if (MigrateVersion78To79())
       version_on_disk = 79;
   }
 
   // Version 80 migration is adding the bag_of_chips column.
   if (version_on_disk == 79) {
     if (MigrateVersion79To80())
       version_on_disk = 80;
   }
 
+  // Version 81 changes the server_position_in_parent_field from an int64
+  // to a blob.
+  if (version_on_disk == 80) {
+    if (MigrateVersion80To81())
+      version_on_disk = 81;
+  }
+
   // 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 86 matching lines @@
   string select;
   select.reserve(kUpdateStatementBufferSize);
   select.append("SELECT ");
   AppendColumnList(&select);
   select.append(" FROM metas ");
 
   sql::Statement s(db_->GetUniqueStatement(select.c_str()));
 
   while (s.Step()) {
     EntryKernel *kernel = UnpackEntry(&s);
+    // A null kernel is evidence of external data corruption.
+    if(!kernel)
+      return false;
     entry_bucket->insert(kernel);
   }
   return s.Succeeded();
 }
 
 bool DirectoryBackingStore::LoadInfo(Directory::KernelLoadInfo* info) {
   {
     sql::Statement s(
         db_->GetUniqueStatement(
             "SELECT store_birthday, next_id, cache_guid, notification_state, "
@@ skipping 54 matching lines @@
   // 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 < PROTO_FIELDS_END; ++i) {
+    for (i = BEGIN_FIELDS; i < END_FIELDS; ++i) {
       query.append(separator);
       values.append(separator);
       separator = ", ";
       query.append(ColumnName(i));
       values.append("?");
     }
     query.append(" ) ");
     values.append(" )");
     query.append(values);
 
@@ skipping 444 matching lines @@
   // Some users are stuck with a DB that causes them to reuse existing IDs.  We
   // perform this one-time fixup on all users to help the few that are stuck.
   // See crbug.com/142987 for details.
   if (!db_->Execute(
           "UPDATE share_info SET next_id = next_id - 65536")) {
     return false;
   }
   SetVersion(79);
   return true;
 }
+
 bool DirectoryBackingStore::MigrateVersion79To80() {
   if (!db_->Execute(
           "ALTER TABLE share_info ADD COLUMN bag_of_chips BLOB"))
     return false;
   sql::Statement update(db_->GetUniqueStatement(
           "UPDATE share_info SET bag_of_chips = ?"));
   // An empty message is serialized to an empty string.
   update.BindBlob(0, NULL, 0);
   if (!update.Run())
     return false;
   SetVersion(80);
   return true;
 }
 
+bool DirectoryBackingStore::MigrateVersion80To81() {
+  if(!db_->Execute(
+         "ALTER TABLE metas ADD COLUMN server_ordinal_in_parent BLOB"))
+    return false;
+
+  sql::Statement get_positions(db_->GetUniqueStatement(
+      "SELECT metahandle, server_position_in_parent FROM metas"));
+
+  sql::Statement put_ordinals(db_->GetUniqueStatement(
+      "UPDATE metas SET server_ordinal_in_parent = ?"
+      "WHERE metahandle = ?"));
+
+  while(get_positions.Step()) {
+    int64 metahandle = get_positions.ColumnInt64(0);
+    int64 position = get_positions.ColumnInt64(1);
+
+    std::string ordinal = Int64ToNodeOrdinal(position).ToInternalValue();
+    put_ordinals.BindBlob(0, ordinal.data(), ordinal.length());
+    put_ordinals.BindInt64(1, metahandle);
+
+    if(!put_ordinals.Run())
+      return false;
+    put_ordinals.Reset(true);
+  }
+
+  SetVersion(81);
+  needs_column_refresh_ = true;
+  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 42 matching lines @@
 
   // Create the big metas table.
   if (!CreateMetasTable(false))
     return false;
 
   {
     // Insert the entry for the root into the metas table.
     const int64 now = TimeToProtoTime(base::Time::Now());
     sql::Statement s(db_->GetUniqueStatement(
             "INSERT INTO metas "
-            "( id, metahandle, is_dir, ctime, mtime) "
-            "VALUES ( \"r\", 1, 1, ?, ?)"));
+            "( id, metahandle, is_dir, ctime, mtime, server_ordinal_in_parent) "
+            "VALUES ( \"r\", 1, 1, ?, ?, ?)"));
     s.BindInt64(0, now);
     s.BindInt64(1, now);
+    std::string ord = NodeOrdinal::CreateInitialOrdinal().ToInternalValue();
+    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";
@@ skipping 92 matching lines @@
     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;
 }
 
 }  // namespace syncable
 }  // namespace syncer