This is an archive of the discontinued Mercurial Phabricator instance.

Differential D5168

sqlitestore: support for storing revisions without their parents
ClosedPublic

Authored by indygreg on Oct 19 2018, 1:00 PM.

Details

Reviewers
None
Group Reviewers
hg-reviewers
Commits
rHG595641bd8404: sqlitestore: support for storing revisions without their parents
Summary

This commit kinda/sorta implements the equivalent of ellipsis nodes for
the SQLite storage backend.

Without implementing full blown ellipsis nodes (and the necessary support for
them in the wire protocol), we instead teach the store to rewrite the p1 and
p2 nodes to nullid when the incoming parent isn't in the local store. This allows
servers to remain dumb and send the real parent and have the clients deal
with the missing parent problem.

This obviously isn't ideal because a benefit of ellipsis nodes is we can
insert a fake parent to ellide missing changesets. But neither solution is
ideal because it drops the original parent from storage. We could probably
teach the SQLite store to retain the original parent and handle missing
parents at read time. However, parent revisions are stored as integers and
it isn't trivial to store an "empty" revision in the store yet, which would
be necessary to represent the "missing" parent.

The store is somewhat intelligent in trying to remove the missing parents
metadata when the revision is re-added. But, revision numbers will be all
messed up in that case, so I'm not sure it is worth it. At some point we'll
likely want to remove the concept of revision numbers from the database and
have the store invent them at index generation time. Or even better, we can
do away with revision numbers from the file storage interface completely.
We'll get there eventually...

Diff Detail

Repository
rHG Mercurial
Lint
Automatic diff as part of commit; lint not applicable.
Unit
Automatic diff as part of commit; unit tests not applicable.

Revision Contents
Changeset List

Diff 12304

hgext/sqlitestore.py

