Backed out changeset 753b5de51ba1 due to not explainable crash in ts_places_generated_max
authorMarco Bonardo <mbonardo@mozilla.com>
Thu, 17 Feb 2011 17:13:21 +0100
changeset 62746 a96f4d673e66254b66921ef8c4ad76b33f374368
parent 62733 753b5de51ba1737b43417a0010a033cb31d80007
child 62747 299667917db622522909e13718df9fb2c17157ce
push idunknown
push userunknown
push dateunknown
milestone2.0b12pre
backs out753b5de51ba1737b43417a0010a033cb31d80007
Backed out changeset 753b5de51ba1 due to not explainable crash in ts_places_generated_max
toolkit/components/places/src/PlacesDBUtils.jsm
toolkit/components/places/tests/unit/test_preventive_maintenance.js
--- a/toolkit/components/places/src/PlacesDBUtils.jsm
+++ b/toolkit/components/places/src/PlacesDBUtils.jsm
@@ -298,373 +298,360 @@ let PlacesDBUtils = {
   },
 
   _getBoundCoherenceStatements: function PDBU__getBoundCoherenceStatements()
   {
     let cleanupStatements = [];
 
     // MOZ_ANNO_ATTRIBUTES
     // A.1 remove unused attributes
-    let deleteUnusedAnnoAttributes = DBConn.createAsyncStatement(
+    let deleteUnusedAnnoAttributes = DBConn.createStatement(
       "DELETE FROM moz_anno_attributes WHERE id IN ( " +
         "SELECT id FROM moz_anno_attributes n " +
         "WHERE NOT EXISTS " +
             "(SELECT id FROM moz_annos WHERE anno_attribute_id = n.id LIMIT 1) " +
           "AND NOT EXISTS " +
             "(SELECT id FROM moz_items_annos WHERE anno_attribute_id = n.id LIMIT 1) " +
       ")");
     cleanupStatements.push(deleteUnusedAnnoAttributes);
 
     // MOZ_ANNOS
     // B.1 remove annos with an invalid attribute
-    let deleteInvalidAttributeAnnos = DBConn.createAsyncStatement(
+    let deleteInvalidAttributeAnnos = DBConn.createStatement(
       "DELETE FROM moz_annos WHERE id IN ( " +
         "SELECT id FROM moz_annos a " +
         "WHERE NOT EXISTS " +
           "(SELECT id FROM moz_anno_attributes " +
             "WHERE id = a.anno_attribute_id LIMIT 1) " +
       ")");
     cleanupStatements.push(deleteInvalidAttributeAnnos);
 
     // B.2 remove orphan annos
-    let deleteOrphanAnnos = DBConn.createAsyncStatement(
+    let deleteOrphanAnnos = DBConn.createStatement(
       "DELETE FROM moz_annos WHERE id IN ( " +
         "SELECT id FROM moz_annos a " +
         "WHERE NOT EXISTS " +
           "(SELECT id FROM moz_places WHERE id = a.place_id LIMIT 1) " +
       ")");
     cleanupStatements.push(deleteOrphanAnnos);
 
     // MOZ_BOOKMARKS_ROOTS
     // C.1 fix missing Places root
     //     Bug 477739 shows a case where the root could be wrongly removed
     //     due to an endianness issue.  We try to fix broken roots here.
     let selectPlacesRoot = DBConn.createStatement(
       "SELECT id FROM moz_bookmarks WHERE id = :places_root");
     selectPlacesRoot.params["places_root"] = PlacesUtils.placesRootId;
     if (!selectPlacesRoot.executeStep()) {
       // We are missing the root, try to recreate it.
-      let createPlacesRoot = DBConn.createAsyncStatement(
+      let createPlacesRoot = DBConn.createStatement(
         "INSERT INTO moz_bookmarks (id, type, fk, parent, position, title, "
       +                            "guid) "
       + "VALUES (:places_root, 2, NULL, 0, 0, :title, GENERATE_GUID())");
       createPlacesRoot.params["places_root"] = PlacesUtils.placesRootId;
       createPlacesRoot.params["title"] = "";
       cleanupStatements.push(createPlacesRoot);
 
       // Now ensure that other roots are children of Places root.
-      let fixPlacesRootChildren = DBConn.createAsyncStatement(
+      let fixPlacesRootChildren = DBConn.createStatement(
         "UPDATE moz_bookmarks SET parent = :places_root WHERE id IN " +
           "(SELECT folder_id FROM moz_bookmarks_roots " +
             "WHERE folder_id <> :places_root)");
       fixPlacesRootChildren.params["places_root"] = PlacesUtils.placesRootId;
       cleanupStatements.push(fixPlacesRootChildren);
     }
     selectPlacesRoot.finalize();
 
     // C.2 fix roots titles
     //     some alpha version has wrong roots title, and this also fixes them if
     //     locale has changed.
     let updateRootTitleSql = "UPDATE moz_bookmarks SET title = :title " +
                              "WHERE id = :root_id AND title <> :title";
     // root
-    let fixPlacesRootTitle = DBConn.createAsyncStatement(updateRootTitleSql);
+    let fixPlacesRootTitle = DBConn.createStatement(updateRootTitleSql);
     fixPlacesRootTitle.params["root_id"] = PlacesUtils.placesRootId;
     fixPlacesRootTitle.params["title"] = "";
     cleanupStatements.push(fixPlacesRootTitle);
     // bookmarks menu
-    let fixBookmarksMenuTitle = DBConn.createAsyncStatement(updateRootTitleSql);
+    let fixBookmarksMenuTitle = DBConn.createStatement(updateRootTitleSql);
     fixBookmarksMenuTitle.params["root_id"] = PlacesUtils.bookmarksMenuFolderId;
     fixBookmarksMenuTitle.params["title"] =
       PlacesUtils.getString("BookmarksMenuFolderTitle");
     cleanupStatements.push(fixBookmarksMenuTitle);
     // bookmarks toolbar
-    let fixBookmarksToolbarTitle = DBConn.createAsyncStatement(updateRootTitleSql);
+    let fixBookmarksToolbarTitle = DBConn.createStatement(updateRootTitleSql);
     fixBookmarksToolbarTitle.params["root_id"] = PlacesUtils.toolbarFolderId;
     fixBookmarksToolbarTitle.params["title"] =
       PlacesUtils.getString("BookmarksToolbarFolderTitle");
     cleanupStatements.push(fixBookmarksToolbarTitle);
     // unsorted bookmarks
-    let fixUnsortedBookmarksTitle = DBConn.createAsyncStatement(updateRootTitleSql);
+    let fixUnsortedBookmarksTitle = DBConn.createStatement(updateRootTitleSql);
     fixUnsortedBookmarksTitle.params["root_id"] = PlacesUtils.unfiledBookmarksFolderId;
     fixUnsortedBookmarksTitle.params["title"] =
       PlacesUtils.getString("UnsortedBookmarksFolderTitle");
     cleanupStatements.push(fixUnsortedBookmarksTitle);
     // tags
-    let fixTagsRootTitle = DBConn.createAsyncStatement(updateRootTitleSql);
+    let fixTagsRootTitle = DBConn.createStatement(updateRootTitleSql);
     fixTagsRootTitle.params["root_id"] = PlacesUtils.tagsFolderId;
     fixTagsRootTitle.params["title"] =
       PlacesUtils.getString("TagsFolderTitle");
     cleanupStatements.push(fixTagsRootTitle);
 
     // MOZ_BOOKMARKS
     // D.1 remove items without a valid place
     // if fk IS NULL we fix them in D.7
-    let deleteNoPlaceItems = DBConn.createAsyncStatement(
+    let deleteNoPlaceItems = DBConn.createStatement(
       "DELETE FROM moz_bookmarks WHERE id NOT IN ( " +
         "SELECT folder_id FROM moz_bookmarks_roots " + // skip roots
       ") AND id IN (" +
         "SELECT b.id FROM moz_bookmarks b " +
         "WHERE fk NOT NULL AND b.type = :bookmark_type " +
           "AND NOT EXISTS (SELECT url FROM moz_places WHERE id = b.fk LIMIT 1) " +
       ")");
     deleteNoPlaceItems.params["bookmark_type"] = PlacesUtils.bookmarks.TYPE_BOOKMARK;
     cleanupStatements.push(deleteNoPlaceItems);
 
     // D.2 remove items that are not uri bookmarks from tag containers
-    let deleteBogusTagChildren = DBConn.createAsyncStatement(
+    let deleteBogusTagChildren = DBConn.createStatement(
       "DELETE FROM moz_bookmarks WHERE id NOT IN ( " +
         "SELECT folder_id FROM moz_bookmarks_roots " + // skip roots
       ") AND id IN (" +
         "SELECT b.id FROM moz_bookmarks b " +
         "WHERE b.parent IN " +
           "(SELECT id FROM moz_bookmarks WHERE parent = :tags_folder) " +
           "AND b.type <> :bookmark_type " +
       ")");
     deleteBogusTagChildren.params["tags_folder"] = PlacesUtils.tagsFolderId;
     deleteBogusTagChildren.params["bookmark_type"] = PlacesUtils.bookmarks.TYPE_BOOKMARK;
     cleanupStatements.push(deleteBogusTagChildren);
 
     // D.3 remove empty tags
-    let deleteEmptyTags = DBConn.createAsyncStatement(
+    let deleteEmptyTags = DBConn.createStatement(
       "DELETE FROM moz_bookmarks WHERE id NOT IN ( " +
         "SELECT folder_id FROM moz_bookmarks_roots " + // skip roots
       ") AND id IN (" +
         "SELECT b.id FROM moz_bookmarks b " +
         "WHERE b.id IN " +
           "(SELECT id FROM moz_bookmarks WHERE parent = :tags_folder) " +
           "AND NOT EXISTS " +
             "(SELECT id from moz_bookmarks WHERE parent = b.id LIMIT 1) " +
       ")");
     deleteEmptyTags.params["tags_folder"] = PlacesUtils.tagsFolderId;
     cleanupStatements.push(deleteEmptyTags);
 
     // D.4 move orphan items to unsorted folder
-    let fixOrphanItems = DBConn.createAsyncStatement(
+    let fixOrphanItems = DBConn.createStatement(
       "UPDATE moz_bookmarks SET parent = :unsorted_folder WHERE id NOT IN ( " +
         "SELECT folder_id FROM moz_bookmarks_roots " +  // skip roots
       ") AND id IN (" +
         "SELECT b.id FROM moz_bookmarks b " +
         "WHERE b.parent <> 0 " + // exclude Places root
         "AND NOT EXISTS " +
           "(SELECT id FROM moz_bookmarks WHERE id = b.parent LIMIT 1) " +
       ")");
     fixOrphanItems.params["unsorted_folder"] = PlacesUtils.unfiledBookmarksFolderId;
     cleanupStatements.push(fixOrphanItems);
 
     // D.5 fix wrong keywords
-    let fixInvalidKeywords = DBConn.createAsyncStatement(
+    let fixInvalidKeywords = DBConn.createStatement(
       "UPDATE moz_bookmarks SET keyword_id = NULL WHERE id NOT IN ( " +
         "SELECT folder_id FROM moz_bookmarks_roots " + // skip roots
       ") AND id IN ( " +
         "SELECT id FROM moz_bookmarks b " +
         "WHERE keyword_id NOT NULL " +
           "AND NOT EXISTS " +
             "(SELECT id FROM moz_keywords WHERE id = b.keyword_id LIMIT 1) " +
       ")");
     cleanupStatements.push(fixInvalidKeywords);
 
     // D.6 fix wrong item types
     //     Folders, separators and dynamic containers should not have an fk.
     //     If they have a valid fk convert them to bookmarks. Later in D.9 we
     //     will move eventual children to unsorted bookmarks.
-    let fixBookmarksAsFolders = DBConn.createAsyncStatement(
+    let fixBookmarksAsFolders = DBConn.createStatement(
       "UPDATE moz_bookmarks SET type = :bookmark_type WHERE id NOT IN ( " +
         "SELECT folder_id FROM moz_bookmarks_roots " + // skip roots
       ") AND id IN ( " +
         "SELECT id FROM moz_bookmarks b " +
         "WHERE type IN (:folder_type, :separator_type, :dynamic_type) " +
           "AND fk NOTNULL " +
       ")");
     fixBookmarksAsFolders.params["bookmark_type"] = PlacesUtils.bookmarks.TYPE_BOOKMARK;
     fixBookmarksAsFolders.params["folder_type"] = PlacesUtils.bookmarks.TYPE_FOLDER;
     fixBookmarksAsFolders.params["separator_type"] = PlacesUtils.bookmarks.TYPE_SEPARATOR;
     fixBookmarksAsFolders.params["dynamic_type"] = PlacesUtils.bookmarks.TYPE_DYNAMIC_CONTAINER;
     cleanupStatements.push(fixBookmarksAsFolders);
 
     // D.7 fix wrong item types
     //     Bookmarks should have an fk, if they don't have any, convert them to
     //     folders.
-    let fixFoldersAsBookmarks = DBConn.createAsyncStatement(
+    let fixFoldersAsBookmarks = DBConn.createStatement(
       "UPDATE moz_bookmarks SET type = :folder_type WHERE id NOT IN ( " +
         "SELECT folder_id FROM moz_bookmarks_roots " + // skip roots
       ") AND id IN ( " +
         "SELECT id FROM moz_bookmarks b " +
         "WHERE type = :bookmark_type " +
           "AND fk IS NULL " +
       ")");
     fixFoldersAsBookmarks.params["bookmark_type"] = PlacesUtils.bookmarks.TYPE_BOOKMARK;
     fixFoldersAsBookmarks.params["folder_type"] = PlacesUtils.bookmarks.TYPE_FOLDER;
     cleanupStatements.push(fixFoldersAsBookmarks);
 
     // D.8 fix wrong item types
     //     Dynamic containers should have a folder_type, if they don't have any
     //     convert them to folders.
-    let fixFoldersAsDynamic = DBConn.createAsyncStatement(
+    let fixFoldersAsDynamic = DBConn.createStatement(
       "UPDATE moz_bookmarks SET type = :folder_type WHERE id NOT IN ( " +
         "SELECT folder_id FROM moz_bookmarks_roots " + // skip roots
       ") AND id IN ( " +
         "SELECT id FROM moz_bookmarks b " +
         "WHERE type = :dynamic_type " +
           "AND folder_type IS NULL " +
       ")");
     fixFoldersAsDynamic.params["dynamic_type"] = PlacesUtils.bookmarks.TYPE_DYNAMIC_CONTAINER;
     fixFoldersAsDynamic.params["folder_type"] = PlacesUtils.bookmarks.TYPE_FOLDER;
     cleanupStatements.push(fixFoldersAsDynamic);
 
     // D.9 fix wrong parents
     //     Items cannot have dynamic containers, separators or other bookmarks
     //     as parent, if they have bad parent move them to unsorted bookmarks.
-    let fixInvalidParents = DBConn.createAsyncStatement(
+    let fixInvalidParents = DBConn.createStatement(
       "UPDATE moz_bookmarks SET parent = :unsorted_folder WHERE id NOT IN ( " +
         "SELECT folder_id FROM moz_bookmarks_roots " +  // skip roots
       ") AND id IN ( " +
         "SELECT id FROM moz_bookmarks b " +
         "WHERE EXISTS " +
           "(SELECT id FROM moz_bookmarks WHERE id = b.parent " +
             "AND type IN (:bookmark_type, :separator_type, :dynamic_type) " +
             "LIMIT 1) " +
       ")");
     fixInvalidParents.params["unsorted_folder"] = PlacesUtils.unfiledBookmarksFolderId;
     fixInvalidParents.params["bookmark_type"] = PlacesUtils.bookmarks.TYPE_BOOKMARK;
     fixInvalidParents.params["separator_type"] = PlacesUtils.bookmarks.TYPE_SEPARATOR;
     fixInvalidParents.params["dynamic_type"] = PlacesUtils.bookmarks.TYPE_DYNAMIC_CONTAINER;
     cleanupStatements.push(fixInvalidParents);
 
+/* XXX needs test
     // D.10 recalculate positions
     //      This requires multiple related statements.
     //      We can detect a folder with bad position values comparing the sum of
-    //      all distinct position values (+1 since position is 0-based) with the
-    //      triangular numbers obtained by the number of children (n).
-    //      SUM(DISTINCT position + 1) == (n * (n + 1) / 2).
-    cleanupStatements.push(DBConn.createAsyncStatement(
-      "CREATE TEMP TABLE moz_bookmarks_reposition_temp ( " +
-        "  id INTEGER PRIMARY_KEY " +
-        ", position INTEGER " +
-      ") "
-    ));
-    cleanupStatements.push(DBConn.createAsyncStatement(
-      "INSERT INTO moz_bookmarks_reposition_temp " +
-        "SELECT id, (" +
-            "(SELECT count(*) FROM moz_bookmarks " +
-             "WHERE parent = b.parent " +
-               "AND position < b.position) + " +
-            "(SELECT count(*) FROM moz_bookmarks  " +
-             "WHERE parent = b.parent " +
-               "AND position == b.position " +
-               "AND ROWID < b.ROWID) " +
-          ") AS reposition " +
-        "FROM moz_bookmarks b " +
-        "WHERE parent IN (" +
-          "SELECT parent FROM " +
-            "(SELECT parent, " +
-                    "(SUM(DISTINCT position + 1) - (count(*) * (count(*) + 1) / 2)) AS diff " +
-            "FROM moz_bookmarks " +
-            "GROUP BY parent) " +
-          "WHERE diff <> 0" +
-        ") "
-    ));
-    cleanupStatements.push(DBConn.createAsyncStatement(
-      "UPDATE moz_bookmarks SET position = " +
-        "(SELECT position FROM moz_bookmarks_reposition_temp " +
-         "WHERE id = moz_bookmarks.id) " +
-      "WHERE id IN (SELECT id FROM moz_bookmarks_reposition_temp) "
-    ));
-    cleanupStatements.push(DBConn.createAsyncStatement(
-      "DROP TABLE moz_bookmarks_reposition_temp"
-    ));
+    //      all position values with the triangular numbers obtained by the number
+    //      of children: (n * (n + 1) / 2). Starting from 0 is (n * (n - 1) / 2).
+    let detectWrongPositionsParents = DBConn.createStatement(
+      "SELECT parent FROM " +
+        "(SELECT parent, " +
+                "(SUM(position) - (count(*) * (count(*) - 1) / 2)) AS diff " +
+        "FROM moz_bookmarks " +
+        "GROUP BY parent) " +
+      "WHERE diff <> 0");
+    while (detectWrongPositionsParents.executeStep()) {
+      let parent = detectWrongPositionsParents.getInt64(0);
+      // We will lose the previous position values and reposition items based
+      // on the ROWID value. Not perfect, but we can't rely on position values.
+      let fixPositionsForParent = DBConn.createStatement(
+        "UPDATE moz_bookmarks SET position = ( " +
+          "SELECT " +
+          "((SELECT count(*) FROM moz_bookmarks WHERE parent = :parent) - " +
+           "(SELECT count(*) FROM moz_bookmarks " +
+            "WHERE parent = :parent AND ROWID >= b.ROWID)) " +
+          "FROM moz_bookmarks b WHERE parent = :parent AND id = moz_bookmarks.id " +
+        ") WHERE parent = :parent");
+      fixPositionsForParent.params["parent"] = parent;
+      cleanupStatements.push(fixPositionsForParent);
+    }
+*/
 
     // D.11 remove old livemarks status items
     //      Livemark status items are now static but some livemark has still old
     //      status items bookmarks inside it. We should remove them.
-    let removeLivemarkStaticItems = DBConn.createAsyncStatement(
+    let removeLivemarkStaticItems = DBConn.createStatement(
       "DELETE FROM moz_bookmarks WHERE type = :bookmark_type AND fk IN ( " +
         "SELECT id FROM moz_places WHERE url = :lmloading OR url = :lmfailed " +
       ")");
     removeLivemarkStaticItems.params["bookmark_type"] = PlacesUtils.bookmarks.TYPE_BOOKMARK;
     removeLivemarkStaticItems.params["lmloading"] = "about:livemark-loading";
     removeLivemarkStaticItems.params["lmfailed"] = "about:livemark-failed";
     cleanupStatements.push(removeLivemarkStaticItems);
 
     // D.12 Fix empty-named tags.
     //      Tags were allowed to have empty names due to a UI bug.  Fix them
     //      replacing their title with "(notitle)".
-    let fixEmptyNamedTags = DBConn.createAsyncStatement(
+    let fixEmptyNamedTags = DBConn.createStatement(
       "UPDATE moz_bookmarks SET title = :empty_title " +
       "WHERE length(title) = 0 AND type = :folder_type " +
         "AND parent = :tags_folder"
     );
     fixEmptyNamedTags.params["empty_title"] = "(notitle)";
     fixEmptyNamedTags.params["folder_type"] = PlacesUtils.bookmarks.TYPE_FOLDER;
     fixEmptyNamedTags.params["tags_folder"] = PlacesUtils.tagsFolderId;
     cleanupStatements.push(fixEmptyNamedTags);
 
     // MOZ_FAVICONS
     // E.1 remove orphan icons
-    let deleteOrphanIcons = DBConn.createAsyncStatement(
+    let deleteOrphanIcons = DBConn.createStatement(
       "DELETE FROM moz_favicons WHERE id IN (" +
         "SELECT id FROM moz_favicons f " +
         "WHERE NOT EXISTS " +
           "(SELECT id FROM moz_places WHERE favicon_id = f.id LIMIT 1) " +
       ")");
     cleanupStatements.push(deleteOrphanIcons);
 
     // MOZ_HISTORYVISITS
     // F.1 remove orphan visits
-    let deleteOrphanVisits = DBConn.createAsyncStatement(
+    let deleteOrphanVisits = DBConn.createStatement(
       "DELETE FROM moz_historyvisits WHERE id IN (" +
         "SELECT id FROM moz_historyvisits v " +
         "WHERE NOT EXISTS " +
           "(SELECT id FROM moz_places WHERE id = v.place_id LIMIT 1) " +
       ")");
     cleanupStatements.push(deleteOrphanVisits);
 
     // MOZ_INPUTHISTORY
     // G.1 remove orphan input history
-    let deleteOrphanInputHistory = DBConn.createAsyncStatement(
+    let deleteOrphanInputHistory = DBConn.createStatement(
       "DELETE FROM moz_inputhistory WHERE place_id IN (" +
         "SELECT place_id FROM moz_inputhistory i " +
         "WHERE NOT EXISTS " +
           "(SELECT id FROM moz_places WHERE id = i.place_id LIMIT 1) " +
       ")");
     cleanupStatements.push(deleteOrphanInputHistory);
 
     // MOZ_ITEMS_ANNOS
     // H.1 remove item annos with an invalid attribute
-    let deleteInvalidAttributeItemsAnnos = DBConn.createAsyncStatement(
+    let deleteInvalidAttributeItemsAnnos = DBConn.createStatement(
       "DELETE FROM moz_items_annos WHERE id IN ( " +
         "SELECT id FROM moz_items_annos t " +
         "WHERE NOT EXISTS " +
           "(SELECT id FROM moz_anno_attributes " +
             "WHERE id = t.anno_attribute_id LIMIT 1) " +
       ")");
     cleanupStatements.push(deleteInvalidAttributeItemsAnnos);
 
     // H.2 remove orphan item annos
-    let deleteOrphanItemsAnnos = DBConn.createAsyncStatement(
+    let deleteOrphanItemsAnnos = DBConn.createStatement(
       "DELETE FROM moz_items_annos WHERE id IN ( " +
         "SELECT id FROM moz_items_annos t " +
         "WHERE NOT EXISTS " +
           "(SELECT id FROM moz_bookmarks WHERE id = t.item_id LIMIT 1) " +
       ")");
     cleanupStatements.push(deleteOrphanItemsAnnos);
 
     // MOZ_KEYWORDS
     // I.1 remove unused keywords
-    let deleteUnusedKeywords = DBConn.createAsyncStatement(
+    let deleteUnusedKeywords = DBConn.createStatement(
       "DELETE FROM moz_keywords WHERE id IN ( " +
         "SELECT id FROM moz_keywords k " +
         "WHERE NOT EXISTS " +
           "(SELECT id FROM moz_bookmarks WHERE keyword_id = k.id LIMIT 1) " +
       ")");
     cleanupStatements.push(deleteUnusedKeywords);
 
     // MOZ_PLACES
     // L.1 fix wrong favicon ids
-    let fixInvalidFaviconIds = DBConn.createAsyncStatement(
+    let fixInvalidFaviconIds = DBConn.createStatement(
       "UPDATE moz_places SET favicon_id = NULL WHERE id IN ( " +
         "SELECT id FROM moz_places h " +
         "WHERE favicon_id NOT NULL " +
           "AND NOT EXISTS " +
             "(SELECT id FROM moz_favicons WHERE id = h.favicon_id LIMIT 1) " +
       ")");
     cleanupStatements.push(fixInvalidFaviconIds);
 
--- a/toolkit/components/places/tests/unit/test_preventive_maintenance.js
+++ b/toolkit/components/places/tests/unit/test_preventive_maintenance.js
@@ -689,84 +689,27 @@ tests.push({
     stmt.params["item_id"] = this._bookmarkId3;
     stmt.params["parent"] = bs.unfiledBookmarksFolder;
     do_check_true(stmt.executeStep());
     stmt.finalize();    
   }
 });
 
 //------------------------------------------------------------------------------
-
+//XXX TODO
 tests.push({
   name: "D.10",
   desc: "Recalculate positions",
 
-  _bookmarks: [],
-
   setup: function() {
-    const NUM_BOOKMARKS = 30;
-    bs.runInBatchMode({
-      runBatched: function (aUserData) {
-        for (let i = 0; i < NUM_BOOKMARKS; i++) {
-          bs.insertBookmark(PlacesUtils.unfiledBookmarksFolderId,
-                            NetUtil.newURI("http://example.com/"),
-                            bs.DEFAULT_INDEX, "testbookmark");
-        }
-      }
-    }, null);
 
-    // Set random positions for the added bookmarks.
-    let stmt = mDBConn.createStatement(
-      "UPDATE moz_bookmarks SET position = :rand " +
-      "WHERE id IN ( " +
-        "SELECT id FROM moz_bookmarks WHERE parent = :unfiled " +
-        "ORDER BY RANDOM() LIMIT 1 " +
-      ") "
-    );
-    for (let i = 0; i < (NUM_BOOKMARKS / 2); i++) {
-      stmt.params["unfiled"] = PlacesUtils.unfiledBookmarksFolderId;
-      stmt.params["rand"] = Math.round(Math.random() * (NUM_BOOKMARKS - 1));
-      stmt.execute();
-      stmt.reset();
-    }
-    stmt.finalize();
-
-    // Build the expected ordered list of bookmarks.
-    stmt = mDBConn.createStatement(
-      "SELECT id, position " +
-      "FROM moz_bookmarks WHERE parent = :unfiled " +
-      "ORDER BY position ASC, ROWID ASC "
-    );
-    stmt.params["unfiled"] = PlacesUtils.unfiledBookmarksFolderId;
-    while (stmt.executeStep()) {
-      this._bookmarks.push(stmt.row.id);
-      print(stmt.row.id + "\t" + stmt.row.position + "\t" + (this._bookmarks.length - 1));
-    }
-    stmt.finalize();
   },
 
   check: function() {
-    // Build the expected ordered list of bookmarks.
-    let stmt = mDBConn.createStatement(
-      "SELECT id, position FROM moz_bookmarks WHERE parent = :unfiled " +
-      "ORDER BY position ASC"
-    );
-    stmt.params["unfiled"] = PlacesUtils.unfiledBookmarksFolderId;
-    let pass = true;
-    while (stmt.executeStep()) {
-      print(stmt.row.id + "\t" + stmt.row.position);
-      if (this._bookmarks.indexOf(stmt.row.id) != stmt.row.position) {
-        pass = false;
-      }
-    }
-    if (!pass) {
-      dump_table("moz_bookmarks");
-      do_throw("Unexpected bookmarks order.");
-    }
-    stmt.finalize();
+
   }
 });
 
 //------------------------------------------------------------------------------
 
 tests.push({
   name: "D.11",
   desc: "Remove old livemarks status items",