I did this file separately because it's a _ton_ of hits and it had
some manual reformatting fallout as a result of black squeezing some
expressions onto a single line.
| Automatic diff as part of commit; lint not applicable. |
| Automatic diff as part of commit; unit tests not applicable. |
| Path | Packages | |||
|---|---|---|---|---|
| M | hgext/sqlitestore.py (188 lines) |
| FLAG_CENSORED = 1 | FLAG_CENSORED = 1 | ||||
| FLAG_MISSING_P1 = 2 | FLAG_MISSING_P1 = 2 | ||||
| FLAG_MISSING_P2 = 4 | 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 (' | 'CREATE TABLE delta (' | ||||
| r' id INTEGER PRIMARY KEY, ' | ' id INTEGER PRIMARY KEY, ' | ||||
| r' compression INTEGER NOT NULL, ' | ' compression INTEGER NOT NULL, ' | ||||
| r' hash BLOB UNIQUE ON CONFLICT ABORT, ' | ' hash BLOB UNIQUE ON CONFLICT ABORT, ' | ||||
| r' delta BLOB NOT NULL ' | ' delta BLOB NOT NULL ' | ||||
| r')', | ')', | ||||
| # Tracked paths are denormalized to integers to avoid redundant | # Tracked paths are denormalized to integers to avoid redundant | ||||
| # storage of the path name. | # storage of the path name. | ||||
| r'CREATE TABLE filepath (' | 'CREATE TABLE filepath (' | ||||
| r' id INTEGER PRIMARY KEY, ' | ' id INTEGER PRIMARY KEY, ' | ||||
| r' path BLOB NOT NULL ' | ' path BLOB NOT NULL ' | ||||
| r')', | ')', | ||||
| r'CREATE UNIQUE INDEX filepath_path ' r' ON filepath (path)', | 'CREATE UNIQUE INDEX filepath_path ON filepath (path)', | ||||
| # We have a single table for all file revision data. | # We have a single table for all file revision data. | ||||
| # Each file revision is uniquely described by a (path, rev) and | # Each file revision is uniquely described by a (path, rev) and | ||||
| # (path, node). | # (path, node). | ||||
| # | # | ||||
| # Revision data is stored as a pointer to the delta producing this | # Revision data is stored as a pointer to the delta producing this | ||||
| # revision and the file revision whose delta should be applied before | # revision and the file revision whose delta should be applied before | ||||
| # that one. One can reconstruct the delta chain by recursively following | # that one. One can reconstruct the delta chain by recursively following | ||||
| # the delta base revision pointers until one encounters NULL. | # the delta base revision pointers until one encounters NULL. | ||||
| # | # | ||||
| # flags column holds bitwise integer flags controlling storage options. | # flags column holds bitwise integer flags controlling storage options. | ||||
| # These flags are defined by the FLAG_* constants. | # These flags are defined by the FLAG_* constants. | ||||
| r'CREATE TABLE fileindex (' | 'CREATE TABLE fileindex (' | ||||
| r' id INTEGER PRIMARY KEY, ' | ' id INTEGER PRIMARY KEY, ' | ||||
| r' pathid INTEGER REFERENCES filepath(id), ' | ' pathid INTEGER REFERENCES filepath(id), ' | ||||
| r' revnum INTEGER NOT NULL, ' | ' revnum INTEGER NOT NULL, ' | ||||
| r' p1rev INTEGER NOT NULL, ' | ' p1rev INTEGER NOT NULL, ' | ||||
| r' p2rev INTEGER NOT NULL, ' | ' p2rev INTEGER NOT NULL, ' | ||||
| r' linkrev INTEGER NOT NULL, ' | ' linkrev INTEGER NOT NULL, ' | ||||
| r' flags INTEGER NOT NULL, ' | ' flags INTEGER NOT NULL, ' | ||||
| r' deltaid INTEGER REFERENCES delta(id), ' | ' deltaid INTEGER REFERENCES delta(id), ' | ||||
| r' deltabaseid INTEGER REFERENCES fileindex(id), ' | ' deltabaseid INTEGER REFERENCES fileindex(id), ' | ||||
| r' node BLOB NOT NULL ' | ' node BLOB NOT NULL ' | ||||
| r')', | ')', | ||||
| r'CREATE UNIQUE INDEX fileindex_pathrevnum ' | 'CREATE UNIQUE INDEX fileindex_pathrevnum ' | ||||
| r' ON fileindex (pathid, revnum)', | ' ON fileindex (pathid, revnum)', | ||||
| r'CREATE UNIQUE INDEX fileindex_pathnode ' | 'CREATE UNIQUE INDEX fileindex_pathnode ON fileindex (pathid, node)', | ||||
| r' ON fileindex (pathid, node)', | |||||
| # Provide a view over all file data for convenience. | # Provide a view over all file data for convenience. | ||||
| r'CREATE VIEW filedata AS ' | 'CREATE VIEW filedata AS ' | ||||
| r'SELECT ' | 'SELECT ' | ||||
| r' fileindex.id AS id, ' | ' fileindex.id AS id, ' | ||||
| r' filepath.id AS pathid, ' | ' filepath.id AS pathid, ' | ||||
| r' filepath.path AS path, ' | ' filepath.path AS path, ' | ||||
| r' fileindex.revnum AS revnum, ' | ' fileindex.revnum AS revnum, ' | ||||
| r' fileindex.node AS node, ' | ' fileindex.node AS node, ' | ||||
| r' fileindex.p1rev AS p1rev, ' | ' fileindex.p1rev AS p1rev, ' | ||||
| r' fileindex.p2rev AS p2rev, ' | ' fileindex.p2rev AS p2rev, ' | ||||
| r' fileindex.linkrev AS linkrev, ' | ' fileindex.linkrev AS linkrev, ' | ||||
| r' fileindex.flags AS flags, ' | ' fileindex.flags AS flags, ' | ||||
| r' fileindex.deltaid AS deltaid, ' | ' fileindex.deltaid AS deltaid, ' | ||||
| r' fileindex.deltabaseid AS deltabaseid ' | ' fileindex.deltabaseid AS deltabaseid ' | ||||
| r'FROM filepath, fileindex ' | 'FROM filepath, fileindex ' | ||||
| r'WHERE fileindex.pathid=filepath.id', | 'WHERE fileindex.pathid=filepath.id', | ||||
| r'PRAGMA user_version=%d' % CURRENT_SCHEMA_VERSION, | 'PRAGMA user_version=%d' % CURRENT_SCHEMA_VERSION, | ||||
| ] | ] | ||||
| def resolvedeltachain(db, pathid, node, revisioncache, stoprids, zstddctx=None): | def resolvedeltachain(db, pathid, node, revisioncache, stoprids, zstddctx=None): | ||||
| """Resolve a delta chain for a file node.""" | """Resolve a delta chain for a file node.""" | ||||
| # TODO the "not in ({stops})" here is possibly slowing down the query | # TODO the "not in ({stops})" here is possibly slowing down the query | ||||
| # because it needs to perform the lookup on every recursive invocation. | # because it needs to perform the lookup on every recursive invocation. | ||||
| # This could possibly be faster if we created a temporary query with | # This could possibly be faster if we created a temporary query with | ||||
| # baseid "poisoned" to null and limited the recursive filter to | # baseid "poisoned" to null and limited the recursive filter to | ||||
| # "is not null". | # "is not null". | ||||
| res = db.execute( | res = db.execute( | ||||
| r'WITH RECURSIVE ' | 'WITH RECURSIVE ' | ||||
| r' deltachain(deltaid, baseid) AS (' | ' deltachain(deltaid, baseid) AS (' | ||||
| r' SELECT deltaid, deltabaseid FROM fileindex ' | ' SELECT deltaid, deltabaseid FROM fileindex ' | ||||
| r' WHERE pathid=? AND node=? ' | ' WHERE pathid=? AND node=? ' | ||||
| r' UNION ALL ' | ' UNION ALL ' | ||||
| r' SELECT fileindex.deltaid, deltabaseid ' | ' SELECT fileindex.deltaid, deltabaseid ' | ||||
| r' FROM fileindex, deltachain ' | ' FROM fileindex, deltachain ' | ||||
| r' WHERE ' | ' WHERE ' | ||||
| r' fileindex.id=deltachain.baseid ' | ' fileindex.id=deltachain.baseid ' | ||||
| r' AND deltachain.baseid IS NOT NULL ' | ' AND deltachain.baseid IS NOT NULL ' | ||||
| r' AND fileindex.id NOT IN ({stops}) ' | ' AND fileindex.id NOT IN ({stops}) ' | ||||
| r' ) ' | ' ) ' | ||||
| r'SELECT deltachain.baseid, compression, delta ' | 'SELECT deltachain.baseid, compression, delta ' | ||||
| r'FROM deltachain, delta ' | 'FROM deltachain, delta ' | ||||
| r'WHERE delta.id=deltachain.deltaid'.format( | 'WHERE delta.id=deltachain.deltaid'.format( | ||||
| stops=r','.join([r'?'] * len(stoprids)) | stops=','.join(['?'] * len(stoprids)) | ||||
| ), | ), | ||||
| tuple([pathid, node] + list(stoprids.keys())), | tuple([pathid, node] + list(stoprids.keys())), | ||||
| ) | ) | ||||
| deltas = [] | deltas = [] | ||||
| lastdeltabaseid = None | lastdeltabaseid = None | ||||
| for deltabaseid, compression, delta in res: | for deltabaseid, compression, delta in res: | ||||
| fulltext = bytes(delta) | fulltext = bytes(delta) | ||||
| return fulltext | return fulltext | ||||
| def insertdelta(db, compression, hash, delta): | def insertdelta(db, compression, hash, delta): | ||||
| try: | try: | ||||
| return db.execute( | return db.execute( | ||||
| r'INSERT INTO delta (compression, hash, delta) ' | 'INSERT INTO delta (compression, hash, delta) VALUES (?, ?, ?)', | ||||
| r'VALUES (?, ?, ?)', | |||||
| (compression, hash, delta), | (compression, hash, delta), | ||||
| ).lastrowid | ).lastrowid | ||||
| except sqlite3.IntegrityError: | except sqlite3.IntegrityError: | ||||
| return db.execute( | return db.execute( | ||||
| r'SELECT id FROM delta WHERE hash=?', (hash,) | 'SELECT id FROM delta WHERE hash=?', (hash,) | ||||
| ).fetchone()[0] | ).fetchone()[0] | ||||
| class SQLiteStoreError(error.StorageError): | class SQLiteStoreError(error.StorageError): | ||||
| pass | pass | ||||
| @attr.s | @attr.s | ||||
| def _refreshindex(self): | def _refreshindex(self): | ||||
| self._revtonode = {} | self._revtonode = {} | ||||
| self._nodetorev = {} | self._nodetorev = {} | ||||
| self._revisions = {} | self._revisions = {} | ||||
| res = list( | res = list( | ||||
| self._db.execute( | self._db.execute( | ||||
| r'SELECT id FROM filepath WHERE path=?', (self._path,) | 'SELECT id FROM filepath WHERE path=?', (self._path,) | ||||
| ) | ) | ||||
| ) | ) | ||||
| if not res: | if not res: | ||||
| self._pathid = None | self._pathid = None | ||||
| return | return | ||||
| self._pathid = res[0][0] | self._pathid = res[0][0] | ||||
| res = self._db.execute( | res = self._db.execute( | ||||
| r'SELECT id, revnum, node, p1rev, p2rev, linkrev, flags ' | 'SELECT id, revnum, node, p1rev, p2rev, linkrev, flags ' | ||||
| r'FROM fileindex ' | 'FROM fileindex ' | ||||
| r'WHERE pathid=? ' | 'WHERE pathid=? ' | ||||
| r'ORDER BY revnum ASC', | 'ORDER BY revnum ASC', | ||||
| (self._pathid,), | (self._pathid,), | ||||
| ) | ) | ||||
| for i, row in enumerate(res): | for i, row in enumerate(res): | ||||
| rid, rev, node, p1rev, p2rev, linkrev, flags = row | rid, rev, node, p1rev, p2rev, linkrev, flags = row | ||||
| if i != rev: | if i != rev: | ||||
| raise SQLiteStoreError( | raise SQLiteStoreError( | ||||
| ) | ) | ||||
| return [self.node(rev) for rev in revs] | return [self.node(rev) for rev in revs] | ||||
| def children(self, node): | def children(self, node): | ||||
| rev = self.rev(node) | rev = self.rev(node) | ||||
| res = self._db.execute( | res = self._db.execute( | ||||
| r'SELECT' | 'SELECT' | ||||
| r' node ' | ' node ' | ||||
| r' FROM filedata ' | ' FROM filedata ' | ||||
| r' WHERE path=? AND (p1rev=? OR p2rev=?) ' | ' WHERE path=? AND (p1rev=? OR p2rev=?) ' | ||||
| r' ORDER BY revnum ASC', | ' ORDER BY revnum ASC', | ||||
| (self._path, rev, rev), | (self._path, rev, rev), | ||||
| ) | ) | ||||
| return [row[0] for row in res] | return [row[0] for row in res] | ||||
| # End of ifileindex interface. | # End of ifileindex interface. | ||||
| # Start of ifiledata interface. | # Start of ifiledata interface. | ||||
| nodes = [n for n in nodes if n != nullid] | nodes = [n for n in nodes if n != nullid] | ||||
| if not nodes: | if not nodes: | ||||
| return | return | ||||
| # TODO perform in a single query. | # TODO perform in a single query. | ||||
| res = self._db.execute( | res = self._db.execute( | ||||
| r'SELECT revnum, deltaid FROM fileindex ' | 'SELECT revnum, deltaid FROM fileindex ' | ||||
| r'WHERE pathid=? ' | 'WHERE pathid=? ' | ||||
| r' AND node in (%s)' % (r','.join([r'?'] * len(nodes))), | ' AND node in (%s)' % (','.join(['?'] * len(nodes))), | ||||
| tuple([self._pathid] + nodes), | tuple([self._pathid] + nodes), | ||||
| ) | ) | ||||
| deltabases = {} | deltabases = {} | ||||
| for rev, deltaid in res: | for rev, deltaid in res: | ||||
| res = self._db.execute( | res = self._db.execute( | ||||
| r'SELECT revnum from fileindex WHERE pathid=? AND deltaid=?', | 'SELECT revnum from fileindex WHERE pathid=? AND deltaid=?', | ||||
| (self._pathid, deltaid), | (self._pathid, deltaid), | ||||
| ) | ) | ||||
| deltabases[rev] = res.fetchone()[0] | deltabases[rev] = res.fetchone()[0] | ||||
| # TODO define revdifffn so we can use delta from storage. | # TODO define revdifffn so we can use delta from storage. | ||||
| for delta in storageutil.emitrevisions( | for delta in storageutil.emitrevisions( | ||||
| self, | self, | ||||
| nodes, | nodes, | ||||
| entry = self._revisions[node] | entry = self._revisions[node] | ||||
| if entry.flags & FLAG_MISSING_P1 and p1 != nullid: | if entry.flags & FLAG_MISSING_P1 and p1 != nullid: | ||||
| entry.p1node = p1 | entry.p1node = p1 | ||||
| entry.p1rev = self._nodetorev[p1] | entry.p1rev = self._nodetorev[p1] | ||||
| entry.flags &= ~FLAG_MISSING_P1 | entry.flags &= ~FLAG_MISSING_P1 | ||||
| self._db.execute( | self._db.execute( | ||||
| r'UPDATE fileindex SET p1rev=?, flags=? ' r'WHERE id=?', | 'UPDATE fileindex SET p1rev=?, flags=? WHERE id=?', | ||||
| (self._nodetorev[p1], entry.flags, entry.rid), | (self._nodetorev[p1], entry.flags, entry.rid), | ||||
| ) | ) | ||||
| if entry.flags & FLAG_MISSING_P2 and p2 != nullid: | if entry.flags & FLAG_MISSING_P2 and p2 != nullid: | ||||
| entry.p2node = p2 | entry.p2node = p2 | ||||
| entry.p2rev = self._nodetorev[p2] | entry.p2rev = self._nodetorev[p2] | ||||
| entry.flags &= ~FLAG_MISSING_P2 | entry.flags &= ~FLAG_MISSING_P2 | ||||
| self._db.execute( | self._db.execute( | ||||
| r'UPDATE fileindex SET p2rev=?, flags=? ' r'WHERE id=?', | 'UPDATE fileindex SET p2rev=?, flags=? WHERE id=?', | ||||
| (self._nodetorev[p1], entry.flags, entry.rid), | (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 | ||||
| # While "better," more complex strategies are possible, we do something | # While "better," more complex strategies are possible, we do something | ||||
| # simple: we find delta chain children of the censored revision and we | # simple: we find delta chain children of the censored revision and we | ||||
| # replace those incremental deltas with fulltexts of their corresponding | # replace those incremental deltas with fulltexts of their corresponding | ||||
| # revision. Then we delete the now-unreferenced delta and original | # revision. Then we delete the now-unreferenced delta and original | ||||
| # revision and insert a replacement. | # revision and insert a replacement. | ||||
| # Find the delta to be censored. | # Find the delta to be censored. | ||||
| censoreddeltaid = self._db.execute( | censoreddeltaid = self._db.execute( | ||||
| r'SELECT deltaid FROM fileindex WHERE id=?', | 'SELECT deltaid FROM fileindex WHERE id=?', | ||||
| (self._revisions[censornode].rid,), | (self._revisions[censornode].rid,), | ||||
| ).fetchone()[0] | ).fetchone()[0] | ||||
| # Find all its delta chain children. | # Find all its delta chain children. | ||||
| # TODO once we support storing deltas for !files, we'll need to look | # TODO once we support storing deltas for !files, we'll need to look | ||||
| # for those delta chains too. | # for those delta chains too. | ||||
| rows = list( | rows = list( | ||||
| self._db.execute( | self._db.execute( | ||||
| r'SELECT id, pathid, node FROM fileindex ' | 'SELECT id, pathid, node FROM fileindex ' | ||||
| r'WHERE deltabaseid=? OR deltaid=?', | 'WHERE deltabaseid=? OR deltaid=?', | ||||
| (censoreddeltaid, censoreddeltaid), | (censoreddeltaid, censoreddeltaid), | ||||
| ) | ) | ||||
| ) | ) | ||||
| for row in rows: | for row in rows: | ||||
| rid, pathid, node = row | rid, pathid, node = row | ||||
| fulltext = resolvedeltachain( | fulltext = resolvedeltachain( | ||||
| if len(deltablob) >= len(fulltext): | if len(deltablob) >= len(fulltext): | ||||
| deltablob = fulltext | deltablob = fulltext | ||||
| compression = COMPRESSION_NONE | compression = COMPRESSION_NONE | ||||
| deltaid = insertdelta(self._db, compression, deltahash, deltablob) | deltaid = insertdelta(self._db, compression, deltahash, deltablob) | ||||
| self._db.execute( | self._db.execute( | ||||
| r'UPDATE fileindex SET deltaid=?, deltabaseid=NULL ' | 'UPDATE fileindex SET deltaid=?, deltabaseid=NULL ' | ||||
| r'WHERE id=?', | 'WHERE id=?', | ||||
| (deltaid, rid), | (deltaid, rid), | ||||
| ) | ) | ||||
| # Now create the tombstone delta and replace the delta on the censored | # Now create the tombstone delta and replace the delta on the censored | ||||
| # node. | # node. | ||||
| deltahash = hashlib.sha1(tombstone).digest() | deltahash = hashlib.sha1(tombstone).digest() | ||||
| tombstonedeltaid = insertdelta( | tombstonedeltaid = insertdelta( | ||||
| self._db, COMPRESSION_NONE, deltahash, tombstone | self._db, COMPRESSION_NONE, deltahash, tombstone | ||||
| ) | ) | ||||
| flags = self._revisions[censornode].flags | flags = self._revisions[censornode].flags | ||||
| flags |= FLAG_CENSORED | flags |= FLAG_CENSORED | ||||
| self._db.execute( | self._db.execute( | ||||
| r'UPDATE fileindex SET flags=?, deltaid=?, deltabaseid=NULL ' | 'UPDATE fileindex SET flags=?, deltaid=?, deltabaseid=NULL ' | ||||
| r'WHERE pathid=? AND node=?', | 'WHERE pathid=? AND node=?', | ||||
| (flags, tombstonedeltaid, self._pathid, censornode), | (flags, tombstonedeltaid, self._pathid, censornode), | ||||
| ) | ) | ||||
| self._db.execute(r'DELETE FROM delta WHERE id=?', (censoreddeltaid,)) | self._db.execute('DELETE FROM delta WHERE id=?', (censoreddeltaid,)) | ||||
| self._refreshindex() | self._refreshindex() | ||||
| self._revisioncache.clear() | self._revisioncache.clear() | ||||
| def getstrippoint(self, minlink): | def getstrippoint(self, minlink): | ||||
| return storageutil.resolvestripinfo( | return storageutil.resolvestripinfo( | ||||
| minlink, | minlink, | ||||
| len(self) - 1, | len(self) - 1, | ||||
| [self.rev(n) for n in self.heads()], | [self.rev(n) for n in self.heads()], | ||||
| self.linkrev, | self.linkrev, | ||||
| self.parentrevs, | self.parentrevs, | ||||
| ) | ) | ||||
| def strip(self, minlink, transaction): | def strip(self, minlink, transaction): | ||||
| if not len(self): | if not len(self): | ||||
| return | return | ||||
| rev, _ignored = self.getstrippoint(minlink) | rev, _ignored = self.getstrippoint(minlink) | ||||
| if rev == len(self): | if rev == len(self): | ||||
| return | return | ||||
| for rev in self.revs(rev): | for rev in self.revs(rev): | ||||
| self._db.execute( | self._db.execute( | ||||
| r'DELETE FROM fileindex WHERE pathid=? AND node=?', | 'DELETE FROM fileindex WHERE pathid=? AND node=?', | ||||
| (self._pathid, self.node(rev)), | (self._pathid, self.node(rev)), | ||||
| ) | ) | ||||
| # TODO how should we garbage collect data in delta table? | # TODO how should we garbage collect data in delta table? | ||||
| self._refreshindex() | self._refreshindex() | ||||
| # End of ifilemutation interface. | # End of ifilemutation interface. | ||||
| linkrev, | linkrev, | ||||
| p1, | p1, | ||||
| p2, | p2, | ||||
| storedelta=None, | storedelta=None, | ||||
| flags=0, | flags=0, | ||||
| ): | ): | ||||
| if self._pathid is None: | if self._pathid is None: | ||||
| res = self._db.execute( | res = self._db.execute( | ||||
| r'INSERT INTO filepath (path) VALUES (?)', (self._path,) | 'INSERT INTO filepath (path) VALUES (?)', (self._path,) | ||||
| ) | ) | ||||
| self._pathid = res.lastrowid | self._pathid = res.lastrowid | ||||
| # For simplicity, always store a delta against p1. | # For simplicity, always store a delta against p1. | ||||
| # TODO we need a lot more logic here to make behavior reasonable. | # TODO we need a lot more logic here to make behavior reasonable. | ||||
| if storedelta: | if storedelta: | ||||
| deltabase, delta = storedelta | deltabase, delta = storedelta | ||||
| p1rev = self._nodetorev[p1] | p1rev = self._nodetorev[p1] | ||||
| if p2 == nullid: | if p2 == nullid: | ||||
| p2rev = nullrev | p2rev = nullrev | ||||
| else: | else: | ||||
| p2rev = self._nodetorev[p2] | p2rev = self._nodetorev[p2] | ||||
| rid = self._db.execute( | rid = self._db.execute( | ||||
| r'INSERT INTO fileindex (' | 'INSERT INTO fileindex (' | ||||
| r' pathid, revnum, node, p1rev, p2rev, linkrev, flags, ' | ' pathid, revnum, node, p1rev, p2rev, linkrev, flags, ' | ||||
| r' deltaid, deltabaseid) ' | ' deltaid, deltabaseid) ' | ||||
| r' VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)', | ' VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)', | ||||
| ( | ( | ||||
| self._pathid, | self._pathid, | ||||
| rev, | rev, | ||||
| node, | node, | ||||
| p1rev, | p1rev, | ||||
| p2rev, | p2rev, | ||||
| linkrev, | linkrev, | ||||
| flags, | flags, | ||||
| def transaction(self, *args, **kwargs): | def transaction(self, *args, **kwargs): | ||||
| current = self.currenttransaction() | current = self.currenttransaction() | ||||
| tr = super(sqliterepository, self).transaction(*args, **kwargs) | tr = super(sqliterepository, self).transaction(*args, **kwargs) | ||||
| if current: | if current: | ||||
| return tr | return tr | ||||
| self._dbconn.execute(r'BEGIN TRANSACTION') | self._dbconn.execute('BEGIN TRANSACTION') | ||||
| def committransaction(_): | def committransaction(_): | ||||
| self._dbconn.commit() | self._dbconn.commit() | ||||
| tr.addfinalize(b'sqlitestore', committransaction) | tr.addfinalize(b'sqlitestore', committransaction) | ||||
| return tr | return tr | ||||
| def makedb(path): | def makedb(path): | ||||
| """Construct a database handle for a database at path.""" | """Construct a database handle for a database at path.""" | ||||
| db = sqlite3.connect(encoding.strfromlocal(path)) | db = sqlite3.connect(encoding.strfromlocal(path)) | ||||
| db.text_factory = bytes | db.text_factory = bytes | ||||
| res = db.execute(r'PRAGMA user_version').fetchone()[0] | res = db.execute('PRAGMA user_version').fetchone()[0] | ||||
| # New database. | # New database. | ||||
| if res == 0: | if res == 0: | ||||
| for statement in CREATE_SCHEMA: | for statement in CREATE_SCHEMA: | ||||
| db.execute(statement) | db.execute(statement) | ||||
| db.commit() | db.commit() | ||||
| elif res == CURRENT_SCHEMA_VERSION: | elif res == CURRENT_SCHEMA_VERSION: | ||||
| pass | pass | ||||
| else: | else: | ||||
| raise error.Abort(_(b'sqlite database has unrecognized version')) | raise error.Abort(_(b'sqlite database has unrecognized version')) | ||||
| db.execute(r'PRAGMA journal_mode=WAL') | db.execute('PRAGMA journal_mode=WAL') | ||||
| return db | return db | ||||
| def featuresetup(ui, supported): | def featuresetup(ui, supported): | ||||
| supported.add(REQUIREMENT) | supported.add(REQUIREMENT) | ||||
| if zstd: | if zstd: | ||||