comparison hgext/sqlitestore.py @ 40390:7e3b6c4f01a2

localrepo: support marking repos as having shallow file storage

Various operations against repositories need to know if repository
storage is full or partial. For example, a checkout (including possibly
a widening of a sparse checkout), needs to know if it can assume all file
revisions are available or whether to look for missing revisions first.

This commit lays the plumbing for doing that.

We define a repo creation option that indicates that shallow file storage
is desired.

The SQLite store uses this creation option to add an extra repo requirement
indicating file storage is shallow.

A new repository feature has been added to indicate that file storage is
shallow. The SQLite store adds this feature when the shallow file store
requirement is present.

Code can now look at repo.features to determine if repo file storage may
be shallow and take additional actions if so.

While we're here, we also teach the SQLite store to handle the narrow repo
requirement, which gets added when making narrow clones.

Differential Revision: https://phab.mercurial-scm.org/D5166

40389:1b183edbb68e

REQUIREMENT = b'exp-sqlite-001'
REQUIREMENT_ZSTD = b'exp-sqlite-comp-001=zstd'
REQUIREMENT_ZLIB = b'exp-sqlite-comp-001=zlib'
REQUIREMENT_NONE = b'exp-sqlite-comp-001=none'

CURRENT_SCHEMA_VERSION = 1

COMPRESSION_NONE = 1
COMPRESSION_ZSTD = 2

    if zstd:
        supported.add(REQUIREMENT_ZSTD)

    supported.add(REQUIREMENT_ZLIB)
    supported.add(REQUIREMENT_NONE)

def newreporequirements(orig, ui, createopts):
    if createopts['backend'] != 'sqlite':
        return orig(ui, createopts)

    # we honor creation options and we do that by annotating exactly the
    # creation options we recognize.
    known = {
        'narrowfiles',
        'backend',
    }

    unsupported = set(createopts) - known
    if unsupported:
        raise error.Abort(_('SQLite store does not support repo creation '

        requirements.add(REQUIREMENT_NONE)
    else:
        raise error.Abort(_('unknown compression engine defined in '
                            'storage.sqlite.compression: %s') % compression)

    return requirements

@interfaceutil.implementer(repository.ilocalrepositoryfilestorage)
class sqlitefilestorage(object):
    """Repository file storage backed by SQLite."""

            raise error.Abort(_('unable to determine what compression engine '
                                'to use for SQLite storage'))

        return sqlitefilestore(self._dbconn, path, compression)

def makefilestorage(orig, requirements, **kwargs):
    """Produce a type conforming to ``ilocalrepositoryfilestorage``."""
    if REQUIREMENT in requirements:
        return sqlitefilestorage
    else:
        return orig(requirements=requirements, **kwargs)

def makemain(orig, ui, requirements, **kwargs):
    if REQUIREMENT in requirements:
        if REQUIREMENT_ZSTD in requirements and not zstd:
            raise error.Abort(_('repository uses zstandard compression, which '

40390:7e3b6c4f01a2

REQUIREMENT = b'exp-sqlite-001'
REQUIREMENT_ZSTD = b'exp-sqlite-comp-001=zstd'
REQUIREMENT_ZLIB = b'exp-sqlite-comp-001=zlib'
REQUIREMENT_NONE = b'exp-sqlite-comp-001=none'
REQUIREMENT_SHALLOW_FILES = b'exp-sqlite-shallow-files'

CURRENT_SCHEMA_VERSION = 1

COMPRESSION_NONE = 1
COMPRESSION_ZSTD = 2

    if zstd:
        supported.add(REQUIREMENT_ZSTD)

    supported.add(REQUIREMENT_ZLIB)
    supported.add(REQUIREMENT_NONE)
    supported.add(REQUIREMENT_SHALLOW_FILES)
    supported.add(repository.NARROW_REQUIREMENT)

def newreporequirements(orig, ui, createopts):
    if createopts['backend'] != 'sqlite':
        return orig(ui, createopts)

    # we honor creation options and we do that by annotating exactly the
    # creation options we recognize.
    known = {
        'narrowfiles',
        'backend',
        'shallowfilestore',
    }

    unsupported = set(createopts) - known
    if unsupported:
        raise error.Abort(_('SQLite store does not support repo creation '

        requirements.add(REQUIREMENT_NONE)
    else:
        raise error.Abort(_('unknown compression engine defined in '
                            'storage.sqlite.compression: %s') % compression)

    if createopts.get('shallowfilestore'):
        requirements.add(REQUIREMENT_SHALLOW_FILES)

    return requirements

@interfaceutil.implementer(repository.ilocalrepositoryfilestorage)
class sqlitefilestorage(object):
    """Repository file storage backed by SQLite."""

            raise error.Abort(_('unable to determine what compression engine '
                                'to use for SQLite storage'))

        return sqlitefilestore(self._dbconn, path, compression)

def makefilestorage(orig, requirements, features, **kwargs):
    """Produce a type conforming to ``ilocalrepositoryfilestorage``."""
    if REQUIREMENT in requirements:
        if REQUIREMENT_SHALLOW_FILES in requirements:
            features.add(repository.REPO_FEATURE_SHALLOW_FILE_STORAGE)

        return sqlitefilestorage
    else:
        return orig(requirements=requirements, features=features, **kwargs)

def makemain(orig, ui, requirements, **kwargs):
    if REQUIREMENT in requirements:
        if REQUIREMENT_ZSTD in requirements and not zstd:
            raise error.Abort(_('repository uses zstandard compression, which '