sqlitestore: file storage backend using SQLite This commit provides an extension which uses SQLite to store file data (as opposed to revlogs). As the inline documentation describes, there are still several aspects to the extension that are incomplete. But it's a start. The extension does support basic clone, checkout, and commit workflows, which makes it suitable for simple use cases. One notable missing feature is support for "bundlerepos." This is probably responsible for the most test failures when the extension is activated as part of the test suite. All revision data is stored in SQLite. Data is stored as zstd compressed chunks (default if zstd is available), zlib compressed chunks (default if zstd is not available), or raw chunks (if configured or if a compressed delta is not smaller than the raw delta). This makes things very similar to revlogs. Unlike revlogs, the extension doesn't yet enforce a limit on delta chain length. This is an obvious limitation and should be addressed. This is somewhat mitigated by the use of zstd, which is much faster than zlib to decompress. There is a dedicated table for storing deltas. Deltas are stored by the SHA-1 hash of their uncompressed content. The "fileindex" table has columns that reference the delta for each revision and the base delta that delta should be applied against. A recursive SQL query is used to resolve the delta chain along with the delta data. By storing deltas by hash, we are able to de-duplicate delta storage! With revlogs, the same deltas in different revlogs would result in duplicate storage of that delta. In this scheme, inserting the duplicate delta is a no-op and delta chains simply reference the existing delta. When initially implementing this extension, I did not have content-indexed deltas and deltas could be duplicated across files (just like revlogs). When I implemented content-indexed deltas, the size of the SQLite database for a full clone of mozilla-unified dropped: before: 2,554,261,504 bytes after: 2,488,754,176 bytes Surprisingly, this is still larger than the bytes size of revlog files: revlog files: 2,104,861,230 bytes du -b: 2,254,381,614 I would have expected storage to be smaller since we're not limiting delta chain length and since we're using zstd instead of zlib. I suspect the SQLite indexes and per-column overhead account for the bulk of the differences. (Keep in mind that revlog uses a 64-byte packed struct for revision index data and deltas are stored without padding. Aside from the 12 unused bytes in the 32 byte node field, revlogs are pretty efficient.) Another source of overhead is file name storage. With revlogs, file names are stored in the filesystem. But with SQLite, we need to store file names in the database. This is roughly equivalent to the size of the fncache file, which for the mozilla-unified repository is ~34MB. Since the SQLite database isn't append-only and since delta chains can reference any delta, this opens some interesting possibilities. For example, we could store deltas in reverse, such that fulltexts are stored for newer revisions and deltas are applied to reconstruct older revisions. This is likely a more optimal storage strategy for version control, as new data tends to be more frequently accessed than old data. We would obviously need wire protocol support for transferring revision data from newest to oldest. And we would probably need some kind of mechanism for "re-encoding" stores. But it should be doable. This extension is very much experimental quality. There are a handful of features that don't work. It probably isn't suitable for day-to-day use. But it could be used in limited cases (e.g. read-only checkouts like in CI). And it is also a good proving ground for alternate storage backends. As we continue to define interfaces for all things storage, it will be useful to have a viable alternate storage backend to see how things shake out in practice. test-storage.py passes on Python 2 and introduces no new test failures on Python 3. Having the storage-level unit tests has proved to be insanely useful when developing this extension. Those tests caught numerous bugs during development and I'm convinced this style of testing is the way forward for ensuring alternate storage backends work as intended. Of course, test coverage isn't close to what it needs to be. But it is a start. And what coverage we have gives me confidence that basic store functionality is implemented properly. Differential Revision: https://phab.mercurial-scm.org/D4928

     1

# This test verifies the conformance of various classes to various

     2

# storage interfaces.

     3

from __future__ import absolute_import

     4

     5

import silenttestrunner

     6

     7

from mercurial import (

     8

    error,

     9

    filelog,

    10

    revlog,

    11

    transaction,

    12

    ui as uimod,

    13

    vfs as vfsmod,

    14

)

    15

    16

from mercurial.testing import (

    17

    storage as storagetesting,

    18

)

    19

    20

from hgext import (

    21

    sqlitestore,

    22

)

    23

    24

try:

    25

    from mercurial import zstd

    26

    zstd.__version__

    27

except ImportError:

    28

    zstd = None

    29

    30

