Merge lp:~maxb/bzr-svn/cache-interface-tidying into lp:bzr-svn/1.1

[Max Bowsher]

No user visible changes - just making the cache interface code more discoverable to coders, and eliminating duplicate documentation which is a pain to maintain.

[Jelmer Vernooij (jelmer)]

Thanks for cleaning up this code.

Can you please add a comment that indicates where the base of a method is - e.g. "See RevisionInfoCache.insert_revision." instead of outright removing the docstring? Otherwise it becomes hard(er) to actually find the relevant docs.

review: Needs Fixing (code)

[Max Bowsher (maxb)]

I've pushed revno 3514 to correct this and revno 3515 with an addition of an extra comment.

=== modified file 'cache/sqlitecache.py'
--- cache/sqlitecache.py	2011-01-16 15:53:18 +0000
+++ cache/sqlitecache.py	2011-02-01 09:52:50 +0000
@@ -33,6 +33,18 @@
 from bzrlib.plugins.svn.mapping import (
     mapping_registry,
     )
+from bzrlib.plugins.svn.revids import (
+    RevisionIdMapCache,
+    )
+from bzrlib.plugins.svn.revmeta import (
+    RevisionInfoCache,
+    )
+from bzrlib.plugins.svn.logwalker import (
+    LogCache,
+    )
+from bzrlib.plugins.svn.parents import (
+    ParentsCache,
+    )
 
 from subvertpy import NODE_UNKNOWN
 
@@ -101,11 +113,7 @@
 CACHE_DB_VERSION = 5
 
 
