Dactyloidae iOS initial commit

mobile/ios/Storage/SQL/SQLiteBookmarksModel.swift

@@ -0,0 +1,948 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+import Deferred
+import Foundation
+import Shared
+
+private let log = Logger.syncLogger
+private let desktopBookmarksLabel: String = NSLocalizedString("Desktop Bookmarks", tableName: "BookmarkPanel", comment: "The folder name for the virtual folder that contains all desktop bookmarks.")
+
+public enum Direction {
+    case buffer
+    case local
+
+    var structureTable: String {
+        switch self {
+        case .local:
+            return TableBookmarksLocalStructure
+        case .buffer:
+            return TableBookmarksBufferStructure
+        }
+    }
+
+    var valueTable: String {
+        switch self {
+        case .local:
+            return TableBookmarksLocal
+        case .buffer:
+            return TableBookmarksBuffer
+        }
+    }
+
+    var valueView: String {
+        switch self {
+        case .local:
+            return ViewBookmarksLocalOnMirror
+        case .buffer:
+            return ViewBookmarksBufferWithDeletionsOnMirror
+        }
+    }
+
+    var structureView: String {
+        switch self {
+        case .local:
+            return ViewBookmarksLocalStructureOnMirror
+        case .buffer:
+            return ViewBookmarksBufferStructureOnMirror
+        }
+    }
+}
+
+public protocol KeywordSearchSource {
+    func getURLForKeywordSearch(_ keyword: String) -> Deferred<Maybe<String>>
+}
+
+open class SQLiteBookmarksModelFactory: BookmarksModelFactory {
+    fileprivate let bookmarks: SQLiteBookmarks
+    fileprivate let direction: Direction
+
+    public init(bookmarks: SQLiteBookmarks, direction: Direction) {
+        self.bookmarks = bookmarks
+        self.direction = direction
+    }
+
+    public func factoryForIndex(_ index: Int, inFolder folder: BookmarkFolder) -> BookmarksModelFactory {
+        return self
+    }
+
+    fileprivate func withDifferentDirection(_ direction: Direction) -> SQLiteBookmarksModelFactory {
+        if self.direction == direction {
+            return self
+        }
+        return SQLiteBookmarksModelFactory(bookmarks: self.bookmarks, direction: direction)
+    }
+
+    fileprivate func getChildrenWithParent(_ parentGUID: GUID, excludingGUIDs: [GUID]?=nil, includeIcon: Bool) -> Deferred<Maybe<Cursor<BookmarkNode>>> {
+        return self.bookmarks.getChildrenWithParent(parentGUID, direction: self.direction, excludingGUIDs: excludingGUIDs, includeIcon: includeIcon)
+    }
+
+    fileprivate func getRootChildren() -> Deferred<Maybe<Cursor<BookmarkNode>>> {
+        return self.getChildrenWithParent(BookmarkRoots.RootGUID, excludingGUIDs: [BookmarkRoots.RootGUID], includeIcon: true)
+    }
+
+    fileprivate func getChildren(_ guid: String) -> Deferred<Maybe<Cursor<BookmarkNode>>> {
+        return self.getChildrenWithParent(guid, includeIcon: true)
+    }
+
+    func folderForGUID(_ guid: GUID, title: String) -> Deferred<Maybe<BookmarkFolder>> {
+        return self.getChildren(guid)
+            >>== { cursor in
+
+            if cursor.status == .failure {
+                return deferMaybe(DatabaseError(description: "Couldn't get children: \(cursor.statusMessage)."))
+            }
+
+            return deferMaybe(SQLiteBookmarkFolder(guid: guid, title: title, children: cursor))
+        }
+    }
+
+    fileprivate func modelWithRoot(_ root: BookmarkFolder) -> Deferred<Maybe<BookmarksModel>> {
+        return deferMaybe(BookmarksModel(modelFactory: self, root: root))
+    }
+
+    open func modelForFolder(_ guid: String, title: String) -> Deferred<Maybe<BookmarksModel>> {
+        if guid == BookmarkRoots.MobileFolderGUID {
+            return self.modelForRoot()
+        }
+
+        if guid == BookmarkRoots.FakeDesktopFolderGUID {
+            return self.modelForDesktopBookmarks()
+        }
+
+        let outputTitle = titleForSpecialGUID(guid) ?? title
+        return self.folderForGUID(guid, title: outputTitle)
+          >>== self.modelWithRoot
+    }
+
+    open func modelForFolder(_ folder: BookmarkFolder) -> Deferred<Maybe<BookmarksModel>> {
+        return self.modelForFolder(folder.guid, title: folder.title)
+    }
+
+    open func modelForFolder(_ guid: String) -> Deferred<Maybe<BookmarksModel>> {
+        return self.modelForFolder(guid, title: "")
+    }
+
+    open func modelForRoot() -> Deferred<Maybe<BookmarksModel>> {
+        log.debug("Getting model for root.")
+        let getFolder = self.folderForGUID(BookmarkRoots.MobileFolderGUID, title: BookmarksFolderTitleMobile)
+        if self.direction == .buffer {
+            return getFolder >>== self.modelWithRoot
+        }
+
+        // Return a virtual model containing "Desktop bookmarks" prepended to the local mobile bookmarks.
+        return getFolder >>== { folder in
+            self.extendWithDesktopBookmarksFolder(folder, factory: self)
+        }
+    }
+
+    open var nullModel: BookmarksModel {
+        let children = Cursor<BookmarkNode>(status: .failure, msg: "Null model")
+        let folder = SQLiteBookmarkFolder(guid: "Null", title: "Null", children: children)
+        return BookmarksModel(modelFactory: self, root: folder)
+    }
+
+    open func isBookmarked(_ url: String) -> Deferred<Maybe<Bool>> {
+        return self.bookmarks.isBookmarked(url, direction: self.direction)
+    }
+
+    open func removeByURL(_ url: String) -> Success {
+        if self.direction == Direction.buffer {
+            return deferMaybe(DatabaseError(description: "Refusing to remove URL from buffer in model."))
+        }
+
+        // Find all of the records for the provided URL. Don't bother with
+        // any that are already deleted!
+        return self.bookmarks.nonDeletedGUIDsForURL(url)
+          >>== self.bookmarks.removeGUIDs
+    }
+
+    open func removeByGUID(_ guid: GUID) -> Success {
+        if self.direction == Direction.buffer {
+            return deferMaybe(DatabaseError(description: "Refusing to remove GUID from buffer in model."))
+        }
+
+        log.debug("removeByGUID: \(guid)")
+        return self.bookmarks.removeGUIDs([guid])
+    }
+
+    func hasDesktopBookmarks() -> Deferred<Maybe<Bool>> {
+        // This is very lazy, but it has the nice property of keeping Desktop Bookmarks visible
+        // for a while after you mark the last desktop child as deleted.
+        let parents: Args = [
+            // Local.
+            BookmarkRoots.MenuFolderGUID,
+            BookmarkRoots.ToolbarFolderGUID,
+            BookmarkRoots.UnfiledFolderGUID,
+
+            // Mirror.
+            BookmarkRoots.MenuFolderGUID,
+            BookmarkRoots.ToolbarFolderGUID,
+            BookmarkRoots.UnfiledFolderGUID,
+        ]
+
+        let sql =
+        "SELECT 1 FROM \(self.direction.structureTable) WHERE parent IN (?, ?, ?)" +
+        " UNION ALL " +
+        "SELECT 1 FROM \(TableBookmarksMirrorStructure) WHERE parent IN (?, ?, ?)" +
+        " LIMIT 1"
+
+        return self.bookmarks.db.queryReturnsResults(sql, args: parents)
+    }
+
+    func getDesktopRoots() -> Deferred<Maybe<Cursor<BookmarkNode>>> {
+        if self.direction == .buffer {
+            // DesktopRoots excludes the Mobile folder, local and non-local mobile are aggregated
+            return self.bookmarks.getRecordsWithGUIDs(BookmarkRoots.DesktopRoots, direction: self.direction, includeIcon: false)
+        }
+
+        // We deliberately exclude the mobile folder, because we're inverting the containment
+        // relationship here.
+        let exclude = [BookmarkRoots.MobileFolderGUID, BookmarkRoots.RootGUID]
+        return self.getChildrenWithParent(BookmarkRoots.RootGUID, excludingGUIDs: exclude, includeIcon: false)
+    }
+
+    /**
+     * Prepend the provided mobile bookmarks folder with a single folder.
+     * The prepended folder is "Desktop Bookmarks". It contains mirrored folders.
+     */
+    open func extendWithDesktopBookmarksFolder(_ mobile: BookmarkFolder, factory: BookmarksModelFactory) -> Deferred<Maybe<BookmarksModel>> {
+
+        func onlyMobile() -> Deferred<Maybe<BookmarksModel>> {
+            // No desktop bookmarks.
+            log.debug("No desktop bookmarks. Only showing mobile.")
+            return deferMaybe(BookmarksModel(modelFactory: factory, root: mobile))
+        }
+
+        return self.hasDesktopBookmarks() >>== { yes in
+            if !yes {
+                return onlyMobile()
+            }
+
+            return self.getDesktopRoots() >>== { cursor in
+                if cursor.count == 0 {
+                    // This shouldn't occur.
+                    return onlyMobile()
+                }
+
+                let desktop = self.folderForDesktopBookmarksCursor(cursor)
+                let prepended = PrependedBookmarkFolder(main: mobile, prepend: desktop)
+                return deferMaybe(BookmarksModel(modelFactory: factory, root: prepended))
+            }
+        }
+    }
+
+    fileprivate func modelForDesktopBookmarks() -> Deferred<Maybe<BookmarksModel>> {
+        return self.getDesktopRoots() >>== { cursor in
+            let desktop = self.folderForDesktopBookmarksCursor(cursor)
+            return deferMaybe(BookmarksModel(modelFactory: self, root: desktop))
+        }
+    }
+
+    fileprivate func folderForDesktopBookmarksCursor(_ cursor: Cursor<BookmarkNode>) -> SQLiteBookmarkFolder {
+        return SQLiteBookmarkFolder(guid: BookmarkRoots.FakeDesktopFolderGUID, title: desktopBookmarksLabel, children: cursor)
+    }
+}
+
+class EditableBufferBookmarksSQLiteBookmarksModelFactory: SQLiteBookmarksModelFactory {
+    override func getChildrenWithParent(_ parentGUID: GUID, excludingGUIDs: [GUID]?, includeIcon: Bool) -> Deferred<Maybe<Cursor<BookmarkNode>>> {
+        if parentGUID == BookmarkRoots.MobileFolderGUID {
+            return self.bookmarks.getChildrenWithParent(parentGUID, direction: self.direction, excludingGUIDs: excludingGUIDs, includeIcon: includeIcon, factory: BookmarkFactory.editableItemsFactory)
+        }
+        return super.getChildrenWithParent(parentGUID, excludingGUIDs: excludingGUIDs, includeIcon: includeIcon)
+    }
+
+    override func removeByGUID(_ guid: GUID) -> Success {
+        log.debug("Removing \(guid) from buffer.")
+        return self.bookmarks.markBufferBookmarkAsDeleted(guid)
+    }
+}
+
+private func isEditableExpression(_ direction: Direction) -> String {
+    if direction == .buffer {
+        return "0"
+    }
+
+    return "SELECT exists( " +
+           "   SELECT exists(SELECT 1 FROM \(TableBookmarksBuffer)) AS hasBuffer, exists(SELECT 1 FROM \(TableBookmarksMirror)) AS hasMirror " +
+           "   WHERE hasBuffer IS 0 OR hasMirror IS 0" +
+           ")"
+}
+
+extension SQLiteBookmarks {
+
+    fileprivate func getRecordsWithGUIDs(_ guids: [GUID], direction: Direction, includeIcon: Bool) -> Deferred<Maybe<Cursor<BookmarkNode>>> {
+
+        let args: Args = guids
+        let varlist = BrowserDB.varlist(args.count)
+        let values =
+        "SELECT -1 AS id, guid, type, date_added, is_deleted, parentid, parentName, feedUri, pos, title, bmkUri, siteUri, folderName, faviconID, (\(isEditableExpression(direction))) AS isEditable " +
+        "FROM \(direction.valueView) WHERE guid IN \(varlist) AND NOT is_deleted"
+
+        let withIcon = [
+            "SELECT bookmarks.id AS id, bookmarks.guid AS guid, bookmarks.type AS type,",
+            "       bookmarks.date_added AS date_added,",
+            "       bookmarks.is_deleted AS is_deleted,",
+            "       bookmarks.parentid AS parentid, bookmarks.parentName AS parentName,",
+            "       bookmarks.feedUri AS feedUri, bookmarks.pos AS pos, title AS title,",
+            "       bookmarks.bmkUri AS bmkUri, bookmarks.siteUri AS siteUri,",
+            "       bookmarks.folderName AS folderName,",
+            "       bookmarks.isEditable AS isEditable,",
+            "       favicons.url AS iconURL, favicons.date AS iconDate, favicons.type AS iconType",
+            "FROM (", values, ") AS bookmarks",
+            "LEFT OUTER JOIN favicons ON bookmarks.faviconID = favicons.id",
+            "ORDER BY title ASC",
+            ].joined(separator: " ")
+
+        let sql = (includeIcon ? withIcon : values) + " ORDER BY title ASC"
+        return self.db.runQuery(sql, args: args, factory: BookmarkFactory.factory)
+    }
+
+    /**
+     * Return the children of the provided parent.
+     * Rows are ordered by positional index.
+     * This method is aware of is_overridden and deletion, using local override structure by preference.
+     * Note that a folder can be empty locally; we thus use the flag rather than looking at the structure itself.
+     */
+    func getChildrenWithParent(_ parentGUID: GUID, direction: Direction, excludingGUIDs: [GUID]?=nil, includeIcon: Bool, factory: @escaping (SDRow) -> BookmarkNode = BookmarkFactory.factory) -> Deferred<Maybe<Cursor<BookmarkNode>>> {
+
+        precondition((excludingGUIDs ?? []).count < 100, "Sanity bound for the number of GUIDs we can exclude.")
+
+        let valueView = direction.valueView
+        let structureView = direction.structureView
+
+        let structure =
+        "SELECT parent, child AS guid, idx FROM \(structureView) " +
+        "WHERE parent = ?"
+
+        let values =
+        "SELECT -1 AS id, guid, type, date_added, is_deleted, parentid, parentName, feedUri, pos, title, bmkUri, siteUri, folderName, faviconID, (\(isEditableExpression(direction))) AS isEditable " +
+        "FROM \(valueView)"
+
+        // We exclude queries and dynamic containers, because we can't
+        // usefully display them.
+        let typeQuery = BookmarkNodeType.query.rawValue
+        let typeDynamic = BookmarkNodeType.dynamicContainer.rawValue
+        let typeFilter = " vals.type NOT IN (\(typeQuery), \(typeDynamic))"
+
+        let args: Args
+        let exclusion: String
+        if let excludingGUIDs = excludingGUIDs {
+            args = ([parentGUID] + excludingGUIDs).map { $0 }
+            exclusion = "\(typeFilter) AND vals.guid NOT IN " + BrowserDB.varlist(excludingGUIDs.count)
+        } else {
+            args = [parentGUID]
+            exclusion = typeFilter
+        }
+
+        let fleshed =
+        "SELECT vals.id AS id, vals.guid AS guid, vals.type AS type, vals.date_added AS date_added, vals.is_deleted AS is_deleted, " +
+        "       vals.parentid AS parentid, vals.parentName AS parentName, vals.feedUri AS feedUri, " +
+        "       vals.siteUri AS siteUri," +
+        "       vals.pos AS pos, vals.title AS title, vals.bmkUri AS bmkUri, vals.folderName AS folderName, " +
+        "       vals.faviconID AS faviconID, " +
+        "       vals.isEditable AS isEditable, " +
+        "       structure.idx AS idx, " +
+        "       structure.parent AS _parent " +
+        "FROM (\(structure)) AS structure JOIN (\(values)) AS vals " +
+        "ON vals.guid = structure.guid " +
+        "WHERE " + exclusion
+
+        let withIcon =
+        "SELECT bookmarks.id AS id, bookmarks.guid AS guid, bookmarks.type AS type, " +
+        "       bookmarks.date_added AS date_added, " +
+        "       bookmarks.is_deleted AS is_deleted, " +
+        "       bookmarks.parentid AS parentid, bookmarks.parentName AS parentName, " +
+        "       bookmarks.feedUri AS feedUri, bookmarks.siteUri AS siteUri, " +
+        "       bookmarks.pos AS pos, title AS title, " +
+        "       bookmarks.bmkUri AS bmkUri, bookmarks.folderName AS folderName, " +
+        "       bookmarks.idx AS idx, bookmarks._parent AS _parent, " +
+        "       bookmarks.isEditable AS isEditable, " +
+        "       favicons.url AS iconURL, favicons.date AS iconDate, favicons.type AS iconType " +
+        "FROM (\(fleshed)) AS bookmarks " +
+        "LEFT OUTER JOIN favicons ON bookmarks.faviconID = favicons.id"
+
+        let sql = (includeIcon ? withIcon : fleshed) + " ORDER BY idx ASC"
+        return self.db.runQuery(sql, args: args, factory: factory)
+    }
+
+    // This is only used from tests.
+    func clearBookmarks() -> Success {
+        log.warning("CALLING clearBookmarks -- this should only be used from tests.")
+        return self.db.run([
+            ("DELETE FROM \(TableBookmarksLocal) WHERE parentid IS NOT ?", [BookmarkRoots.RootGUID]),
+            self.favicons.getCleanupFaviconsQuery()
+        ])
+    }
+
+    public func removeGUIDs(_ guids: [GUID]) -> Success {
+        log.debug("removeGUIDs: \(guids)")
+
+        // Override any parents that aren't already overridden. We're about to remove some
+        // of their children.
+        return self.overrideParentsOfGUIDs(guids)
+
+        // Find, recursively, any children of the provided GUIDs. This will only be the case
+        // if you specify folders. This is a special case because we're removing *all*
+        // children, so we don't need to do the reindexing dance.
+           >>> { self.deleteChildrenOfGUIDs(guids) }
+
+        // Override any records that aren't already overridden.
+           >>> { self.overrideGUIDs(guids) }
+
+        // Then delete the already-overridden records. We do this one at a time in order
+        // to get indices correct in edge cases. (We do bulk-delete their children
+        // one layer at a time, at least.)
+           >>> { walk(guids, f: self.removeLocalByGUID) }
+    }
+
+    fileprivate func nonDeletedGUIDsForURL(_ url: String) -> Deferred<Maybe<([GUID])>> {
+        let sql = "SELECT DISTINCT guid FROM \(ViewBookmarksLocalOnMirror) WHERE bmkUri = ? AND is_deleted = 0"
+        let args: Args = [url]
+
+        return self.db.runQuery(sql, args: args, factory: { $0[0] as! GUID }) >>== { guids in
+            return deferMaybe(guids.asArray())
+        }
+    }
+
+    fileprivate func overrideParentsOfGUIDs(_ guids: [GUID]) -> Success {
+        log.debug("Overriding parents of \(guids).")
+
+        // TODO: Yes, this can be done in one go.
+        let getParentsSQL =
+        "SELECT DISTINCT parent FROM \(ViewBookmarksLocalStructureOnMirror) " +
+        "WHERE child IN \(BrowserDB.varlist(guids.count)) AND is_overridden = 0"
+        let getParentsArgs: Args = guids
+
+        return self.db.runQuery(getParentsSQL, args: getParentsArgs, factory: { $0[0] as! GUID })
+            >>== { parentsCursor in
+                let parents = parentsCursor.asArray()
+                log.debug("Overriding parents: \(parents).")
+                let (sql, args) = self.getSQLToOverrideFolders(parents, atModifiedTime: Date.now())
+                return self.db.run(sql.map { ($0, args) })
+        }
+    }
+
+    fileprivate func overrideGUIDs(_ guids: [GUID]) -> Success {
+        log.debug("Overriding GUIDs: \(guids).")
+        let (sql, args) = self.getSQLToOverrideNonFolders(guids, atModifiedTime: Date.now())
+        return self.db.run(sql.map { ($0, args) })
+    }
+
+    // Recursive.
+    fileprivate func deleteChildrenOfGUIDs(_ guids: [GUID]) -> Success {
+        if guids.isEmpty {
+            return succeed()
+        }
+
+        precondition(BookmarkRoots.All.intersection(guids).isEmpty, "You can't even touch the roots for removal.")
+
+        log.debug("Deleting children of \(guids).")
+
+        let topArgs: Args = guids
+        let topVarlist = BrowserDB.varlist(topArgs.count)
+        let query =
+        "SELECT child FROM \(ViewBookmarksLocalStructureOnMirror) " +
+        "WHERE parent IN \(topVarlist)"
+
+        // We're deleting whole folders, so we don't need to worry about indices.
+        return self.db.runQuery(query, args: topArgs, factory: { $0[0] as! GUID })
+            >>== { children in
+                let childGUIDs = children.asArray()
+                log.debug("… children of \(guids) are \(childGUIDs).")
+
+                if childGUIDs.isEmpty {
+                    log.debug("No children; nothing more to do.")
+                    return succeed()
+                }
+
+                let childArgs: Args = childGUIDs
+                let childVarlist = BrowserDB.varlist(childArgs.count)
+
+                // Mirror the children if they're not already.
+                // We use the non-folder version of this query because we're recursively
+                // destroying structure right after this, so there's no point cloning the
+                // mirror structure.
+                // Then delete the children's children, so we don't leave orphans. This is
+                // recursive, so by the time this succeeds we know that all of these records
+                // have no remaining children.
+                let (overrideSQL, overrideArgs) = self.getSQLToOverrideNonFolders(childGUIDs, atModifiedTime: Date.now())
+
+                return self.deleteChildrenOfGUIDs(childGUIDs)
+                    >>> { self.db.run(overrideSQL.map { ($0, overrideArgs) }) }
+                    >>> {
+                        // Delete the children themselves.
+
+                        // Remove each child from structure. We use the top list to save effort.
+                        let deleteStructure =
+                        "DELETE FROM \(TableBookmarksLocalStructure) WHERE parent IN \(topVarlist)"
+
+                        // If a bookmark is New, delete it outright.
+                        let deleteNew =
+                        "DELETE FROM \(TableBookmarksLocal) WHERE guid IN \(childVarlist) AND sync_status = \(SyncStatus.new.rawValue)"
+
+                        // If a bookmark is Changed, mark it as deleted and bump its modified time.
+                        let markChanged = self.getMarkDeletedSQLWithWhereFragment("guid IN \(childVarlist)")
+
+                        return self.db.run([
+                            (deleteStructure, topArgs),
+                            (deleteNew, childArgs),
+                            (markChanged, childArgs),
+                        ])
+                }
+        }
+    }
+
+    fileprivate func getMarkDeletedSQLWithWhereFragment(_ whereFragment: String) -> String {
+        let sql =
+        "UPDATE \(TableBookmarksLocal) SET" +
+        "  date_added = NULL" +
+        ", is_deleted = 1" +
+        ", local_modified = \(Date.now())" +
+        ", bmkUri = NULL" +
+        ", feedUri = NULL" +
+        ", siteUri = NULL" +
+        ", pos = NULL" +
+        ", title = NULL" +
+        ", tags = NULL" +
+        ", keyword = NULL" +
+        ", description = NULL" +
+        ", parentid = NULL" +
+        ", parentName = NULL" +
+        ", folderName = NULL" +
+        ", queryId = NULL" +
+        " WHERE \(whereFragment) AND sync_status = \(SyncStatus.changed.rawValue)"
+
+        return sql
+    }
+    /**
+     * This depends on the record's parent already being overridden if necessary.
+     */
+    fileprivate func removeLocalByGUID(_ guid: GUID) -> Success {
+        let args: Args = [guid]
+
+        // Find the index we're currently occupying.
+        let previousIndexSubquery = "SELECT idx FROM \(TableBookmarksLocalStructure) WHERE child = ?"
+
+        // Fix up the indices of subsequent siblings.
+        let updateIndices =
+        "UPDATE \(TableBookmarksLocalStructure) SET idx = (idx - 1) WHERE idx > (\(previousIndexSubquery))"
+
+        // If the bookmark is New, delete it outright.
+        let deleteNew =
+        "DELETE FROM \(TableBookmarksLocal) WHERE guid = ? AND sync_status = \(SyncStatus.new.rawValue)"
+
+        // If the bookmark is Changed, mark it as deleted and bump its modified time.
+        let markChanged = self.getMarkDeletedSQLWithWhereFragment("guid = ?")
+
+        // Its parent must be either New or Changed, so we don't need to re-mirror it.
+        // TODO: bump the parent's modified time, because the child list changed?
+
+        // Now delete from structure.
+        let deleteStructure =
+        "DELETE FROM \(TableBookmarksLocalStructure) WHERE child = ?"
+
+        return self.db.run([
+            (updateIndices, args),
+            (deleteNew, args),
+            (markChanged, args),
+            (deleteStructure, args),
+        ])
+    }
+
+    fileprivate func markBufferBookmarkAsDeleted(_ guid: GUID) -> Success {
+        let insertInPendingDeletions =
+        "INSERT OR IGNORE INTO \(TablePendingBookmarksDeletions) " +
+        "(id) " +
+        "VALUES (?)"
+        let args: Args = [guid]
+        return self.db.run(insertInPendingDeletions, withArgs: args)
+    }
+}
+
+class SQLiteBookmarkFolder: BookmarkFolder {
+    fileprivate let cursor: Cursor<BookmarkNode>
+    override var count: Int {
+        return cursor.count
+    }
+
+    override subscript(index: Int) -> BookmarkNode {
+        let bookmark = cursor[index]
+        return bookmark! as BookmarkNode
+    }
+
+    init(guid: String, title: String, children: Cursor<BookmarkNode>) {
+        self.cursor = children
+        super.init(guid: guid, title: title)
+    }
+
+    override func removeItemWithGUID(_ guid: GUID) -> BookmarkFolder? {
+        let without = cursor.asArray().filter { $0.guid != guid }
+        return MemoryBookmarkFolder(guid: self.guid, title: self.title, children: without)
+    }
+}
+
+class BookmarkFactory {
+    fileprivate class func addIcon(_ bookmark: BookmarkNode, row: SDRow) {
+        // TODO: share this logic with SQLiteHistory.
+        if let faviconURL = row["iconURL"] as? String,
+           let date = row["iconDate"] as? Double,
+           let faviconType = row["iconType"] as? Int,
+           let type = IconType(rawValue: faviconType) {
+                bookmark.favicon = Favicon(url: faviconURL,
+                                           date: Date(timeIntervalSince1970: date),
+                                           type: type)
+        }
+    }
+
+    fileprivate class func livemarkFactory(_ row: SDRow) -> BookmarkItem {
+        let id = row["id"] as? Int
+        let guid = row["guid"] as! String
+        let url = row["siteUri"] as! String
+        let title = row["title"] as? String ?? "Livemark"       // TODO
+        let isEditable = row.getBoolean("isEditable")           // Defaults to false.
+        let bookmark = BookmarkItem(guid: guid, title: title, url: url, isEditable: isEditable)
+        bookmark.id = id
+        BookmarkFactory.addIcon(bookmark, row: row)
+        return bookmark
+    }
+
+    // We ignore queries altogether inside the model factory.
+    fileprivate class func queryFactory(_ row: SDRow) -> BookmarkItem {
+        log.warning("Creating a BookmarkItem from a query. This is almost certainly unexpected.")
+        let id = row["id"] as? Int
+        let guid = row["guid"] as! String
+        let title = row["title"] as? String ?? SQLiteBookmarks.defaultItemTitle
+        let isEditable = row.getBoolean("isEditable")           // Defaults to false.
+        let bookmark = BookmarkItem(guid: guid, title: title, url: "about:blank", isEditable: isEditable)
+        bookmark.id = id
+        BookmarkFactory.addIcon(bookmark, row: row)
+        return bookmark
+    }
+
+    fileprivate class func separatorFactory(_ row: SDRow) -> BookmarkSeparator {
+        let id = row["id"] as? Int
+        let guid = row["guid"] as! String
+        let separator = BookmarkSeparator(guid: guid)
+        separator.id = id
+        return separator
+    }
+
+    fileprivate class func itemRowFactory(_ row: SDRow, forceEditable: Bool = false) -> BookmarkItem {
+        let id = row["id"] as? Int
+        let guid = row["guid"] as! String
+        let url = row["bmkUri"] as! String
+        let title = row["title"] as? String ?? url
+        let isEditable = forceEditable || row.getBoolean("isEditable")           // Defaults to false.
+        let bookmark = BookmarkItem(guid: guid, title: title, url: url, isEditable: isEditable)
+        bookmark.id = id
+        BookmarkFactory.addIcon(bookmark, row: row)
+        return bookmark
+    }
+
+    fileprivate class func itemFactory(_ row: SDRow) -> BookmarkItem {
+        return BookmarkFactory.itemRowFactory(row, forceEditable: false)
+    }
+
+    fileprivate class func folderFactory(_ row: SDRow) -> BookmarkFolder {
+        let id = row["id"] as? Int
+        let guid = row["guid"] as! String
+        let isEditable = row.getBoolean("isEditable")           // Defaults to false.
+        let title = titleForSpecialGUID(guid) ??
+                    row["title"] as? String ??
+                    SQLiteBookmarks.defaultFolderTitle
+
+        let folder = BookmarkFolder(guid: guid, title: title, isEditable: isEditable)
+        folder.id = id
+        BookmarkFactory.addIcon(folder, row: row)
+        return folder
+    }
+
+    class func factory(_ row: SDRow) -> BookmarkNode {
+        return BookmarkFactory.rowFactory(row, forceEditable: false)
+    }
+
+    class func editableItemsFactory(_ row: SDRow) -> BookmarkNode {
+        return BookmarkFactory.rowFactory(row, forceEditable: true)
+    }
+
+    class func rowFactory(_ row: SDRow, forceEditable: Bool = false) -> BookmarkNode {
+        if let typeCode = row["type"] as? Int, let type = BookmarkNodeType(rawValue: typeCode) {
+            switch type {
+            case .bookmark:
+                return itemRowFactory(row, forceEditable: forceEditable)
+            case .dynamicContainer:
+                // This should never be hit: we exclude dynamic containers from our models.
+                fallthrough
+            case .folder:
+                return folderFactory(row)
+            case .separator:
+                return separatorFactory(row)
+            case .livemark:
+                return livemarkFactory(row)
+            case .query:
+                // This should never be hit: we exclude queries from our models.
+                return queryFactory(row)
+            }
+        }
+        assert(false, "Invalid bookmark data.")
+        return itemFactory(row)     // This will fail, but it keeps the compiler happy.
+    }
+
+    // N.B., doesn't include children!
+    class func mirrorItemFactory(_ row: SDRow) -> BookmarkMirrorItem {
+        // TODO
+        // let id = row["id"] as! Int
+
+        let guid = row["guid"] as! GUID
+        let typeCode = row["type"] as! Int
+        let is_deleted = row.getBoolean("is_deleted")
+        let parentid = row["parentid"] as? GUID
+        let parentName = row["parentName"] as? String
+        let feedUri = row["feedUri"] as? String
+        let siteUri = row["siteUri"] as? String
+        let pos = row["pos"] as? Int
+        let title = row["title"] as? String
+        let description = row["description"] as? String
+        let bmkUri = row["bmkUri"] as? String
+        let tags = row["tags"] as? String
+        let keyword = row["keyword"] as? String
+        let folderName = row["folderName"] as? String
+        let queryId = row["queryId"] as? String
+        let date_added = row.getTimestamp("date_added")
+
+        // Local and mirror only.
+        let faviconID = row["faviconID"] as? Int
+
+        // Local only.
+        let local_modified = row.getTimestamp("local_modified")
+
+        // Mirror and buffer.
+        let server_modified = row.getTimestamp("server_modified")
+        let hasDupe = row.getBoolean("hasDupe")
+
+        // Mirror only. TODO
+        //let is_overridden = row.getBoolean("is_overridden")
+
+        // Use the struct initializer directly. Yes, this doesn't validate as strongly as
+        // using the static constructors, but it'll be as valid as the contents of the DB.
+        let type = BookmarkNodeType(rawValue: typeCode)!
+
+        // This one might really be missing (it's local-only), so do this the hard way.
+        let syncStatus: SyncStatus?
+        if let s = row["sync_status"] as? Int {
+            syncStatus = SyncStatus(rawValue: s)
+        } else {
+            syncStatus = nil
+        }
+        let item = BookmarkMirrorItem(guid: guid, type: type, dateAdded: date_added, serverModified: server_modified ?? 0,
+                                      isDeleted: is_deleted, hasDupe: hasDupe, parentID: parentid, parentName: parentName,
+                                      feedURI: feedUri, siteURI: siteUri,
+                                      pos: pos,
+                                      title: title, description: description,
+                                      bookmarkURI: bmkUri, tags: tags, keyword: keyword,
+                                      folderName: folderName, queryID: queryId,
+                                      children: nil,
+                                      faviconID: faviconID, localModified: local_modified,
+                                      syncStatus: syncStatus)
+        return item
+    }
+}
+
+extension SQLiteBookmarks: SearchableBookmarks {
+    public func bookmarksByURL(_ url: URL) -> Deferred<Maybe<Cursor<BookmarkItem>>> {
+        let inner =
+        "SELECT id, type, date_added, guid, bmkUri, title, faviconID FROM \(TableBookmarksLocal) " +
+        "WHERE " +
+        "type = \(BookmarkNodeType.bookmark.rawValue) AND is_deleted IS NOT 1 AND bmkUri = ? " +
+        "UNION ALL " +
+        "SELECT id, type, date_added, guid, bmkUri, title, faviconID FROM \(TableBookmarksMirror) " +
+        "WHERE " +
+        "type = \(BookmarkNodeType.bookmark.rawValue) AND is_overridden IS NOT 1 AND is_deleted IS NOT 1 AND bmkUri = ? "
+
+        let sql =
+        "SELECT bookmarks.id AS id, bookmarks.type AS type, bookmarks.date_added AS date_added, guid, bookmarks.bmkUri AS bmkUri, title, " +
+        "favicons.url AS iconURL, favicons.date AS iconDate, favicons.type AS iconType " +
+        "FROM (\(inner)) AS bookmarks " +
+        "LEFT OUTER JOIN favicons ON bookmarks.faviconID = favicons.id"
+
+        let u = url.absoluteString
+        let args: Args = [u, u]
+        return db.runQuery(sql, args: args, factory: BookmarkFactory.itemFactory)
+    }
+}
+
+extension SQLiteBookmarks {
+    // We're in sync (even partially) if the mirror is non-empty.
+    // We can show fallback desktop bookmarks if the mirror is empty and the buffer contains
+    // children of the roots.
+    func hasOnlyUnmergedRemoteBookmarks() -> Deferred<Maybe<Bool>> {
+        let parents: Args = [
+            BookmarkRoots.MenuFolderGUID,
+            BookmarkRoots.ToolbarFolderGUID,
+            BookmarkRoots.UnfiledFolderGUID,
+            BookmarkRoots.MobileFolderGUID,
+        ]
+        let sql = [
+            "SELECT",
+            "not exists(SELECT 1 FROM \(TableBookmarksMirror))",
+            "AND",
+            "exists(SELECT 1 FROM \(TableBookmarksBufferStructure) WHERE parent IN (?, ?, ?, ?))",
+            ].joined(separator: " ")
+        return self.db.runQuery(sql, args: parents, factory: { $0[0] as! Int == 1 })
+            >>== { row in
+                guard row.status == .success,
+                    let result = row[0] else {
+                        // if the query did not succeed, we should return false so that we can use local bookmarks
+                        return deferMaybe(false)
+                }
+                return deferMaybe(result)
+        }
+    }
+}
+
+// It's a factory where the root contains Desktop Bookmarks from the buffer, and
+// mobile bookmarks from local.
+open class UnsyncedBookmarksFallbackModelFactory: BookmarksModelFactory {
+    let localFactory: SQLiteBookmarksModelFactory
+    let bufferFactory: SQLiteBookmarksModelFactory
+
+    init(bookmarks: SQLiteBookmarks) {
+        // This relies on SQLiteBookmarks being the storage for both directions.
+        self.localFactory = SQLiteBookmarksModelFactory(bookmarks: bookmarks, direction: .local)
+        if AppConstants.MOZ_SIMPLE_BOOKMARKS_SYNCING {
+            self.bufferFactory = EditableBufferBookmarksSQLiteBookmarksModelFactory(bookmarks: bookmarks, direction: .buffer)
+        } else {
+            self.bufferFactory = SQLiteBookmarksModelFactory(bookmarks: bookmarks, direction: .buffer)
+        }
+    }
+
+    // This is a special-case class, so here's the special-case behavior to
+    // know how to handle a folder that contains items drawn from different
+    // parts of the database. We look for the special kinds of folders we
+    // nest at the top level, and then we pick a folder to match.
+    public func factoryForIndex(_ index: Int, inFolder folder: BookmarkFolder) -> BookmarksModelFactory {
+        let concatenated: ConcatenatedBookmarkFolder
+        let i: Int
+
+        // We have either just remote and local mobile bookmarks, or we have Desktop Bookmarks
+        // followed by remote and local mobile bookmarks. Handle either.
+        if let prepended = folder as? PrependedBookmarkFolder {
+            if index == 0 {
+                return self
+            }
+
+            guard let c = prepended.main as? ConcatenatedBookmarkFolder else {
+                return self
+            }
+            i = index - 1        // Drop the prepend.
+            concatenated = c
+        } else {
+            guard let c = folder as? ConcatenatedBookmarkFolder else {
+                return self
+            }
+            i = index
+            concatenated = c
+        }
+
+        if i < concatenated.pivot {
+            return self.bufferFactory   // This comes first in our concatenation.
+        }
+        return self.localFactory
+    }
+
+    open func modelForFolder(_ folder: BookmarkFolder) -> Deferred<Maybe<BookmarksModel>> {
+        return self.modelForFolder(folder.guid, title: folder.title)
+    }
+
+    open func modelForFolder(_ guid: GUID) -> Deferred<Maybe<BookmarksModel>> {
+        return self.modelForFolder(guid, title: "")
+    }
+
+    open func modelForFolder(_ guid: GUID, title: String) -> Deferred<Maybe<BookmarksModel>> {
+        if guid == BookmarkRoots.MobileFolderGUID {
+            return self.modelForRoot()
+        }
+
+        if guid == BookmarkRoots.FakeDesktopFolderGUID {
+            return self.bufferFactory.modelForFolder(guid, title: title)
+        }
+
+        return self.localFactory.modelForFolder(guid, title: title)
+    }
+
+    open func modelForRoot() -> Deferred<Maybe<BookmarksModel>> {
+        log.debug("Getting model for fallback root.")
+        // Return a virtual model containing "Desktop bookmarks" prepended to the local mobile bookmarks.
+        return self.localFactory.folderForGUID(BookmarkRoots.MobileFolderGUID, title: BookmarksFolderTitleMobile)
+            >>== {
+                localMobileFolder in
+                
+                self.bufferFactory.folderForGUID(BookmarkRoots.MobileFolderGUID, title: BookmarksFolderTitleMobile) >>== {
+                    bufferMobileFolder in
+
+                    let bufferAndLocalMobile = ConcatenatedBookmarkFolder(main: bufferMobileFolder, append: localMobileFolder)
+                    return self.bufferFactory.hasDesktopBookmarks() >>== { yes in
+                        guard yes else {
+                            return deferMaybe(BookmarksModel(modelFactory: self, root: bufferAndLocalMobile))
+                        }
+                        return self.bufferFactory.getDesktopRoots() >>== { cursor in
+                            let desktop = self.bufferFactory.folderForDesktopBookmarksCursor(cursor)
+                            let withDesktopPrepended = PrependedBookmarkFolder(main: bufferAndLocalMobile, prepend: desktop)
+                            return deferMaybe(BookmarksModel(modelFactory: self, root: withDesktopPrepended))
+                        }
+                    }
+                }
+        }
+    }
+
+    // Whenever async construction is necessary, we fall into a pattern of needing
+    // a placeholder that behaves correctly for the period between kickoff and set.
+    open var nullModel: BookmarksModel {
+        let children = Cursor<BookmarkNode>(status: .failure, msg: "Null model")
+        let folder = SQLiteBookmarkFolder(guid: "Null", title: "Null", children: children)
+        return BookmarksModel(modelFactory: self, root: folder)
+    }
+
+    open func isBookmarked(_ url: String) -> Deferred<Maybe<Bool>> {
+        // We don't include buffer items in this check, because we can't un-star them!
+        return self.localFactory.isBookmarked(url)
+    }
+
+    open func removeByGUID(_ guid: GUID) -> Success {
+        return self.localFactory.removeByGUID(guid)
+    }
+
+    open func removeByURL(_ url: String) -> Success {
+        return self.localFactory.removeByURL(url)
+    }
+}
+
+open class MergedSQLiteBookmarks: BookmarksModelFactorySource, KeywordSearchSource {
+    let local: SQLiteBookmarks
+    let buffer: SQLiteBookmarkBufferStorage
+
+    // Figuring out our factory can require hitting the DB, so this is async.
+    // Note that we check *every time* -- we don't want to get stuck in a dead
+    // end when you might sync soon.
+    open var modelFactory: Deferred<Maybe<BookmarksModelFactory>> {
+        return self.local.hasOnlyUnmergedRemoteBookmarks() >>== { yes in
+            if yes {
+                log.debug("Only unmerged remote bookmarks; using fallback factory.")
+                return deferMaybe(UnsyncedBookmarksFallbackModelFactory(bookmarks: self.local))
+            }
+            log.debug("Using local+mirror bookmark factory.")
+            return self.local.modelFactory
+        }
+    }
+
+    public init(db: BrowserDB) {
+        self.local = SQLiteBookmarks(db: db)
+        self.buffer = SQLiteBookmarkBufferStorage(db: db)
+    }
+
+    open func getURLForKeywordSearch(_ keyword: String) -> Deferred<Maybe<String>> {
+        return self.local.getURLForKeywordSearch(keyword)
+    }
+}