#
#
# patch "cmd_db.cc"
#  from [c47b57fe5d3f3be66f53aeefe527c426952ff302]
#    to [5a9fb76114e44850bca2342292d88fe31eccd9ec]
# 
# patch "database.cc"
#  from [8418e0bb2cefbedaf6435f66f5a5c64c9b77b00b]
#    to [6264f69632e5030d7f68f04a63bb6d4187c47344]
# 
# patch "database.hh"
#  from [59dbc78eee566565e591994556a7c9446f2a8865]
#    to [bd01ca183d77f325835ea588f38a7f6505cc32e0]
# 
# patch "migrate_ancestry.cc"
#  from [351c11cd194241e30554fa81c2f4b7425e76daf2]
#    to [7990d56f09d8c76fdc33f71700780b4634504345]
# 
# patch "migrate_schema.cc"
#  from [71649cdd46641a9c63c8b6dfec3a02af6a426541]
#    to [7076acb1d4039529737cd752b58e47a19d2c2964]
# 
# patch "migration.hh"
#  from [3dad1bb7ccc5d4cca2941b8a650770febeada6e0]
#    to [8ca0e0ff039660286f78fbcc5bac2dc347a90dd9]
#
============================================================
--- database.cc	8418e0bb2cefbedaf6435f66f5a5c64c9b77b00b
+++ database.cc	6264f69632e5030d7f68f04a63bb6d4187c47344
@@ -697,8 +697,6 @@ database_impl::sql(enum open_mode mode)
         }
       install_functions();
     }
-  else
-    I(mode == normal_mode);
 
   return __sql;
 }
@@ -3101,6 +3099,40 @@ void
 }
 
 void