CURRENT_SCHEMA_VERSION = 1 CURRENT_SCHEMA_VERSION = 1
COMPRESSION_NONE = 1 COMPRESSION_NONE = 1
COMPRESSION_ZSTD = 2 COMPRESSION_ZSTD = 2
COMPRESSION_ZLIB = 3 COMPRESSION_ZLIB = 3
FLAG_CENSORED = 1 FLAG_CENSORED = 1
FLAG_MISSING_P1 = 2
FLAG_MISSING_P2 = 4
CREATE_SCHEMA = [ CREATE_SCHEMA = [
# Deltas are stored as content-indexed blobs. # Deltas are stored as content-indexed blobs.
# compression column holds COMPRESSION_* constant for how the # compression column holds COMPRESSION_* constant for how the
# delta is encoded. # delta is encoded.
r'CREATE TABLE delta (' r'CREATE TABLE delta ('
r' id INTEGER PRIMARY KEY, ' r' id INTEGER PRIMARY KEY, '
if not stoprids: if not stoprids:
stoprids[-1] = None stoprids[-1] = None
fulltext = resolvedeltachain(self._db, self._pathid, node, fulltext = resolvedeltachain(self._db, self._pathid, node,
self._revisioncache, stoprids, self._revisioncache, stoprids,
zstddctx=self._dctx) zstddctx=self._dctx)
# Don't verify hashes if parent nodes were rewritten, as the hash
# wouldn't verify.
if self._revisions[node].flags & (FLAG_MISSING_P1 | FLAG_MISSING_P2):
_verifyhash = False
if _verifyhash: if _verifyhash:
self._checkhash(fulltext, node) self._checkhash(fulltext, node)
self._revisioncache[node] = fulltext self._revisioncache[node] = fulltext
return fulltext return fulltext
def read(self, node): def read(self, node):
return storageutil.filtermetadata(self.revision(node)) return storageutil.filtermetadata(self.revision(node))
node = self._addrawrevision(node, revisiondata, transaction, linkrev, node = self._addrawrevision(node, revisiondata, transaction, linkrev,
p1, p2) p1, p2)
self._revisioncache[node] = revisiondata self._revisioncache[node] = revisiondata
return node return node
def addgroup(self, deltas, linkmapper, transaction, addrevisioncb=None, def addgroup(self, deltas, linkmapper, transaction, addrevisioncb=None,
maybemissingparents=False): maybemissingparents=False):
if maybemissingparents:
raise error.Abort(_('SQLite storage does not support missing '
'parents write mode'))
nodes = [] nodes = []
for node, p1, p2, linknode, deltabase, delta, wireflags in deltas: for node, p1, p2, linknode, deltabase, delta, wireflags in deltas:
storeflags = 0 storeflags = 0
if wireflags & repository.REVISION_FLAG_CENSORED: if wireflags & repository.REVISION_FLAG_CENSORED:
storeflags |= FLAG_CENSORED storeflags |= FLAG_CENSORED
if wireflags & ~repository.REVISION_FLAG_CENSORED: if wireflags & ~repository.REVISION_FLAG_CENSORED:
raise SQLiteStoreError('unhandled revision flag') raise SQLiteStoreError('unhandled revision flag')
if maybemissingparents:
if p1 != nullid and not self.hasnode(p1):
p1 = nullid
storeflags |= FLAG_MISSING_P1
if p2 != nullid and not self.hasnode(p2):
p2 = nullid
storeflags |= FLAG_MISSING_P2
baserev = self.rev(deltabase) baserev = self.rev(deltabase)
# If base is censored, delta must be full replacement in a single # If base is censored, delta must be full replacement in a single
# patch operation. # patch operation.
if baserev != nullrev and self.iscensored(baserev): if baserev != nullrev and self.iscensored(baserev):
hlen = struct.calcsize('>lll') hlen = struct.calcsize('>lll')
oldlen = len(self.revision(deltabase, raw=True, oldlen = len(self.revision(deltabase, raw=True,
_verifyhash=False)) _verifyhash=False))
newlen = len(delta) - hlen newlen = len(delta) - hlen
if delta[:hlen] != mdiff.replacediffheader(oldlen, newlen): if delta[:hlen] != mdiff.replacediffheader(oldlen, newlen):
raise error.CensoredBaseError(self._path, raise error.CensoredBaseError(self._path,
deltabase) deltabase)
if (not (storeflags & FLAG_CENSORED) if (not (storeflags & FLAG_CENSORED)
and storageutil.deltaiscensored( and storageutil.deltaiscensored(
delta, baserev, lambda x: len(self.revision(x, raw=True)))): delta, baserev, lambda x: len(self.revision(x, raw=True)))):
storeflags |= FLAG_CENSORED storeflags |= FLAG_CENSORED
linkrev = linkmapper(linknode) linkrev = linkmapper(linknode)
nodes.append(node) nodes.append(node)
if node in self._revisions: if node in self._revisions:
# Possibly reset parents to make them proper.
entry = self._revisions[node]
if entry.flags & FLAG_MISSING_P1 and p1 != nullid:
entry.p1node = p1
entry.p1rev = self._nodetorev[p1]
entry.flags &= ~FLAG_MISSING_P1
self._db.execute(
r'UPDATE fileindex SET p1rev=?, flags=? '
r'WHERE id=?',
(self._nodetorev[p1], entry.flags, entry.rid))
if entry.flags & FLAG_MISSING_P2 and p2 != nullid:
entry.p2node = p2
entry.p2rev = self._nodetorev[p2]
entry.flags &= ~FLAG_MISSING_P2
self._db.execute(
r'UPDATE fileindex SET p2rev=?, flags=? '
r'WHERE id=?',
(self._nodetorev[p1], entry.flags, entry.rid))
continue continue
if deltabase == nullid: if deltabase == nullid:
text = mdiff.patch(b'', delta) text = mdiff.patch(b'', delta)
storedelta = None storedelta = None
else: else:
text = None text = None
storedelta = (deltabase, delta) storedelta = (deltabase, delta)