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

#require sqlite

     2

     3

  $ cat >> $HGRCPATH <<EOF

     4

  > [extensions]

     5

  > sqlitestore =

     6

  > EOF

     7

     8

New repo should not use SQLite by default

     9

    10

  $ hg init empty-no-sqlite

    11

  $ cat empty-no-sqlite/.hg/requires

    12

  dotencode

    13

  fncache

    14

  generaldelta

    15

  revlogv1

    16

  store

    17

    18

storage.new-repo-backend=sqlite is recognized

    19

    20

  $ hg --config storage.new-repo-backend=sqlite init empty-sqlite

    21

  $ cat empty-sqlite/.hg/requires

    22

  dotencode

    23

  exp-sqlite-001

    24

  exp-sqlite-comp-001=zstd (zstd !)

    25

  exp-sqlite-comp-001-zlib (no-zstd !)

    26

  fncache

    27

  generaldelta

    28

  revlogv1

    29

  store

    30

    31

  $ cat >> $HGRCPATH << EOF

    32

  > [storage]

    33

  > new-repo-backend = sqlite

    34

  > EOF

    35

    36

Can force compression to zlib

    37

    38

  $ hg --config storage.sqlite.compression=zlib init empty-zlib

    39

  $ cat empty-zlib/.hg/requires

    40

  dotencode

    41

  exp-sqlite-001

    42

  exp-sqlite-comp-001=$BUNDLE2_COMPRESSIONS$

    43

  fncache

    44

  generaldelta

    45

  revlogv1

    46

  store

    47

    48

Can force compression to none

    49

    50

  $ hg --config storage.sqlite.compression=none init empty-none

    51

  $ cat empty-none/.hg/requires

    52

  dotencode

    53

  exp-sqlite-001

    54

  exp-sqlite-comp-001=none

    55

  fncache

    56

  generaldelta

    57

  revlogv1

    58

  store

    59

    60

Can make a local commit

    61

    62

  $ hg init local-commit

    63

  $ cd local-commit

    64

  $ echo 0 > foo

    65

  $ hg commit -A -m initial

    66

  adding foo

    67

    68

That results in a row being inserted into various tables

    69

    70

  $ sqlite3 .hg/store/db.sqlite << EOF

    71

  > SELECT * FROM filepath;

    72

  > EOF

    73

  1|foo

    74

    75

  $ sqlite3 .hg/store/db.sqlite << EOF

    76

  > SELECT * FROM fileindex;

    77

  > EOF

    78

  1|1|0|-1|-1|0|0|1||6/\xef(L\xe2\xca\x02\xae\xcc\x8d\xe6\xd5\xe8\xa1\xc3\xaf\x05V\xfe (esc)

    79

    80

  $ sqlite3 .hg/store/db.sqlite << EOF

    81

  > SELECT * FROM delta;

    82

  > EOF

    83

  1|1|	\xd2\xaf\x8d\xd2"\x01\xdd\x8dH\xe5\xdc\xfc\xae\xd2\x81\xff\x94"\xc7|0 (esc)

    84

    85

    86

Tracking multiple files works

    87

    88

  $ echo 1 > bar

    89

  $ hg commit -A -m 'add bar'

    90

  adding bar

    91

    92

  $ sqlite3 .hg/store/db.sqlite << EOF

    93

  > SELECT * FROM filedata ORDER BY id ASC;

    94

  > EOF

    95

  1|1|foo|0|6/\xef(L\xe2\xca\x02\xae\xcc\x8d\xe6\xd5\xe8\xa1\xc3\xaf\x05V\xfe|-1|-1|0|0|1| (esc)

    96

  2|2|bar|0|\xb8\xe0/d3s\x80!\xa0e\xf9Au\xc7\xcd#\xdb_\x05\xbe|-1|-1|1|0|2| (esc)

    97

    98

Multiple revisions of a file works

    99

   100

  $ echo a >> foo

   101

  $ hg commit -m 'modify foo'

   102

   103

  $ sqlite3 .hg/store/db.sqlite << EOF

   104

  > SELECT * FROM filedata ORDER BY id ASC;

   105

  > EOF

   106

  1|1|foo|0|6/\xef(L\xe2\xca\x02\xae\xcc\x8d\xe6\xd5\xe8\xa1\xc3\xaf\x05V\xfe|-1|-1|0|0|1| (esc)

   107

  2|2|bar|0|\xb8\xe0/d3s\x80!\xa0e\xf9Au\xc7\xcd#\xdb_\x05\xbe|-1|-1|1|0|2| (esc)

   108

  3|1|foo|1|\xdd\xb3V\xcd\xde1p@\xf7\x8e\x90\xb8*\x8b,\xe9\x0e\xd6j+|0|-1|2|0|3|1 (esc)

   109

   110

  $ cd ..