-class RevisionIdMapCache(CacheTable):
-    """Revision id mapping store.
-
-    Stores mapping from revid -> (path, revnum, mapping)
-    """
+class SqliteRevisionIdMapCache(RevisionIdMapCache, CacheTable):
 
     def _create_table(self):
         self.cachedb.executescript("""
@@ -130,23 +138,15 @@
         self._commit_interval = 500
 
     def set_last_revnum_checked(self, layout, revnum):
-        """Remember the latest revision number that has been checked
-        for a particular layout.
+        """See RevisionIdMapCache.set_last_revnum_checked."""
 
-        :param layout: Repository layout.
-        :param revnum: Revision number.
-        """
         self.mutter("set last revnum checked for %r to %r", layout, revnum)
         self.cachedb.execute("replace into revids_seen (layout, max_revnum) VALUES (?, ?)", (layout, revnum))
         self.commit()
 
     def last_revnum_checked(self, layout):
-        """Retrieve the latest revision number that has been checked
-        for revision ids for a particular layout.
+        """See RevisionIdMapCache.last_revnum_checked."""
 
-        :param layout: Repository layout.
-        :return: Last revision number checked or 0.
-        """
         ret = self.cachedb.execute(
             "select max_revnum from revids_seen where layout = ?", (layout,)).fetchone()
         if ret is None:
@@ -157,12 +157,8 @@
         return revnum
 
     def lookup_revid(self, revid):
-        """Lookup the details for a particular revision id.
+        """See RevisionIdMapCache.lookup_revid."""
 
-        :param revid: Revision id.
-        :return: Tuple with path inside repository, minimum revision number, maximum revision number and
-            mapping.
-        """
         assert isinstance(revid, str)
         self.mutter("lookup revid %r", revid)
         ret = self.cachedb.execute(
@@ -176,12 +172,8 @@
             return (path, min_revnum, max_revnum, mapping)
 
     def lookup_branch_revnum(self, revnum, path, mapping):
-        """Lookup a revision by revision number, branch path and mapping.
+        """See RevisionIdMapCache.lookup_branch_revnum."""
 
-        :param revnum: Subversion revision number.
-        :param path: Subversion branch path.
-        :param mapping: Mapping
-        """
         assert isinstance(revnum, int)
         assert isinstance(path, str)
         assert isinstance(mapping, str)
@@ -195,17 +187,8 @@
         return ret
 
     def insert_revid(self, revid, branch, min_revnum, max_revnum, mapping):
-        """Insert a revision id into the revision id cache.
+        """See RevisionIdMapCache.insert_revid."""
 
-        :param revid: Revision id for which to insert metadata.
-        :param branch: Branch path at which the revision was seen
-        :param min_revnum: Minimum Subversion revision number in which the
-                           revid was found
-        :param max_revnum: Maximum Subversion revision number in which the
-                           revid was found
-        :param mapping: Name of the mapping with which the revision
-                       was found
-        """
         assert revid is not None and revid != ""
         assert isinstance(mapping, str)
         assert isinstance(branch, str)
@@ -227,7 +210,7 @@
         self._commit_conditionally()
 
 
-class RevisionInfoCache(CacheTable):
+class SqliteRevisionInfoCache(RevisionInfoCache, CacheTable):
 
     def _create_table(self):
         self.cachedb.executescript("""
@@ -252,6 +235,8 @@
         self._commit_interval = 500
 
     def set_original_mapping(self, foreign_revid, original_mapping):
+        """See RevisionInfoCache.set_original_mapping."""
+
         if original_mapping is not None:
             orig_mapping_name = original_mapping.name
         else:
@@ -260,24 +245,14 @@
 
     def insert_revision(self, foreign_revid, mapping, (revno, revid, hidden),
             stored_lhs_parent_revid):
-        """Insert a revision to the cache.
+        """See RevisionInfoCache.insert_revision."""
 
-        :param foreign_revid: Foreign revision id
-        :param mapping: Mapping used
-        :param info: Tuple with (revno, revid, hidden)
-        :param stored_lhs_parent_revid: Stored lhs parent revision
-        """
         self.cachedb.execute("insert into revmetainfo (path, revnum, mapping, revid, revno, hidden, stored_lhs_parent_revid) values (?, ?, ?, ?, ?, ?, ?)", (foreign_revid[1], foreign_revid[2], mapping.name, revid, revno, hidden, stored_lhs_parent_revid))
         self._commit_conditionally()
 
     def get_revision(self, foreign_revid, mapping):
-        """Get the revision metadata info for a (foreign_revid, mapping) tuple.
+        """See RevisionInfoCache.get_revision."""
 
-        :param foreign_revid: Foreign revision id
-        :param mapping: Mapping
-        :return: Tuple with (stored revno, revid, hidden),
-            stored_lhs_parent_revid
-        """
         # Will raise KeyError if not present
         row = self.cachedb.execute("select revno, revid, hidden, stored_lhs_parent_revid from revmetainfo where path = ? and revnum = ? and mapping = ?", (foreign_revid[1], foreign_revid[2], mapping.name)).fetchone()
         if row is None:
@@ -294,11 +269,8 @@
             return ((row[0], stored_revid, row[2]), stored_lhs_parent_revid)
 
     def get_original_mapping(self, foreign_revid):
-        """Find the original mapping for a revision.
+        """See RevisionInfoCache.get_original_mapping."""
 
-        :param foreign_revid: Foreign revision id
-        :return: Mapping object or None
-        """
         row = self.cachedb.execute("select original_mapping from original_mapping where path = ? and revnum = ?", (foreign_revid[1].decode("utf-8"), foreign_revid[2])).fetchone()
         if row is None:
             raise KeyError(foreign_revid)
@@ -308,10 +280,7 @@
             return mapping_registry.parse_mapping_name("svn-" + row[0].encode("utf-8"))
 
 
-class LogCache(CacheTable):
-    """Log browser cache table manager. The methods of this class
-    encapsulate the SQL commands used by CachingLogWalker to access
-    the log cache tables."""
+class SqliteLogCache(LogCache, CacheTable):
 
     def _create_table(self):
         self.cachedb.executescript("""
@@ -343,6 +312,8 @@
             pass # Column already exists.
 
     def find_latest_change(self, path, revnum):
+        """See LogCache.find_latest_change."""
+
         if path == "":
             return self.cachedb.execute("select max(rev) from changed_path where rev <= ?", (revnum,)).fetchone()[0]
         return self.cachedb.execute("""
@@ -355,10 +326,8 @@
         """, (revnum, path, path + "/*", path)).fetchone()[0]
 
     def get_revision_paths(self, revnum):
-        """Return all history information for a given revision number.
+        """See LogCache.get_revision_paths."""
 
-        :param revnum: Revision number of revision.
-        """
         result = self.cachedb.execute("select path, action, copyfrom_path, copyfrom_rev, kind from changed_path where rev=?", (revnum,))
         paths = {}
         for p, act, cf, cr, kind in result:
@@ -368,11 +337,8 @@
         return paths
 
     def insert_paths(self, rev, orig_paths):
-        """Insert new history information into the cache.
+        """See LogCache.insert_paths."""
 
-        :param rev: Revision number of the revision
-        :param orig_paths: SVN-style changes dictionary
-        """
         if orig_paths is None or orig_paths == {}:
             return
         new_paths = []
@@ -390,13 +356,13 @@
         self.cachedb.executemany("replace into changed_path (rev, path, action, copyfrom_path, copyfrom_rev, kind) values (?, ?, ?, ?, ?, ?)", new_paths)
 
     def drop_revprops(self, revnum):
+        """See LogCache.drop_revprops."""
+
         self.cachedb.execute("update revinfo set all_revprops = 0 where rev = ?", (revnum,))
 
     def get_revprops(self, revnum):
-        """Retrieve all the cached revision properties.
+        """See LogCache.get_revprops."""
 
-        :param revnum: Revision number of revision to retrieve revprops for.
-        """
         result = self.cachedb.execute("select name, value from revprop where rev = ?", (revnum,))
         revprops = dict((k.encode("utf-8"), v.encode("utf-8")) for (k, v) in result)
         result = self.cachedb.execute("select all_revprops from revinfo where rev = ?", (revnum,)).fetchone()
@@ -407,6 +373,8 @@
         return (revprops, all_revprops)
 
     def insert_revprops(self, revision, revprops, all_revprops):
+        """See LogCache.insert_revprops."""
+
         if revprops is None:
             return
         self.cachedb.executemany("replace into revprop (rev, name, value) values (?, ?, ?)", [(revision, name.decode("utf-8", "replace"), value.decode("utf-8", "replace")) for (name, value) in revprops.iteritems()])
@@ -415,16 +383,20 @@
         """, (revision, all_revprops))
 
     def last_revnum(self):
+        """See LogCache.last_revnum."""
+
         saved_revnum = self.cachedb.execute("SELECT MAX(rev) FROM changed_path").fetchone()[0]
         if saved_revnum is None:
             return 0
         return saved_revnum
 
     def min_revnum(self):
+        """See LogCache.min_revnum."""
+
         return self.cachedb.execute("SELECT MIN(rev) FROM revprop").fetchone()[0]
 
 
-class ParentsCache(CacheTable):
+class SqliteParentsCache(ParentsCache, CacheTable):
 
     def _create_table(self):
         self.cachedb.executescript("""
@@ -439,6 +411,8 @@
         self._commit_interval = 200
 
     def insert_parents(self, revid, parents):
+        """See ParentsCache.insert_parents."""
+
         self.mutter('insert parents: %r -> %r', revid, parents)
         if len(parents) == 0:
             self.cachedb.execute("replace into parent (rev, parent, idx) values (?, NULL, -1)", (revid,))
@@ -448,6 +422,8 @@
         self._commit_conditionally()
 
     def lookup_parents(self, revid):
+        """See ParentsCache.lookup_parents."""
+
         self.mutter('lookup parents: %r', revid)
         rows = self.cachedb.execute("select parent from parent where rev = ? order by idx", (revid, )).fetchall()
         if len(rows) == 0:
@@ -466,16 +442,16 @@
         return cachedbs()[cache_file]
 
     def open_revid_map(self):
-        return RevisionIdMapCache(self.open_sqlite())
+        return SqliteRevisionIdMapCache(self.open_sqlite())
 
     def open_logwalker(self):
-        return LogCache(self.open_sqlite())
+        return SqliteLogCache(self.open_sqlite())
 
     def open_revision_cache(self):
-        return RevisionInfoCache(self.open_sqlite())
+        return SqliteRevisionInfoCache(self.open_sqlite())
 
     def open_parents(self):
-        return ParentsCache(self.open_sqlite())
+        return SqliteParentsCache(self.open_sqlite())
 
     def commit(self):
         self.open_sqlite().commit()

=== modified file 'cache/tdbcache.py'
--- cache/tdbcache.py	2011-01-18 18:33:05 +0000
+++ cache/tdbcache.py	2011-02-01 09:52:50 +0000
@@ -38,6 +38,18 @@
 from bzrlib.plugins.svn.mapping import (
     mapping_registry,
     )
+from bzrlib.plugins.svn.revids import (
+    RevisionIdMapCache,
+    )
+from bzrlib.plugins.svn.revmeta import (
+    RevisionInfoCache,
+    )
+from bzrlib.plugins.svn.logwalker import (
+    LogCache,
+    )
+from bzrlib.plugins.svn.parents import (
+    ParentsCache,
+    )
 
 from subvertpy import NODE_UNKNOWN
 
@@ -60,40 +72,24 @@
             trace.mutter(text, *args, **kwargs)
 
 
-class RevisionIdMapCache(CacheTable):
-    """Revision id mapping store.
-
-    Stores mapping from revid -> (path, revnum, mapping)
-    """
+class TdbRevisionIdMapCache(RevisionIdMapCache, CacheTable):
 
     def set_last_revnum_checked(self, layout, revnum):
-        """Remember the latest revision number that has been checked
-        for a particular layout.
+        """See RevisionIdMapCache.set_last_revnum_checked."""
 
-        :param layout: Repository layout.
-        :param revnum: Revision number.
-        """
         self.db["revidmap-last/%s" % str(layout)] = str(revnum)
 
     def last_revnum_checked(self, layout):
-        """Retrieve the latest revision number that has been checked
-        for revision ids for a particular layout.
+        """See RevisionIdMapCache.last_revnum_checked."""
 
-        :param layout: Repository layout.
-        :return: Last revision number checked or 0.
-        """
         try:
             return int(self.db["revidmap-last/%s" % str(layout)])
         except KeyError:
             return 0
 
     def lookup_revid(self, revid):
-        """Lookup the details for a particular revision id.
+        """See RevisionIdMapCache.lookup_revid."""
 
-        :param revid: Revision id.
-        :return: Tuple with path inside repository, minimum revision number,
-            maximum revision number and mapping.
-        """
         self.mutter('lookup-revid %s', revid)
         try:
             (min_revnum, max_revnum, mapping_name, path) = self.db["native-revid/" + revid].split(" ", 3)
@@ -102,12 +98,8 @@
         return (path, int(min_revnum), int(max_revnum), mapping_name)
 
     def lookup_branch_revnum(self, revnum, path, mapping):
-        """Lookup a revision by revision number, branch path and mapping.
+        """See RevisionIdMapCache.lookup_branch_revnum."""
 
-        :param revnum: Subversion revision number.
-        :param path: Subversion branch path.
-        :param mapping: Mapping
-        """
         self.mutter('lookup-branch-revnum %s:%d', path, revnum)
         try:
             return self.db["foreign-revid/%d %s %s" % (revnum, getattr(mapping, "name", mapping), path)]
@@ -115,25 +107,19 @@
             return None
 
     def insert_revid(self, revid, branch, min_revnum, max_revnum, mapping):
-        """Insert a revision id into the revision id cache.
+        """See RevisionIdMapCache.insert_revid."""
 
-        :param revid: Revision id for which to insert metadata.
-        :param branch: Branch path at which the revision was seen
-        :param min_revnum: Minimum Subversion revision number in which the
-                           revid was found
-        :param max_revnum: Maximum Subversion revision number in which the
-                           revid was found
-        :param mapping: Name of the mapping with which the revision was found
-        """
         mappingname = getattr(mapping, "name", mapping)
         self.db["native-revid/" + revid] = "%d %d %s %s" % (min_revnum, max_revnum, mappingname, branch)
         if min_revnum == max_revnum:
             self.db["foreign-revid/%d %s %s" % (min_revnum, mappingname, branch)] = revid
 
 
-class RevisionInfoCache(CacheTable):
+class TdbRevisionInfoCache(RevisionInfoCache, CacheTable):
 
     def set_original_mapping(self, foreign_revid, original_mapping):
+        """See RevisionInfoCache.set_original_mapping."""
+
         if original_mapping is not None:
             orig_mapping_name = original_mapping.name
         else:
@@ -142,16 +128,8 @@
 
     def insert_revision(self, foreign_revid, mapping, (revno, revid, hidden),
             stored_lhs_parent_revid):
-        """Insert a revision to the cache.
+        """See RevisionInfoCache.insert_revision."""
 
-        :param foreign_revid: Foreign revision id
-        :param mapping: Mapping used
-        :param revid: Revision id
-        :param revno: Revision number
-        :param hidden: Whether revision is hidden
-        :param original_mapping: Original mapping used
-        :param stored_lhs_parent_revid: Stored lhs parent revision
-        """
         if revid is None:
             revid = mapping.revision_id_foreign_to_bzr(foreign_revid)
         self.db["foreign-revid/%d %d %s %s" % (foreign_revid[2], foreign_revid[2], mapping.name, foreign_revid[1])] = revid
@@ -165,12 +143,8 @@
             self.db["lhs-parent-revid/%s" % basekey] = stored_lhs_parent_revid
 
     def get_revision(self, foreign_revid, mapping):
-        """Get the revision metadata info for a (foreign_revid, mapping) tuple.
+        """See RevisionInfoCache.get_revision."""
 
-        :param foreign_revid: Foreign revision id
-        :param mapping: Mapping
-        :return: Tuple with (stored revno, revid, hidden), stored_lhs_parent_revid
-        """
         self.mutter("get-revision %r,%r", foreign_revid, mapping)
         basekey = "%d %s %s" % (foreign_revid[2], mapping.name, foreign_revid[1])
         revid = self.db["foreign-revid/%d %d %s %s" % (foreign_revid[2], foreign_revid[2], mapping.name, foreign_revid[1])]
@@ -187,11 +161,8 @@
         return ((revno, revid, hidden), stored_lhs_parent_revid)
 
     def get_original_mapping(self, foreign_revid):
-        """Find the original mapping for a revision.
+        """See RevisionInfoCache.get_original_mapping."""
 
-        :param foreign_revid: Foreign revision id
-        :return: Mapping object or None
-        """
         self.mutter("get-original-mapping %r", foreign_revid)
         ret = self.db["original-mapping/%d %s" % (foreign_revid[2], foreign_revid[1])]
         if ret == "":
@@ -199,19 +170,16 @@
         return mapping_registry.parse_mapping_name("svn-" + ret)
 
 
-class LogCache(CacheTable):
-    """Log browser cache table manager. The methods of this class
-    encapsulate the SQL commands used by CachingLogWalker to access
-    the log cache tables."""
+class TdbLogCache(LogCache, CacheTable):
 
     def find_latest_change(self, path, revnum):
+        """See LogCache.find_latest_change."""
+
         raise NotImplementedError(self.find_latest_change)
 
     def get_revision_paths(self, revnum):
-        """Return all history information for a given revision number.
+        """See LogCache.get_revision_paths."""
 
-        :param revnum: Revision number of revision.
-        """
         self.mutter("get-revision-paths %d", revnum)
         ret = {}
         db = bencode.bdecode(self.db["paths/%d" % revnum])
@@ -227,11 +195,8 @@
         return ret
 
     def insert_paths(self, rev, orig_paths):
-        """Insert new history information into the cache.
+        """See LogCache.insert_paths."""
 
-        :param rev: Revision number of the revision
-        :param orig_paths: SVN-style changes dictionary
-        """
         if orig_paths is None:
             orig_paths = {}
         new_paths = {}
@@ -252,18 +217,20 @@
         self.db["log-last"] = "%d" % max(self.last_revnum(), rev)
 
     def drop_revprops(self, revnum):
+        """See LogCache.drop_revprops."""
+
         self.db["revprops/%d" % revnum] = bencode.bencode({})
 
     def get_revprops(self, revnum):
-        """Retrieve all the cached revision properties.
+        """See LogCache.get_revprops."""
 
-        :param revnum: Revision number of revision to retrieve revprops for.
-        """
         self.mutter("get-revision-properties %d", revnum)
         ret = bencode.bdecode(self.db["revprops/%d" % revnum])
         return (ret[0], bool(ret[1]))
 
     def insert_revprops(self, revision, revprops, all_revprops):
+        """See LogCache.insert_revprops."""
+
         if revprops is None:
             revprops = {}
         self.db["revprops/%d" % revision] = bencode.bencode((revprops, all_revprops))
@@ -275,23 +242,31 @@
         self.db["log-min"] = str(min_revnum)
 
     def last_revnum(self):
+        """See LogCache.last_revnum."""
+
         try:
             return int(self.db["log-last"])
         except KeyError:
             return 0
 
     def min_revnum(self):
+        """See LogCache.min_revnum."""
+
         try:
             return int(self.db["log-min"])
         except KeyError:
             return None
 
-class ParentsCache(CacheTable):
+class TdbParentsCache(ParentsCache, CacheTable):
 
     def insert_parents(self, revid, parents):
+        """See ParentsCache.insert_parents."""
+
         self.db["parents/%s" % revid] = " ".join(parents)
 
     def lookup_parents(self, revid):
+        """See ParentsCache.lookup_parents."""
+
         self.mutter("lookup-parents %s", revid)
         try:
             return tuple([p for p in self.db["parents/%s" % revid].split(" ") if p != ""])
@@ -319,13 +294,13 @@
         return db
 
     def open_revid_map(self):
-        return RevisionIdMapCache(self.open_tdb())
+        return TdbRevisionIdMapCache(self.open_tdb())
 
     def open_logwalker(self):
-        return LogCache(self.open_tdb())
+        return TdbLogCache(self.open_tdb())
 
     def open_revision_cache(self):
-        return RevisionInfoCache(self.open_tdb())
+        return TdbRevisionInfoCache(self.open_tdb())
 
     def open_parents(self):
-        return ParentsCache(self.open_tdb())
+        return TdbParentsCache(self.open_tdb())

=== modified file 'logwalker.py'
--- logwalker.py	2010-11-09 01:02:32 +0000
+++ logwalker.py	2011-02-01 09:52:50 +0000
@@ -141,12 +141,17 @@
 
 
 class LogCache(object):
-    """Log browser cache. """
+    """Log browser cache manager. The methods of this class
+    encapsulate the data access patterns used by CachingLogWalker to
+    access the log cache."""
 
     def find_latest_change(self, path, revnum):
         """Find the last revision in which a particular path
         was changed.
 
+        This is an optional operation: cache backends may choose not to
+        implement it if they cannot efficiently perform this kind of lookup.
+
         :param path: Path to check
         :param revnum: Revision in which to check
         """

=== modified file 'revids.py'
--- revids.py	2010-08-10 02:36:24 +0000
+++ revids.py	2011-02-01 09:52:50 +0000
@@ -348,39 +348,3 @@
                        was found
         """
         raise NotImplementedError(self.insert_revid)
-
-
-class RevisionInfoCache(object):
-
-    def set_original_mapping(self, foreign_revid, original_mapping):
-        raise NotImplementedError(self.set_original_mapping)
-
-    def insert_revision(self, foreign_revid, mapping, revinfo,
-            stored_lhs_parent_revid):
-        """Insert a revision to the cache.
-
-        :param foreign_revid: Foreign revision id
-        :param mapping: Mapping used
-        :param revinfo: Tuple with (revno, revid, hidden)
-        :param original_mapping: Original mapping used
-        :param stored_lhs_parent_revid: Stored lhs parent revision
-        """
-        raise NotImplementedError(self.insert_revision)
-
-    def get_revision(self, foreign_revid, mapping):
-        """Get the revision metadata info for a (foreign_revid, mapping) tuple.
-
-        :param foreign_revid: Foreign reviasion id
-        :param mapping: Mapping
-        :return: Tuple with (stored revno, revid, hidden), original_mapping,
-            stored_lhs_parent_revid
-        """
-        raise NotImplementedError(self.get_revision)
-
-    def get_original_mapping(self, foreign_revid):
-        """Find the original mapping for a revision.
-
-        :param foreign_revid: Foreign revision id
-        :return: Mapping object or None
-        """
-        raise NotImplementedError(self.get_original_mapping)

=== modified file 'revmeta.py'
--- revmeta.py	2011-01-18 18:33:05 +0000
+++ revmeta.py	2011-02-01 09:52:50 +0000
@@ -1435,3 +1435,38 @@
         for kind, item in browser:
             if kind != "revision" or check_unusual_path(item.branch_path):
                 yield kind, item
+
+
+class RevisionInfoCache(object):
+
+    def set_original_mapping(self, foreign_revid, original_mapping):
+        raise NotImplementedError(self.set_original_mapping)
+
+    def insert_revision(self, foreign_revid, mapping, revinfo,
+            stored_lhs_parent_revid):
+        """Insert a revision to the cache.
+
+        :param foreign_revid: Foreign revision id
+        :param mapping: Mapping used
+        :param revinfo: Tuple with (revno, revid, hidden)
+        :param stored_lhs_parent_revid: Stored lhs parent revision
+        """
+        raise NotImplementedError(self.insert_revision)
+
+    def get_revision(self, foreign_revid, mapping):
+        """Get the revision metadata info for a (foreign_revid, mapping) tuple.
+
+        :param foreign_revid: Foreign revision id
+        :param mapping: Mapping
+        :return: Tuple with (stored revno, revid, hidden),
+            stored_lhs_parent_revid
+        """
+        raise NotImplementedError(self.get_revision)
+
+    def get_original_mapping(self, foreign_revid):
+        """Find the original mapping for a revision.
+
+        :param foreign_revid: Foreign revision id
+        :return: Mapping object or None
+        """
+        raise NotImplementedError(self.get_original_mapping)

=== modified file 'tests/test_cache.py'
--- tests/test_cache.py	2010-10-06 15:16:50 +0000
+++ tests/test_cache.py	2011-02-01 09:52:50 +0000
@@ -69,8 +69,8 @@
 
     def setUp(self):
         super(SqliteLogCacheTests, self).setUp()
-        from bzrlib.plugins.svn.cache.sqlitecache import LogCache
-        self.cache = LogCache()
+        from bzrlib.plugins.svn.cache.sqlitecache import SqliteLogCache
+        self.cache = SqliteLogCache()
 
 
 class TdbLogCacheTests(TestCaseInTempDir,LogCacheTests):
@@ -78,11 +78,11 @@
     def setUp(self):
         super(TdbLogCacheTests, self).setUp()
         try:
-            from bzrlib.plugins.svn.cache.tdbcache import LogCache, tdb_open
+            from bzrlib.plugins.svn.cache.tdbcache import TdbLogCache, tdb_open
         except ImportError:
             raise UnavailableFeature("tdb")
         import tdb
-        self.cache = LogCache(tdb_open("cache.tdb", 0, tdb.DEFAULT, os.O_RDWR|os.O_CREAT))
+        self.cache = TdbLogCache(tdb_open("cache.tdb", 0, tdb.DEFAULT, os.O_RDWR|os.O_CREAT))
 
 
 class RevidMapCacheTests(object):
@@ -124,8 +124,8 @@
 
     def setUp(self):
         super(SqliteRevidMapCacheTests, self).setUp()
-        from bzrlib.plugins.svn.cache.sqlitecache import RevisionIdMapCache
-        self.cache = RevisionIdMapCache()
+        from bzrlib.plugins.svn.cache.sqlitecache import SqliteRevisionIdMapCache
+        self.cache = SqliteRevisionIdMapCache()
 
 
 class TdbRevidMapCacheTests(TestCaseInTempDir,RevidMapCacheTests):
@@ -133,11 +133,11 @@
     def setUp(self):
         super(TdbRevidMapCacheTests, self).setUp()
         try:
-            from bzrlib.plugins.svn.cache.tdbcache import RevisionIdMapCache, tdb_open
+            from bzrlib.plugins.svn.cache.tdbcache import TdbRevisionIdMapCache, tdb_open
         except ImportError:
             raise UnavailableFeature("tdb")
         import tdb
-        self.cache = RevisionIdMapCache(tdb_open("cache.tdb", 0, tdb.DEFAULT, os.O_RDWR|os.O_CREAT))
+        self.cache = TdbRevisionIdMapCache(tdb_open("cache.tdb", 0, tdb.DEFAULT, os.O_RDWR|os.O_CREAT))
 
 
 class RevInfoCacheTests(object):
@@ -185,8 +185,8 @@
 
     def setUp(self):
         super(SqliteRevInfoCacheTests, self).setUp()
-        from bzrlib.plugins.svn.cache.sqlitecache import RevisionInfoCache
-        self.cache = RevisionInfoCache()
+        from bzrlib.plugins.svn.cache.sqlitecache import SqliteRevisionInfoCache
+        self.cache = SqliteRevisionInfoCache()
 
 
 class TdbRevInfoCacheTests(TestCaseInTempDir,RevInfoCacheTests):
@@ -194,11 +194,11 @@
     def setUp(self):
         super(TdbRevInfoCacheTests, self).setUp()
         try:
-            from bzrlib.plugins.svn.cache.tdbcache import RevisionInfoCache, tdb_open
+            from bzrlib.plugins.svn.cache.tdbcache import TdbRevisionInfoCache, tdb_open
         except ImportError:
             raise UnavailableFeature("tdb")
         import tdb
-        self.cache = RevisionInfoCache(tdb_open("cache.tdb", 0, tdb.DEFAULT, os.O_RDWR|os.O_CREAT))
+        self.cache = TdbRevisionInfoCache(tdb_open("cache.tdb", 0, tdb.DEFAULT, os.O_RDWR|os.O_CREAT))
 
 
 class ParentsCacheTests:
@@ -228,8 +228,8 @@
 
     def setUp(self):
         super(SqliteParentsCacheTests, self).setUp()
-        from bzrlib.plugins.svn.cache.sqlitecache import ParentsCache
-        self.cache = ParentsCache()
+        from bzrlib.plugins.svn.cache.sqlitecache import SqliteParentsCache
+        self.cache = SqliteParentsCache()
 
 
 class TdbParentsCacheTests(TestCaseInTempDir,ParentsCacheTests):
@@ -237,8 +237,8 @@
     def setUp(self):
         super(TdbParentsCacheTests, self).setUp()
         try:
-            from bzrlib.plugins.svn.cache.tdbcache import ParentsCache, tdb_open
+            from bzrlib.plugins.svn.cache.tdbcache import TdbParentsCache, tdb_open
         except ImportError:
             raise UnavailableFeature("tdb")
         import tdb
-        self.cache = ParentsCache(tdb_open("cache.tdb", 0, tdb.DEFAULT, os.O_RDWR|os.O_CREAT))
+        self.cache = TdbParentsCache(tdb_open("cache.tdb", 0, tdb.DEFAULT, os.O_RDWR|os.O_CREAT))

=== modified file 'tests/test_logwalker.py'
--- tests/test_logwalker.py	2010-08-08 13:35:10 +0000
+++ tests/test_logwalker.py	2011-02-01 09:52:50 +0000
@@ -588,8 +588,8 @@
         logwalker.cache_dir = os.path.join(self.test_dir, "cache-dir")
 
     def get_log_walker(self, transport):
-        from bzrlib.plugins.svn.cache.sqlitecache import LogCache
-        return logwalker.CachingLogWalker(super(TestCachingLogWalker, self).get_log_walker(transport), LogCache())
+        from bzrlib.plugins.svn.cache.sqlitecache import SqliteLogCache
+        return logwalker.CachingLogWalker(super(TestCachingLogWalker, self).get_log_walker(transport), SqliteLogCache())
 
 
 

=== modified file 'tests/test_parents.py'
--- tests/test_parents.py	2010-07-26 21:59:02 +0000
+++ tests/test_parents.py	2011-02-01 09:52:50 +0000
@@ -33,9 +33,9 @@
         TestCase.setUp(self)
         dict_pp = _mod_graph.DictParentsProvider({'a':('b',)})
         self.inst_pp = InstrumentedParentsProvider(dict_pp)
-        from bzrlib.plugins.svn.cache.sqlitecache import ParentsCache
+        from bzrlib.plugins.svn.cache.sqlitecache import SqliteParentsCache
         self.caching_pp = DiskCachingParentsProvider(self.inst_pp,
-                ParentsCache())
+                SqliteParentsCache())
 
     def test_get_parent_map(self):
         """Requesting the same revision should be returned from cache"""