+database::put_file_sizes_for_revision(revision_t const & rev)
+{
+  // FIXME: could we safely drop merge revisions here since their
+  // individual file changes should be already recorded in other
+  // revisions?
+  for (edge_map::const_iterator i = rev.edges.begin(); i != rev.edges.end(); ++i)
+    {
+      cset const & cs = edge_changes(*i);
+
+      for (map<file_path, file_id>::const_iterator i = cs.files_added.begin();
+           i != cs.files_added.end(); ++i)
+        {
+          if (imp->table_has_entry(i->second.inner(), "id", "file_sizes"))
+            continue;
+
+          file_data dat;
+          get_file_version(i->second, dat);
+          imp->put_file_size(i->second, dat);
+        }
+
+      for (map<file_path, pair<file_id, file_id> >::const_iterator
+           i = cs.deltas_applied.begin(); i != cs.deltas_applied.end(); ++i)
+        {
+          if (imp->table_has_entry(i->second.second.inner(), "id", "file_sizes"))
+            continue;
+
+          file_data dat;
+          get_file_version(i->second.second, dat);
+          imp->put_file_size(i->second.second, dat);
+        }
+    }
+}
+
+void
 database::put_roster_for_revision(revision_id const & new_id,
                                   revision_t const & rev)
 {
============================================================
--- database.hh	59dbc78eee566565e591994556a7c9446f2a8865
+++ database.hh	bd01ca183d77f325835ea588f38a7f6505cc32e0
@@ -336,7 +336,6 @@ public:
   void compute_branch_leaves(cert_value const & branch_name, std::set<revision_id> & revs);
   void recalc_branch_leaves(cert_value const & branch_name);
   void delete_existing_branch_leaves();
-  void delete_existing_file_sizes();
 
   // Used through project.cc
   outdated_indicator get_revision_certs(revision_id const & ident,
@@ -489,6 +488,10 @@ public:
   void put_roster_for_revision(revision_id const & new_id,
                                revision_t const & rev);
 
+  // for regenerate_rosters
+  void delete_existing_file_sizes();
+  void put_file_sizes_for_revision(revision_t const & rev);
+
 private:
   static database_cache dbcache;
 
============================================================
--- migrate_schema.cc	71649cdd46641a9c63c8b6dfec3a02af6a426541
+++ migrate_schema.cc	7076acb1d4039529737cd752b58e47a19d2c2964
@@ -903,6 +903,7 @@ struct migration_event
   char const * migrator_sql;
   migrator_cb migrator_func;
   upgrade_regime regime;
+  regen_cache_type regen_type;
 };
 
 // IMPORTANT: whenever you modify this to add a new schema version, you must
@@ -911,59 +912,59 @@ const migration_event migration_events[]
 
 const migration_event migration_events[] = {
   { "edb5fa6cef65bcb7d0c612023d267c3aeaa1e57a",
-    migrate_merge_url_and_group, 0, upgrade_none },
+    migrate_merge_url_and_group, 0, upgrade_none, regen_none},
 
   { "f042f3c4d0a4f98f6658cbaf603d376acf88ff4b",
-    migrate_add_hashes_and_merkle_trees, 0, upgrade_none },
+    migrate_add_hashes_and_merkle_trees, 0, upgrade_none, regen_none },
 
   { "8929e54f40bf4d3b4aea8b037d2c9263e82abdf4",
-    migrate_to_revisions, 0, upgrade_changesetify },
+    migrate_to_revisions, 0, upgrade_changesetify, regen_none },
 
   { "c1e86588e11ad07fa53e5d294edc043ce1d4005a",
-    migrate_to_epochs, 0, upgrade_none },
+    migrate_to_epochs, 0, upgrade_none, regen_none },
 
   { "40369a7bda66463c5785d160819ab6398b9d44f4",
-    migrate_to_vars, 0, upgrade_none },
+    migrate_to_vars, 0, upgrade_none, regen_none },
 
   { "e372b508bea9b991816d1c74680f7ae10d2a6d94",
-    migrate_add_indexes, 0, upgrade_none },
+    migrate_add_indexes, 0, upgrade_none, regen_none },
 
   { "1509fd75019aebef5ac3da3a5edf1312393b70e9",
-    0, migrate_to_external_privkeys, upgrade_none },
+    0, migrate_to_external_privkeys, upgrade_none, regen_none },
 
   { "bd86f9a90b5d552f0be1fa9aee847ea0f317778b",
-    migrate_add_rosters, 0, upgrade_rosterify },
+    migrate_add_rosters, 0, upgrade_rosterify, regen_none },
 
   { "1db80c7cee8fa966913db1a463ed50bf1b0e5b0e",
-    migrate_files_BLOB, 0, upgrade_none },
+    migrate_files_BLOB, 0, upgrade_none, regen_none },
 
   { "9d2b5d7b86df00c30ac34fe87a3c20f1195bb2df",
-    migrate_rosters_no_hash, 0, upgrade_regen_caches },
+    migrate_rosters_no_hash, 0, upgrade_regen_caches, regen_rosters },
 
   { "ae196843d368d042f475e3dadfed11e9d7f9f01e",
-    migrate_add_heights, 0, upgrade_regen_caches },
+    migrate_add_heights, 0, upgrade_regen_caches, regen_heights },
 
   { "48fd5d84f1e5a949ca093e87e5ac558da6e5956d",
-    0, migrate_add_ccode, upgrade_none },
+    0, migrate_add_ccode, upgrade_none, regen_none },
 
   { "fe48b0804e0048b87b4cea51b3ab338ba187bdc2",
-    migrate_add_heights_index, 0, upgrade_none },
+    migrate_add_heights_index, 0, upgrade_none, regen_none },
 
   { "7ca81b45279403419581d7fde31ed888a80bd34e",
-    migrate_to_binary_hashes, 0, upgrade_none },
+    migrate_to_binary_hashes, 0, upgrade_none, regen_none },
 
   { "212dd25a23bfd7bfe030ab910e9d62aa66aa2955",
-    migrate_certs_to_key_hash, 0, upgrade_none },
+    migrate_certs_to_key_hash, 0, upgrade_none, regen_none },
 
   { "9c8d5a9ea8e29c69be6459300982a68321b0ec12",
-    0, migrate_add_branch_leaf_cache, upgrade_none },
+    0, migrate_add_branch_leaf_cache, upgrade_none, regen_branches },
 
   { "0c956abae3e52522e4e0b7c5cbe7868f5047153e",
-    migrate_add_file_sizes, 0, upgrade_regen_caches },
+    migrate_add_file_sizes, 0, upgrade_regen_caches, regen_file_sizes },
 
   // The last entry in this table should always be the current
   // schema ID, with 0 for the migrators.
-  { "1f60cec1b0f6c8c095dc6d0ffeff2bd0af971ce1", 0, 0, upgrade_none }
+  { "1f60cec1b0f6c8c095dc6d0ffeff2bd0af971ce1", 0, 0, upgrade_none, regen_none }
 };
 const size_t n_migration_events = (sizeof migration_events
                                    / sizeof migration_events[0]);