STATE = {

    31

    'lastindex': 0,

    32

    'ui': uimod.ui(),

    33

    'vfs': vfsmod.vfs(b'.', realpath=True),

    34

}

    35

    36

def makefilefn(self):

    37

    """Factory for filelog instances."""

    38

    fl = filelog.filelog(STATE['vfs'], b'filelog-%d' % STATE['lastindex'])

    39

    STATE['lastindex'] += 1

    40

    return fl

    41

    42

def maketransaction(self):

    43

    vfsmap = {b'plain': STATE['vfs'], b'store': STATE['vfs']}

    44

    45

    return transaction.transaction(STATE['ui'].warn, STATE['vfs'], vfsmap,

    46

                                   b'journal', b'undo')

    47

    48

def addrawrevision(self, fl, tr, node, p1, p2, linkrev, rawtext=None,

    49

                   delta=None, censored=False, ellipsis=False, extstored=False):

    50

    flags = 0

    51

    52

    if censored:

    53

        flags |= revlog.REVIDX_ISCENSORED

    54

    if ellipsis:

    55

        flags |= revlog.REVIDX_ELLIPSIS

    56

    if extstored:

    57

        flags |= revlog.REVIDX_EXTSTORED

    58

    59

    if rawtext is not None:

    60

        fl._revlog.addrawrevision(rawtext, tr, linkrev, p1, p2, node, flags)

    61

    elif delta is not None:

    62

        fl._revlog.addrawrevision(rawtext, tr, linkrev, p1, p2, node, flags,

    63

                                  cachedelta=delta)

    64

    else:

    65

        raise error.Abort('must supply rawtext or delta arguments')

    66

    67

    # We may insert bad data. Clear caches to prevent e.g. cache hits to

    68

    # bypass hash verification.

    69

    fl._revlog.clearcaches()

    70

    71

# Assigning module-level attributes that inherit from unittest.TestCase

    72

# is all that is needed to register tests.

    73

filelogindextests = storagetesting.makeifileindextests(makefilefn,

    74

                                                       maketransaction,

    75

                                                       addrawrevision)

    76

filelogdatatests = storagetesting.makeifiledatatests(makefilefn,

    77

                                                     maketransaction,

    78

                                                     addrawrevision)

    79

filelogmutationtests = storagetesting.makeifilemutationtests(makefilefn,

    80

                                                             maketransaction,

    81

                                                             addrawrevision)

    82

    83

def makesqlitefile(self):

    84

    path = STATE['vfs'].join(b'db-%d.db' % STATE['lastindex'])

    85

    STATE['lastindex'] += 1

    86

    87

    db = sqlitestore.makedb(path)

    88

    89

    compression = b'zstd' if zstd else b'zlib'

    90

    91

    return sqlitestore.sqlitefilestore(db, b'dummy-path', compression)

    92

    93

def addrawrevisionsqlite(self, fl, tr, node, p1, p2, linkrev, rawtext=None,

    94

                         delta=None, censored=False, ellipsis=False,

    95

                         extstored=False):

    96

    flags = 0

    97

    98

    if censored:

    99

        flags |= sqlitestore.FLAG_CENSORED

   100

   101

    if ellipsis | extstored:

   102

        raise error.Abort(b'support for ellipsis and extstored flags not '

   103

                          b'supported')

   104

   105

    if rawtext is not None:

   106

        fl._addrawrevision(node, rawtext, tr, linkrev, p1, p2, flags=flags)

   107

    elif delta is not None:

   108

        fl._addrawrevision(node, rawtext, tr, linkrev, p1, p2,

   109

                           storedelta=delta, flags=flags)

   110

    else:

   111

        raise error.Abort(b'must supply rawtext or delta arguments')

   112

   113

sqlitefileindextests = storagetesting.makeifileindextests(

   114

    makesqlitefile, maketransaction, addrawrevisionsqlite)

   115

sqlitefiledatatests = storagetesting.makeifiledatatests(

   116

    makesqlitefile, maketransaction, addrawrevisionsqlite)

   117

sqlitefilemutationtests = storagetesting.makeifilemutationtests(

   118

    makesqlitefile, maketransaction, addrawrevisionsqlite)

   119

   120

if __name__ == '__main__':

   121

    silenttestrunner.main(__name__)