mercurial: comparison hgext/sqlitestore.py

equal deleted inserted replaced

-:5fa019ceb499
+:d55b71393907
 import threading
 import zlib
 from mercurial.i18n import _
 from mercurial.node import (
-nullid,
 nullrev,
 sha1nodeconstants,
 short,
 )
 from mercurial.thirdparty import attr
 raise SQLiteStoreError(
 _(b'sqlite database has inconsistent revision numbers')
 )
 if p1rev == nullrev:
-p1node = nullid
+p1node = sha1nodeconstants.nullid
 else:
 p1node = self._revtonode[p1rev]
 if p2rev == nullrev:
-p2node = nullid
+p2node = sha1nodeconstants.nullid
 else:
 p2node = self._revtonode[p2rev]
 entry = revisionentry(
 rid=rid,
 def __iter__(self):
 return iter(pycompat.xrange(len(self._revisions)))
 def hasnode(self, node):
-if node == nullid:
+if node == sha1nodeconstants.nullid:
 return False
 return node in self._nodetorev
 def revs(self, start=0, stop=None):
 return storageutil.iterrevs(
 len(self._revisions), start=start, stop=stop
 )
 def parents(self, node):
-if node == nullid:
+if node == sha1nodeconstants.nullid:
-return nullid, nullid
+return sha1nodeconstants.nullid, sha1nodeconstants.nullid
 if node not in self._revisions:
 raise error.LookupError(node, self._path, _(b'no node'))
 entry = self._revisions[node]
 entry = self._revisions[self._revtonode[rev]]
 return entry.p1rev, entry.p2rev
 def rev(self, node):
-if node == nullid:
+if node == sha1nodeconstants.nullid:
 return nullrev
 if node not in self._nodetorev:
 raise error.LookupError(node, self._path, _(b'no node'))
 return self._nodetorev[node]
 def node(self, rev):
 if rev == nullrev:
-return nullid
+return sha1nodeconstants.nullid
 if rev not in self._revtonode:
 raise IndexError(rev)
 return self._revtonode[rev]
 return dagop.descendantrevs(revs, self.revs, self.parentrevs)
 def heads(self, start=None, stop=None):
 if start is None and stop is None:
 if not len(self):
-return [nullid]
+return [sha1nodeconstants.nullid]
 startrev = self.rev(start) if start is not None else nullrev
 stoprevs = {self.rev(n) for n in stop or []}
 revs = dagop.headrevssubset(
 return len(self.read(node))
 return len(self.revision(node))
 def revision(self, node, raw=False, _verifyhash=True):
-if node in (nullid, nullrev):
+if node in (sha1nodeconstants.nullid, nullrev):
 return b''
 if isinstance(node, int):
 node = self.node(node)
 if nodesorder not in (b'nodes', b'storage', b'linear', None):
 raise error.ProgrammingError(
 b'unhandled value for nodesorder: %s' % nodesorder
 )
-nodes = [n for n in nodes if n != nullid]
+nodes = [n for n in nodes if n != sha1nodeconstants.nullid]
 if not nodes:
 return
 # TODO perform in a single query.
 if wireflags & ~repository.REVISION_FLAG_CENSORED:
 raise SQLiteStoreError(b'unhandled revision flag')
 if maybemissingparents:
-if p1 != nullid and not self.hasnode(p1):
+if p1 != sha1nodeconstants.nullid and not self.hasnode(p1):
-p1 = nullid
+p1 = sha1nodeconstants.nullid
 storeflags |= FLAG_MISSING_P1
-if p2 != nullid and not self.hasnode(p2):
+if p2 != sha1nodeconstants.nullid and not self.hasnode(p2):
-p2 = nullid
+p2 = sha1nodeconstants.nullid
 storeflags |= FLAG_MISSING_P2
 baserev = self.rev(deltabase)
 # If base is censored, delta must be full replacement in a single
 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:
+if (
+entry.flags & FLAG_MISSING_P1
+and p1 != sha1nodeconstants.nullid
+):
 entry.p1node = p1
 entry.p1rev = self._nodetorev[p1]
 entry.flags &= ~FLAG_MISSING_P1
 self._db.execute(
 'UPDATE fileindex SET p1rev=?, flags=? WHERE id=?',
 (self._nodetorev[p1], entry.flags, entry.rid),
 )
-if entry.flags & FLAG_MISSING_P2 and p2 != nullid:
+if (
+entry.flags & FLAG_MISSING_P2
+and p2 != sha1nodeconstants.nullid
+):
 entry.p2node = p2
 entry.p2rev = self._nodetorev[p2]
 entry.flags &= ~FLAG_MISSING_P2
 self._db.execute(
 if duplicaterevisioncb:
 duplicaterevisioncb(self, self.rev(node))
 empty = False
 continue
-if deltabase == nullid:
+if deltabase == sha1nodeconstants.nullid:
 text = mdiff.patch(b'', delta)
 storedelta = None
 else:
 text = None
 storedelta = (deltabase, delta)
 else:
 assert revisiondata is not None
 deltabase = p1
-if deltabase == nullid:
+if deltabase == sha1nodeconstants.nullid:
 delta = revisiondata
 else:
 delta = mdiff.textdiff(
 self.revision(self.rev(deltabase)), revisiondata
 )
 # File index stores a pointer to its delta and the parent delta.
 # The parent delta is stored via a pointer to the fileindex PK.
-if deltabase == nullid:
+if deltabase == sha1nodeconstants.nullid:
 baseid = None
 else:
 baseid = self._revisions[deltabase].rid
 # Deltas are stored with a hash of their content. This allows
 deltaid = insertdelta(self._db, compression, deltahash, deltablob)
 rev = len(self)
-if p1 == nullid:
+if p1 == sha1nodeconstants.nullid:
 p1rev = nullrev
 else:
 p1rev = self._nodetorev[p1]
-if p2 == nullid:
+if p2 == sha1nodeconstants.nullid:
 p2rev = nullrev
 else:
 p2rev = self._nodetorev[p2]
 rid = self._db.execute(

changeset 47012	d55b71393907
parent 46780	6266d19556ad
child 47077	119790e1c67c