@@ -1195,6 +1196,7 @@ migrate_sql_schema(sqlite3 * db, key_sto
   I(db != NULL);
 
   upgrade_regime regime = upgrade_none; MM(regime);
+  regen_cache_type regen_type = regen_none;
 
   // Take an exclusive lock on the database before we try to read anything
   // from it.  If we don't take this lock until the beginning of the
@@ -1212,6 +1214,16 @@ migrate_sql_schema(sqlite3 * db, key_sto
     m = find_migration(db);
     cat = classify_schema(db, m);
 
+    // if we should regenerate more than just one specific cache,
+    // we regenerate them all
+    if (m->regen_type != regen_none)
+      {
+        if (regen_type == regen_none)
+          regen_type = m->regen_type;
+        else
+          regen_type = regen_all;
+      }
+
     diagnose_unrecognized_schema(cat, filename);
 
     // We really want 'db migrate' on an up-to-date schema to be a no-op
@@ -1221,7 +1233,7 @@ migrate_sql_schema(sqlite3 * db, key_sto
     if (cat == SCHEMA_MATCHES)
       {
         P(F("no migration performed; database schema already up-to-date"));
-        return migration_status(false);
+        return migration_status();
       }
 
 #ifdef SUPPORT_SQLITE_BEFORE_3003014
@@ -1274,16 +1286,17 @@ migrate_sql_schema(sqlite3 * db, key_sto
       {
         string command_str = (regime == upgrade_changesetify
                               ? "changesetify" : "rosterify");
-        return migration_status(false, command_str);
+        return migration_status(regen_none, command_str);
       }
       break;
     case upgrade_regen_caches:
-      return migration_status(true);
+      I(regen_type != regen_none);
+      return migration_status(regen_type);
       break;
     case upgrade_none:
       break;
     }
-  return migration_status(false);
+  return migration_status();
 }
 
 // test_migration_step runs the migration step from SCHEMA to its successor,
============================================================
--- migration.hh	3dad1bb7ccc5d4cca2941b8a650770febeada6e0
+++ migration.hh	8ca0e0ff039660286f78fbcc5bac2dc347a90dd9
@@ -28,18 +28,22 @@ void check_sql_schema(sqlite3 * db, syst
 std::string describe_sql_schema(sqlite3 * db);
 void check_sql_schema(sqlite3 * db, system_path const & filename);
 
+enum regen_cache_type { regen_none, regen_all, regen_rosters,
+                        regen_heights, regen_branches, regen_file_sizes };
+
 class migration_status {
-  bool _need_regen;
+  regen_cache_type _regen_type;
   std::string _flag_day_name;
 public:
   migration_status(){}
-  explicit migration_status(bool regen, std::string flag_day_name = "")
-    : _need_regen(regen),
+  explicit migration_status(regen_cache_type type, std::string flag_day_name = "")
+    : _regen_type(type),
       _flag_day_name(flag_day_name)
   {}
-  bool need_regen() const { return _need_regen; }
+  bool need_regen() const { return _regen_type != regen_none; }
   bool need_flag_day() const { return !_flag_day_name.empty(); }
   std::string flag_day_name() const { return _flag_day_name; }
+  regen_cache_type regen_type() const { return _regen_type; }
 };
 migration_status migrate_sql_schema(sqlite3 * db, key_store & keys,
                                     system_path const & filename);
@@ -77,8 +81,9 @@ build_roster_style_revs_from_manifest_st
                                                  project_t & project,
                                                  std::set<std::string> const & attrs_to_drop);
 
+
 void
-regenerate_caches(database & db);
+regenerate_caches(database & db, regen_cache_type type);
 
 
 #endif // __MIGRATION__
============================================================
--- cmd_db.cc	c47b57fe5d3f3be66f53aeefe527c426952ff302
+++ cmd_db.cc	5a9fb76114e44850bca2342292d88fe31eccd9ec
@@ -144,7 +144,7 @@ CMD(db_migrate, "migrate", "", CMD_REF(d
   if (mstat.need_regen())
     {
       database db(app);
-      regenerate_caches(db);
+      regenerate_caches(db, mstat.regen_type());
     }
 
   if (mstat.need_flag_day())
@@ -380,7 +380,7 @@ CMD(db_regenerate_caches, "regenerate_ca
     F("no arguments needed"));
 
   database db(app);
-  regenerate_caches(db);
+  regenerate_caches(db, regen_all);
 }
 
 CMD_HIDDEN(clear_epoch, "clear_epoch", "", CMD_REF(db), "BRANCH",
============================================================
--- migrate_ancestry.cc	351c11cd194241e30554fa81c2f4b7425e76daf2
+++ migrate_ancestry.cc	7990d56f09d8c76fdc33f71700780b4634504345
@@ -981,24 +981,51 @@ allrevs_toposorted(database & db,
   toposort_rev_ancestry(graph, revisions);
 }
 
-void
-regenerate_caches(database & db)
+static void
+regenerate_rosters(database & db)
 {
-  P(F("regenerating cached rosters and heights"));
-
+  P(F("regenerating cached rosters"));
   db.ensure_open_for_cache_reset();
 
   {
     transaction_guard guard(db);
+    db.delete_existing_rosters();
 
-    db.delete_existing_rosters();
+    vector<revision_id> sorted_ids;
+    allrevs_toposorted(db, sorted_ids);
+
+    ticker done(_("regenerated"), "r", 1);
+    done.set_total(sorted_ids.size());
+
+    for (std::vector<revision_id>::const_iterator i = sorted_ids.begin();
+         i != sorted_ids.end(); ++i)
+      {
+        revision_t rev;
+        revision_id const & rev_id = *i;
+        db.get_revision(rev_id, rev);
+        db.put_roster_for_revision(rev_id, rev);
+        ++done;
+      }
+
+    guard.commit();
+  }
+  P(F("finished regenerating cached rosters"));
+}
+
+static void
+regenerate_heights(database & db)
+{
+  P(F("regenerating cached heights"));
+  db.ensure_open_for_cache_reset();
+
+  {
+    transaction_guard guard(db);
     db.delete_existing_heights();
-    db.delete_existing_file_sizes();
 
     vector<revision_id> sorted_ids;
     allrevs_toposorted(db, sorted_ids);
 
-    ticker done(_("regenerated"), "r", 5);
+    ticker done(_("regenerated"), "r", 1);
     done.set_total(sorted_ids.size());
 
     for (std::vector<revision_id>::const_iterator i = sorted_ids.begin();
@@ -1007,42 +1034,96 @@ regenerate_caches(database & db)
         revision_t rev;
         revision_id const & rev_id = *i;
         db.get_revision(rev_id, rev);
-        db.put_roster_for_revision(rev_id, rev);
         db.put_height_for_revision(rev_id, rev);
         ++done;
       }
 
     guard.commit();
   }
+  P(F("finished regenerating cached heights"));
+}
 
-  P(F("finished regenerating cached rosters and heights"));
-
+static void
+regenerate_branches(database & db)
+{
   P(F("regenerating cached branches"));
+  db.ensure_open_for_cache_reset();
+
   {
     transaction_guard guard(db);
-
     db.delete_existing_branch_leaves();
 
     vector<cert> all_branch_certs;
     db.get_revision_certs(branch_cert_name, all_branch_certs);
     set<string> seen_branches;
-    for (vector<cert>::const_iterator i = all_branch_certs.begin(); i != all_branch_certs.end(); ++i)
+
+    ticker done(_("regenerated"), "r", 1);
+
+    for (vector<cert>::const_iterator i = all_branch_certs.begin();
+         i != all_branch_certs.end(); ++i)
       {
         string const name = i->value();
 
-        std::pair<set<string>::iterator, bool> inserted = seen_branches.insert(name);
+        std::pair<set<string>::iterator, bool> inserted =
+          seen_branches.insert(name);
 
         if (inserted.second)
           {
-            db.recalc_branch_leaves (i->value);
+            db.recalc_branch_leaves(i->value);
+            ++done;
           }
       }
     guard.commit();
   }
   P(F("finished regenerating cached branches"));
+}
 
+static void
+regenerate_file_sizes(database & db)
+{
+  P(F("regenerating cached file sizes for revivisions"));
+  db.ensure_open_for_cache_reset();
+
+  {
+    transaction_guard guard(db);
+    db.delete_existing_file_sizes();
+
+    vector<revision_id> sorted_ids;
+    allrevs_toposorted(db, sorted_ids);
+
+    ticker done(_("regenerated"), "r", 1);
+    done.set_total(sorted_ids.size());
+
+    for (std::vector<revision_id>::const_iterator i = sorted_ids.begin();
+         i != sorted_ids.end(); ++i)
+      {
+        revision_t rev;
+        revision_id const & rev_id = *i;
+        db.get_revision(rev_id, rev);
+        db.put_file_sizes_for_revision(rev);
+        ++done;
+      }
+
+    guard.commit();
+  }
+  P(F("finished regenerating cached file sizes"));
 }
 
+void
+regenerate_caches(database & db, regen_cache_type type)
+{
+  I(type != regen_none);
+
+  if (type == regen_all || type == regen_rosters)
+    regenerate_rosters(db);
+  if (type == regen_all || type == regen_heights)
+    regenerate_heights(db);
+  if (type == regen_all || type == regen_branches)
+    regenerate_branches(db);
+  if (type == regen_all || type == regen_file_sizes)
+    regenerate_file_sizes(db);
+}
+
 // Local Variables:
 // mode: C++
 // fill-column: 76