diff --git a/swh/indexer/metadata.py b/swh/indexer/metadata.py
index 0e37963..d5e5496 100644
--- a/swh/indexer/metadata.py
+++ b/swh/indexer/metadata.py
@@ -1,432 +1,395 @@
 # Copyright (C) 2017-2020  The Software Heritage developers
 # See the AUTHORS file at the top-level directory of this distribution
 # License: GNU General Public License version 3, or any later version
 # See top-level LICENSE file for more information
 
 from copy import deepcopy
 from typing import (
     Any,
     Callable,
     Dict,
     Iterable,
     Iterator,
     List,
     Optional,
     Tuple,
     TypeVar,
 )
 
 from swh.core.config import merge_configs
 from swh.core.utils import grouper
 from swh.indexer.codemeta import merge_documents
 from swh.indexer.indexer import ContentIndexer, OriginIndexer, RevisionIndexer
 from swh.indexer.metadata_detector import detect_metadata
 from swh.indexer.metadata_dictionary import MAPPINGS
 from swh.indexer.origin_head import OriginHeadIndexer
 from swh.indexer.storage import INDEXER_CFG_KEY, Sha1
 from swh.indexer.storage.model import (
     ContentMetadataRow,
     OriginIntrinsicMetadataRow,
     RevisionIntrinsicMetadataRow,
 )
 from swh.model import hashutil
 from swh.model.model import Revision, Sha1Git
 
 REVISION_GET_BATCH_SIZE = 10
 ORIGIN_GET_BATCH_SIZE = 10
 
 
 T1 = TypeVar("T1")
 T2 = TypeVar("T2")
 
 
 def call_with_batches(
     f: Callable[[List[T1]], Iterable[T2]], args: List[T1], batch_size: int,
 ) -> Iterator[T2]:
     """Calls a function with batches of args, and concatenates the results.
     """
     groups = grouper(args, batch_size)
     for group in groups:
         yield from f(list(group))
 
 
 class ContentMetadataIndexer(ContentIndexer[ContentMetadataRow]):
     """Content-level indexer
 
     This indexer is in charge of:
 
     - filtering out content already indexed in content_metadata
     - reading content from objstorage with the content's id sha1
     - computing metadata by given context
     - using the metadata_dictionary as the 'swh-metadata-translator' tool
     - store result in content_metadata table
 
     """
 
     def filter(self, ids):
         """Filter out known sha1s and return only missing ones.
         """
         yield from self.idx_storage.content_metadata_missing(
             ({"id": sha1, "indexer_configuration_id": self.tool["id"],} for sha1 in ids)
         )
 
     def index(
         self,
         id: Sha1,
         data: Optional[bytes] = None,
         log_suffix="unknown revision",
         **kwargs,
     ) -> List[ContentMetadataRow]:
         """Index sha1s' content and store result.
 
         Args:
             id (bytes): content's identifier
             data (bytes): raw content in bytes
 
         Returns:
             dict: dictionary representing a content_metadata. If the
             translation wasn't successful the metadata keys will
             be returned as None
 
         """
         assert isinstance(id, bytes)
         assert data is not None
         try:
             mapping_name = self.tool["tool_configuration"]["context"]
             log_suffix += ", content_id=%s" % hashutil.hash_to_hex(id)
             metadata = MAPPINGS[mapping_name](log_suffix).translate(data)
         except Exception:
             self.log.exception(
                 "Problem during metadata translation "
                 "for content %s" % hashutil.hash_to_hex(id)
             )
         if metadata is None:
             return []
         return [
             ContentMetadataRow(
                 id=id, indexer_configuration_id=self.tool["id"], metadata=metadata,
             )
         ]
 
     def persist_index_computations(
         self, results: List[ContentMetadataRow], policy_update: str
     ) -> Dict[str, int]:
         """Persist the results in storage.
 
         Args:
             results: list of content_metadata, dict with the
               following keys:
               - id (bytes): content's identifier (sha1)
               - metadata (jsonb): detected metadata
             policy_update: either 'update-dups' or 'ignore-dups' to
               respectively update duplicates or ignore them
 
         """
         return self.idx_storage.content_metadata_add(
             results, conflict_update=(policy_update == "update-dups")
         )
 
 
 DEFAULT_CONFIG: Dict[str, Any] = {
     "tools": {
         "name": "swh-metadata-detector",
         "version": "0.0.2",
         "configuration": {},
     },
 }
 
 
 class RevisionMetadataIndexer(RevisionIndexer[RevisionIntrinsicMetadataRow]):
     """Revision-level indexer
 
     This indexer is in charge of:
 
     - filtering revisions already indexed in revision_intrinsic_metadata table
       with defined computation tool
     - retrieve all entry_files in root directory
     - use metadata_detector for file_names containing metadata
     - compute metadata translation if necessary and possible (depends on tool)
     - send sha1s to content indexing if possible
     - store the results for revision
 
     """
 
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
         self.config = merge_configs(DEFAULT_CONFIG, self.config)
 
     def filter(self, sha1_gits):
         """Filter out known sha1s and return only missing ones.
 
         """
         yield from self.idx_storage.revision_intrinsic_metadata_missing(
             (
                 {"id": sha1_git, "indexer_configuration_id": self.tool["id"],}
                 for sha1_git in sha1_gits
             )
         )
 
     def index(
         self, id: Sha1Git, data: Optional[Revision], **kwargs
     ) -> List[RevisionIntrinsicMetadataRow]:
         """Index rev by processing it and organizing result.
 
         use metadata_detector to iterate on filenames
 
         - if one filename detected -> sends file to content indexer
         - if multiple file detected -> translation needed at revision level
 
         Args:
           id: sha1_git of the revision
           data: revision model object from storage
 
         Returns:
             dict: dictionary representing a revision_intrinsic_metadata, with
             keys:
 
             - id (str): rev's identifier (sha1_git)
             - indexer_configuration_id (bytes): tool used
             - metadata: dict of retrieved metadata
 
         """
         rev = data
         assert isinstance(rev, Revision)
 
         try:
             root_dir = rev.directory
             dir_ls = list(self.storage.directory_ls(root_dir, recursive=False))
             if [entry["type"] for entry in dir_ls] == ["dir"]:
                 # If the root is just a single directory, recurse into it
                 # eg. PyPI packages, GNU tarballs
                 subdir = dir_ls[0]["target"]
                 dir_ls = list(self.storage.directory_ls(subdir, recursive=False))
             files = [entry for entry in dir_ls if entry["type"] == "file"]
             detected_files = detect_metadata(files)
             (mappings, metadata) = self.translate_revision_intrinsic_metadata(
                 detected_files, log_suffix="revision=%s" % hashutil.hash_to_hex(rev.id),
             )
         except Exception as e:
             self.log.exception("Problem when indexing rev: %r", e)
         return [
             RevisionIntrinsicMetadataRow(
                 id=rev.id,
                 indexer_configuration_id=self.tool["id"],
                 mappings=mappings,
                 metadata=metadata,
             )
         ]
 
     def persist_index_computations(
         self, results: List[RevisionIntrinsicMetadataRow], policy_update: str
     ) -> Dict[str, int]:
         """Persist the results in storage.
 
         Args:
             results: list of content_mimetype, dict with the
               following keys:
               - id (bytes): content's identifier (sha1)
               - mimetype (bytes): mimetype in bytes
               - encoding (bytes): encoding in bytes
             policy_update: either 'update-dups' or 'ignore-dups' to
               respectively update duplicates or ignore them
 
         """
         # TODO: add functions in storage to keep data in
         # revision_intrinsic_metadata
         return self.idx_storage.revision_intrinsic_metadata_add(
             results, conflict_update=(policy_update == "update-dups")
         )
 
     def translate_revision_intrinsic_metadata(
         self, detected_files: Dict[str, List[Any]], log_suffix: str
     ) -> Tuple[List[Any], Any]:
         """
         Determine plan of action to translate metadata when containing
         one or multiple detected files:
 
         Args:
             detected_files: dictionary mapping context names (e.g.,
               "npm", "authors") to list of sha1
 
         Returns:
             (List[str], dict): list of mappings used and dict with
             translated metadata according to the CodeMeta vocabulary
 
         """
         used_mappings = [MAPPINGS[context].name for context in detected_files]
         metadata = []
         tool = {
             "name": "swh-metadata-translator",
             "version": "0.0.2",
             "configuration": {},
         }
         # TODO: iterate on each context, on each file
         # -> get raw_contents
         # -> translate each content
         config = {k: self.config[k] for k in [INDEXER_CFG_KEY, "objstorage", "storage"]}
         config["tools"] = [tool]
         for context in detected_files.keys():
             cfg = deepcopy(config)
             cfg["tools"][0]["configuration"]["context"] = context
             c_metadata_indexer = ContentMetadataIndexer(config=cfg)
             # sha1s that are in content_metadata table
             sha1s_in_storage = []
             metadata_generator = self.idx_storage.content_metadata_get(
                 detected_files[context]
             )
             for c in metadata_generator:
                 # extracting metadata
                 sha1 = c.id
                 sha1s_in_storage.append(sha1)
                 local_metadata = c.metadata
                 # local metadata is aggregated
                 if local_metadata:
                     metadata.append(local_metadata)
 
             sha1s_filtered = [
                 item for item in detected_files[context] if item not in sha1s_in_storage
             ]
 
             if sha1s_filtered:
                 # content indexing
                 try:
                     c_metadata_indexer.run(
                         sha1s_filtered,
                         policy_update="ignore-dups",
                         log_suffix=log_suffix,
                     )
                     # on the fly possibility:
                     for result in c_metadata_indexer.results:
                         local_metadata = result.metadata
                         metadata.append(local_metadata)
 
                 except Exception:
                     self.log.exception("Exception while indexing metadata on contents")
 
         metadata = merge_documents(metadata)
         return (used_mappings, metadata)
 
 
 class OriginMetadataIndexer(
     OriginIndexer[Tuple[OriginIntrinsicMetadataRow, RevisionIntrinsicMetadataRow]]
 ):
     USE_TOOLS = False
 
     def __init__(self, config=None, **kwargs) -> None:
         super().__init__(config=config, **kwargs)
         self.origin_head_indexer = OriginHeadIndexer(config=config)
         self.revision_metadata_indexer = RevisionMetadataIndexer(config=config)
 
     def index_list(
         self, origin_urls: List[str], **kwargs
     ) -> List[Tuple[OriginIntrinsicMetadataRow, RevisionIntrinsicMetadataRow]]:
         head_rev_ids = []
         origins_with_head = []
         origins = list(
             call_with_batches(
                 self.storage.origin_get, origin_urls, ORIGIN_GET_BATCH_SIZE,
             )
         )
         for origin in origins:
             if origin is None:
                 continue
             head_results = self.origin_head_indexer.index(origin.url)
             if head_results:
                 (head_result,) = head_results
                 origins_with_head.append(origin)
                 head_rev_ids.append(head_result["revision_id"])
 
         head_revs = list(
             call_with_batches(
                 self.storage.revision_get, head_rev_ids, REVISION_GET_BATCH_SIZE
             )
         )
         assert len(head_revs) == len(head_rev_ids)
 
         results = []
         for (origin, rev) in zip(origins_with_head, head_revs):
             if not rev:
                 self.log.warning("Missing head revision of origin %r", origin.url)
                 continue
 
             for rev_metadata in self.revision_metadata_indexer.index(rev.id, rev):
                 # There is at most one rev_metadata
                 orig_metadata = OriginIntrinsicMetadataRow(
                     from_revision=rev_metadata.id,
                     id=origin.url,
                     metadata=rev_metadata.metadata,
                     mappings=rev_metadata.mappings,
                     indexer_configuration_id=rev_metadata.indexer_configuration_id,
                 )
                 results.append((orig_metadata, rev_metadata))
         return results
 
     def persist_index_computations(
         self,
         results: List[Tuple[OriginIntrinsicMetadataRow, RevisionIntrinsicMetadataRow]],
         policy_update: str,
     ) -> Dict[str, int]:
         conflict_update = policy_update == "update-dups"
 
         # Deduplicate revisions
         rev_metadata: List[RevisionIntrinsicMetadataRow] = []
         orig_metadata: List[OriginIntrinsicMetadataRow] = []
-        revs_to_delete: List[Dict] = []
-        origs_to_delete: List[Dict] = []
         summary: Dict = {}
         for (orig_item, rev_item) in results:
             assert rev_item.metadata == orig_item.metadata
-            if not rev_item.metadata or rev_item.metadata.keys() <= {"@context"}:
-                # If we didn't find any metadata, don't store a DB record
-                # (and delete existing ones, if any)
-                if rev_item not in revs_to_delete:
-                    revs_to_delete.append(
-                        {
-                            "id": rev_item.id,
-                            "indexer_configuration_id": (
-                                rev_item.indexer_configuration_id
-                            ),
-                        }
-                    )
-                if orig_item not in origs_to_delete:
-                    origs_to_delete.append(
-                        {
-                            "id": orig_item.id,
-                            "indexer_configuration_id": (
-                                orig_item.indexer_configuration_id
-                            ),
-                        }
-                    )
-            else:
+            if rev_item.metadata and not (rev_item.metadata.keys() <= {"@context"}):
+                # Only store non-empty metadata sets
                 if rev_item not in rev_metadata:
                     rev_metadata.append(rev_item)
                 if orig_item not in orig_metadata:
                     orig_metadata.append(orig_item)
 
         if rev_metadata:
             summary_rev = self.idx_storage.revision_intrinsic_metadata_add(
                 rev_metadata, conflict_update=conflict_update
             )
             summary.update(summary_rev)
         if orig_metadata:
             summary_ori = self.idx_storage.origin_intrinsic_metadata_add(
                 orig_metadata, conflict_update=conflict_update
             )
             summary.update(summary_ori)
 
-        # revs_to_delete should always be empty unless we changed a mapping
-        # to detect less files or less content.
-        # However, origs_to_delete may be empty whenever an upstream deletes
-        # a metadata file.
-        if origs_to_delete:
-            summary_ori = self.idx_storage.origin_intrinsic_metadata_delete(
-                origs_to_delete
-            )
-            summary.update(summary_ori)
-        if revs_to_delete:
-            summary_rev = self.idx_storage.revision_intrinsic_metadata_delete(
-                revs_to_delete
-            )
-            summary.update(summary_rev)
-
         return summary
diff --git a/swh/indexer/storage/__init__.py b/swh/indexer/storage/__init__.py
index ab5b80d..ea1fc3b 100644
--- a/swh/indexer/storage/__init__.py
+++ b/swh/indexer/storage/__init__.py
@@ -1,745 +1,725 @@
 # Copyright (C) 2015-2020  The Software Heritage developers
 # See the AUTHORS file at the top-level directory of this distribution
 # License: GNU General Public License version 3, or any later version
 # See top-level LICENSE file for more information
 
 from collections import Counter
 from importlib import import_module
 import json
 from typing import Dict, Iterable, List, Optional, Tuple, Union
 import warnings
 
 import psycopg2
 import psycopg2.pool
 
 from swh.core.db.common import db_transaction
 from swh.indexer.storage.interface import IndexerStorageInterface
 from swh.model.hashutil import hash_to_bytes, hash_to_hex
 from swh.model.model import SHA1_SIZE
 from swh.storage.exc import StorageDBError
 from swh.storage.utils import get_partition_bounds_bytes
 
 from . import converters
 from .db import Db
 from .exc import DuplicateId, IndexerStorageArgumentException
 from .interface import PagedResult, Sha1
 from .metrics import process_metrics, send_metric, timed
 from .model import (
     ContentCtagsRow,
     ContentLanguageRow,
     ContentLicenseRow,
     ContentMetadataRow,
     ContentMimetypeRow,
     OriginIntrinsicMetadataRow,
     RevisionIntrinsicMetadataRow,
 )
 
 INDEXER_CFG_KEY = "indexer_storage"
 
 
 MAPPING_NAMES = ["codemeta", "gemspec", "maven", "npm", "pkg-info"]
 
 
 SERVER_IMPLEMENTATIONS: Dict[str, str] = {
     "local": ".IndexerStorage",
     "remote": ".api.client.RemoteStorage",
     "memory": ".in_memory.IndexerStorage",
 }
 
 
 def get_indexer_storage(cls: str, **kwargs) -> IndexerStorageInterface:
     """Instantiate an indexer storage implementation of class `cls` with arguments
     `kwargs`.
 
     Args:
         cls: indexer storage class (local, remote or memory)
         kwargs: dictionary of arguments passed to the
             indexer storage class constructor
 
     Returns:
         an instance of swh.indexer.storage
 
     Raises:
         ValueError if passed an unknown storage class.
 
     """
     if "args" in kwargs:
         warnings.warn(
             'Explicit "args" key is deprecated, use keys directly instead.',
             DeprecationWarning,
         )
         kwargs = kwargs["args"]
 
     class_path = SERVER_IMPLEMENTATIONS.get(cls)
     if class_path is None:
         raise ValueError(
             f"Unknown indexer storage class `{cls}`. "
             f"Supported: {', '.join(SERVER_IMPLEMENTATIONS)}"
         )
 
     (module_path, class_name) = class_path.rsplit(".", 1)
     module = import_module(module_path if module_path else ".", package=__package__)
     BackendClass = getattr(module, class_name)
     check_config = kwargs.pop("check_config", {})
     idx_storage = BackendClass(**kwargs)
     if check_config:
         if not idx_storage.check_config(**check_config):
             raise EnvironmentError("Indexer storage check config failed")
     return idx_storage
 
 
 def check_id_duplicates(data):
     """
     If any two row models in `data` have the same unique key, raises
     a `ValueError`.
 
     Values associated to the key must be hashable.
 
     Args:
         data (List[dict]): List of dictionaries to be inserted
 
     >>> check_id_duplicates([
     ...     ContentLanguageRow(id=b'foo', indexer_configuration_id=42, lang="python"),
     ...     ContentLanguageRow(id=b'foo', indexer_configuration_id=32, lang="python"),
     ... ])
     >>> check_id_duplicates([
     ...     ContentLanguageRow(id=b'foo', indexer_configuration_id=42, lang="python"),
     ...     ContentLanguageRow(id=b'foo', indexer_configuration_id=42, lang="python"),
     ... ])
     Traceback (most recent call last):
       ...
     swh.indexer.storage.exc.DuplicateId: [{'id': b'foo', 'indexer_configuration_id': 42}]
     """  # noqa
     counter = Counter(tuple(sorted(item.unique_key().items())) for item in data)
     duplicates = [id_ for (id_, count) in counter.items() if count >= 2]
     if duplicates:
         raise DuplicateId(list(map(dict, duplicates)))
 
 
 class IndexerStorage:
     """SWH Indexer Storage
 
     """
 
     def __init__(self, db, min_pool_conns=1, max_pool_conns=10):
         """
         Args:
             db_conn: either a libpq connection string, or a psycopg2 connection
 
         """
         try:
             if isinstance(db, psycopg2.extensions.connection):
                 self._pool = None
                 self._db = Db(db)
             else:
                 self._pool = psycopg2.pool.ThreadedConnectionPool(
                     min_pool_conns, max_pool_conns, db
                 )
                 self._db = None
         except psycopg2.OperationalError as e:
             raise StorageDBError(e)
 
     def get_db(self):
         if self._db:
             return self._db
         return Db.from_pool(self._pool)
 
     def put_db(self, db):
         if db is not self._db:
             db.put_conn()
 
     @timed
     @db_transaction()
     def check_config(self, *, check_write, db=None, cur=None):
         # Check permissions on one of the tables
         if check_write:
             check = "INSERT"
         else:
             check = "SELECT"
 
         cur.execute(
             "select has_table_privilege(current_user, 'content_mimetype', %s)",  # noqa
             (check,),
         )
         return cur.fetchone()[0]
 
     @timed
     @db_transaction()
     def content_mimetype_missing(
         self, mimetypes: Iterable[Dict], db=None, cur=None
     ) -> List[Tuple[Sha1, int]]:
         return [obj[0] for obj in db.content_mimetype_missing_from_list(mimetypes, cur)]
 
     @timed
     @db_transaction()
     def get_partition(
         self,
         indexer_type: str,
         indexer_configuration_id: int,
         partition_id: int,
         nb_partitions: int,
         page_token: Optional[str] = None,
         limit: int = 1000,
         with_textual_data=False,
         db=None,
         cur=None,
     ) -> PagedResult[Sha1]:
         """Retrieve ids of content with `indexer_type` within within partition partition_id
         bound by limit.
 
         Args:
             **indexer_type**: Type of data content to index (mimetype, language, etc...)
             **indexer_configuration_id**: The tool used to index data
             **partition_id**: index of the partition to fetch
             **nb_partitions**: total number of partitions to split into
             **page_token**: opaque token used for pagination
             **limit**: Limit result (default to 1000)
             **with_textual_data** (bool): Deal with only textual content (True) or all
                 content (all contents by defaults, False)
 
         Raises:
             IndexerStorageArgumentException for;
             - limit to None
             - wrong indexer_type provided
 
         Returns:
             PagedResult of Sha1. If next_page_token is None, there is no more data to
             fetch
 
         """
         if limit is None:
             raise IndexerStorageArgumentException("limit should not be None")
         if indexer_type not in db.content_indexer_names:
             err = f"Wrong type. Should be one of [{','.join(db.content_indexer_names)}]"
             raise IndexerStorageArgumentException(err)
 
         start, end = get_partition_bounds_bytes(partition_id, nb_partitions, SHA1_SIZE)
         if page_token is not None:
             start = hash_to_bytes(page_token)
         if end is None:
             end = b"\xff" * SHA1_SIZE
 
         next_page_token: Optional[str] = None
         ids = [
             row[0]
             for row in db.content_get_range(
                 indexer_type,
                 start,
                 end,
                 indexer_configuration_id,
                 limit=limit + 1,
                 with_textual_data=with_textual_data,
                 cur=cur,
             )
         ]
 
         if len(ids) >= limit:
             next_page_token = hash_to_hex(ids[-1])
             ids = ids[:limit]
 
         assert len(ids) <= limit
         return PagedResult(results=ids, next_page_token=next_page_token)
 
     @timed
     @db_transaction()
     def content_mimetype_get_partition(
         self,
         indexer_configuration_id: int,
         partition_id: int,
         nb_partitions: int,
         page_token: Optional[str] = None,
         limit: int = 1000,
         db=None,
         cur=None,
     ) -> PagedResult[Sha1]:
         return self.get_partition(
             "mimetype",
             indexer_configuration_id,
             partition_id,
             nb_partitions,
             page_token=page_token,
             limit=limit,
             db=db,
             cur=cur,
         )
 
     @timed
     @process_metrics
     @db_transaction()
     def content_mimetype_add(
         self,
         mimetypes: List[ContentMimetypeRow],
         conflict_update: bool = False,
         db=None,
         cur=None,
     ) -> Dict[str, int]:
         check_id_duplicates(mimetypes)
         mimetypes.sort(key=lambda m: m.id)
         db.mktemp_content_mimetype(cur)
         db.copy_to(
             [m.to_dict() for m in mimetypes],
             "tmp_content_mimetype",
             ["id", "mimetype", "encoding", "indexer_configuration_id"],
             cur,
         )
         count = db.content_mimetype_add_from_temp(conflict_update, cur)
         return {"content_mimetype:add": count}
 
     @timed
     @db_transaction()
     def content_mimetype_get(
         self, ids: Iterable[Sha1], db=None, cur=None
     ) -> List[ContentMimetypeRow]:
         return [
             ContentMimetypeRow.from_dict(
                 converters.db_to_mimetype(dict(zip(db.content_mimetype_cols, c)))
             )
             for c in db.content_mimetype_get_from_list(ids, cur)
         ]
 
     @timed
     @db_transaction()
     def content_language_missing(
         self, languages: Iterable[Dict], db=None, cur=None
     ) -> List[Tuple[Sha1, int]]:
         return [obj[0] for obj in db.content_language_missing_from_list(languages, cur)]
 
     @timed
     @db_transaction()
     def content_language_get(
         self, ids: Iterable[Sha1], db=None, cur=None
     ) -> List[ContentLanguageRow]:
         return [
             ContentLanguageRow.from_dict(
                 converters.db_to_language(dict(zip(db.content_language_cols, c)))
             )
             for c in db.content_language_get_from_list(ids, cur)
         ]
 
     @timed
     @process_metrics
     @db_transaction()
     def content_language_add(
         self,
         languages: List[ContentLanguageRow],
         conflict_update: bool = False,
         db=None,
         cur=None,
     ) -> Dict[str, int]:
         check_id_duplicates(languages)
         languages.sort(key=lambda m: m.id)
         db.mktemp_content_language(cur)
         # empty language is mapped to 'unknown'
         db.copy_to(
             (
                 {
                     "id": lang.id,
                     "lang": lang.lang or "unknown",
                     "indexer_configuration_id": lang.indexer_configuration_id,
                 }
                 for lang in languages
             ),
             "tmp_content_language",
             ["id", "lang", "indexer_configuration_id"],
             cur,
         )
 
         count = db.content_language_add_from_temp(conflict_update, cur)
         return {"content_language:add": count}
 
     @timed
     @db_transaction()
     def content_ctags_missing(
         self, ctags: Iterable[Dict], db=None, cur=None
     ) -> List[Tuple[Sha1, int]]:
         return [obj[0] for obj in db.content_ctags_missing_from_list(ctags, cur)]
 
     @timed
     @db_transaction()
     def content_ctags_get(
         self, ids: Iterable[Sha1], db=None, cur=None
     ) -> List[ContentCtagsRow]:
         return [
             ContentCtagsRow.from_dict(
                 converters.db_to_ctags(dict(zip(db.content_ctags_cols, c)))
             )
             for c in db.content_ctags_get_from_list(ids, cur)
         ]
 
     @timed
     @process_metrics
     @db_transaction()
     def content_ctags_add(
         self,
         ctags: List[ContentCtagsRow],
         conflict_update: bool = False,
         db=None,
         cur=None,
     ) -> Dict[str, int]:
         check_id_duplicates(ctags)
         ctags.sort(key=lambda m: m.id)
 
         db.mktemp_content_ctags(cur)
         db.copy_to(
             [ctag.to_dict() for ctag in ctags],
             tblname="tmp_content_ctags",
             columns=["id", "name", "kind", "line", "lang", "indexer_configuration_id"],
             cur=cur,
         )
 
         count = db.content_ctags_add_from_temp(conflict_update, cur)
         return {"content_ctags:add": count}
 
     @timed
     @db_transaction()
     def content_ctags_search(
         self,
         expression: str,
         limit: int = 10,
         last_sha1: Optional[Sha1] = None,
         db=None,
         cur=None,
     ) -> List[ContentCtagsRow]:
         return [
             ContentCtagsRow.from_dict(
                 converters.db_to_ctags(dict(zip(db.content_ctags_cols, obj)))
             )
             for obj in db.content_ctags_search(expression, last_sha1, limit, cur=cur)
         ]
 
     @timed
     @db_transaction()
     def content_fossology_license_get(
         self, ids: Iterable[Sha1], db=None, cur=None
     ) -> List[ContentLicenseRow]:
         return [
             ContentLicenseRow.from_dict(
                 converters.db_to_fossology_license(
                     dict(zip(db.content_fossology_license_cols, c))
                 )
             )
             for c in db.content_fossology_license_get_from_list(ids, cur)
         ]
 
     @timed
     @process_metrics
     @db_transaction()
     def content_fossology_license_add(
         self,
         licenses: List[ContentLicenseRow],
         conflict_update: bool = False,
         db=None,
         cur=None,
     ) -> Dict[str, int]:
         check_id_duplicates(licenses)
         licenses.sort(key=lambda m: m.id)
         db.mktemp_content_fossology_license(cur)
         db.copy_to(
             [license.to_dict() for license in licenses],
             tblname="tmp_content_fossology_license",
             columns=["id", "license", "indexer_configuration_id"],
             cur=cur,
         )
         count = db.content_fossology_license_add_from_temp(conflict_update, cur)
         return {"content_fossology_license:add": count}
 
     @timed
     @db_transaction()
     def content_fossology_license_get_partition(
         self,
         indexer_configuration_id: int,
         partition_id: int,
         nb_partitions: int,
         page_token: Optional[str] = None,
         limit: int = 1000,
         db=None,
         cur=None,
     ) -> PagedResult[Sha1]:
         return self.get_partition(
             "fossology_license",
             indexer_configuration_id,
             partition_id,
             nb_partitions,
             page_token=page_token,
             limit=limit,
             with_textual_data=True,
             db=db,
             cur=cur,
         )
 
     @timed
     @db_transaction()
     def content_metadata_missing(
         self, metadata: Iterable[Dict], db=None, cur=None
     ) -> List[Tuple[Sha1, int]]:
         return [obj[0] for obj in db.content_metadata_missing_from_list(metadata, cur)]
 
     @timed
     @db_transaction()
     def content_metadata_get(
         self, ids: Iterable[Sha1], db=None, cur=None
     ) -> List[ContentMetadataRow]:
         return [
             ContentMetadataRow.from_dict(
                 converters.db_to_metadata(dict(zip(db.content_metadata_cols, c)))
             )
             for c in db.content_metadata_get_from_list(ids, cur)
         ]
 
     @timed
     @process_metrics
     @db_transaction()
     def content_metadata_add(
         self,
         metadata: List[ContentMetadataRow],
         conflict_update: bool = False,
         db=None,
         cur=None,
     ) -> Dict[str, int]:
         check_id_duplicates(metadata)
         metadata.sort(key=lambda m: m.id)
 
         db.mktemp_content_metadata(cur)
 
         db.copy_to(
             [m.to_dict() for m in metadata],
             "tmp_content_metadata",
             ["id", "metadata", "indexer_configuration_id"],
             cur,
         )
         count = db.content_metadata_add_from_temp(conflict_update, cur)
         return {
             "content_metadata:add": count,
         }
 
     @timed
     @db_transaction()
     def revision_intrinsic_metadata_missing(
         self, metadata: Iterable[Dict], db=None, cur=None
     ) -> List[Tuple[Sha1, int]]:
         return [
             obj[0]
             for obj in db.revision_intrinsic_metadata_missing_from_list(metadata, cur)
         ]
 
     @timed
     @db_transaction()
     def revision_intrinsic_metadata_get(
         self, ids: Iterable[Sha1], db=None, cur=None
     ) -> List[RevisionIntrinsicMetadataRow]:
         return [
             RevisionIntrinsicMetadataRow.from_dict(
                 converters.db_to_metadata(
                     dict(zip(db.revision_intrinsic_metadata_cols, c))
                 )
             )
             for c in db.revision_intrinsic_metadata_get_from_list(ids, cur)
         ]
 
     @timed
     @process_metrics
     @db_transaction()
     def revision_intrinsic_metadata_add(
         self,
         metadata: List[RevisionIntrinsicMetadataRow],
         conflict_update: bool = False,
         db=None,
         cur=None,
     ) -> Dict[str, int]:
         check_id_duplicates(metadata)
         metadata.sort(key=lambda m: m.id)
 
         db.mktemp_revision_intrinsic_metadata(cur)
 
         db.copy_to(
             [m.to_dict() for m in metadata],
             "tmp_revision_intrinsic_metadata",
             ["id", "metadata", "mappings", "indexer_configuration_id"],
             cur,
         )
         count = db.revision_intrinsic_metadata_add_from_temp(conflict_update, cur)
         return {
             "revision_intrinsic_metadata:add": count,
         }
 
-    @timed
-    @process_metrics
-    @db_transaction()
-    def revision_intrinsic_metadata_delete(
-        self, entries: List[Dict], db=None, cur=None
-    ) -> Dict:
-        count = db.revision_intrinsic_metadata_delete(entries, cur)
-        return {"revision_intrinsic_metadata:del": count}
-
     @timed
     @db_transaction()
     def origin_intrinsic_metadata_get(
         self, urls: Iterable[str], db=None, cur=None
     ) -> List[OriginIntrinsicMetadataRow]:
         return [
             OriginIntrinsicMetadataRow.from_dict(
                 converters.db_to_metadata(
                     dict(zip(db.origin_intrinsic_metadata_cols, c))
                 )
             )
             for c in db.origin_intrinsic_metadata_get_from_list(urls, cur)
         ]
 
     @timed
     @process_metrics
     @db_transaction()
     def origin_intrinsic_metadata_add(
         self,
         metadata: List[OriginIntrinsicMetadataRow],
         conflict_update: bool = False,
         db=None,
         cur=None,
     ) -> Dict[str, int]:
         check_id_duplicates(metadata)
         metadata.sort(key=lambda m: m.id)
 
         db.mktemp_origin_intrinsic_metadata(cur)
 
         db.copy_to(
             [m.to_dict() for m in metadata],
             "tmp_origin_intrinsic_metadata",
             ["id", "metadata", "indexer_configuration_id", "from_revision", "mappings"],
             cur,
         )
         count = db.origin_intrinsic_metadata_add_from_temp(conflict_update, cur)
         return {
             "origin_intrinsic_metadata:add": count,
         }
 
-    @timed
-    @process_metrics
-    @db_transaction()
-    def origin_intrinsic_metadata_delete(
-        self, entries: List[Dict], db=None, cur=None
-    ) -> Dict:
-        count = db.origin_intrinsic_metadata_delete(entries, cur)
-        return {
-            "origin_intrinsic_metadata:del": count,
-        }
-
     @timed
     @db_transaction()
     def origin_intrinsic_metadata_search_fulltext(
         self, conjunction: List[str], limit: int = 100, db=None, cur=None
     ) -> List[OriginIntrinsicMetadataRow]:
         return [
             OriginIntrinsicMetadataRow.from_dict(
                 converters.db_to_metadata(
                     dict(zip(db.origin_intrinsic_metadata_cols, c))
                 )
             )
             for c in db.origin_intrinsic_metadata_search_fulltext(
                 conjunction, limit=limit, cur=cur
             )
         ]
 
     @timed
     @db_transaction()
     def origin_intrinsic_metadata_search_by_producer(
         self,
         page_token: str = "",
         limit: int = 100,
         ids_only: bool = False,
         mappings: Optional[List[str]] = None,
         tool_ids: Optional[List[int]] = None,
         db=None,
         cur=None,
     ) -> PagedResult[Union[str, OriginIntrinsicMetadataRow]]:
         assert isinstance(page_token, str)
         # we go to limit+1 to check whether we should add next_page_token in
         # the response
         rows = db.origin_intrinsic_metadata_search_by_producer(
             page_token, limit + 1, ids_only, mappings, tool_ids, cur
         )
         next_page_token = None
         if ids_only:
             results = [origin for (origin,) in rows]
             if len(results) > limit:
                 results[limit:] = []
                 next_page_token = results[-1]
         else:
             results = [
                 OriginIntrinsicMetadataRow.from_dict(
                     converters.db_to_metadata(
                         dict(zip(db.origin_intrinsic_metadata_cols, row))
                     )
                 )
                 for row in rows
             ]
             if len(results) > limit:
                 results[limit:] = []
                 next_page_token = results[-1].id
 
         return PagedResult(results=results, next_page_token=next_page_token,)
 
     @timed
     @db_transaction()
     def origin_intrinsic_metadata_stats(self, db=None, cur=None):
         mapping_names = [m for m in MAPPING_NAMES]
         select_parts = []
 
         # Count rows for each mapping
         for mapping_name in mapping_names:
             select_parts.append(
                 (
                     "sum(case when (mappings @> ARRAY['%s']) "
                     "         then 1 else 0 end)"
                 )
                 % mapping_name
             )
 
         # Total
         select_parts.append("sum(1)")
 
         # Rows whose metadata has at least one key that is not '@context'
         select_parts.append(
             "sum(case when ('{}'::jsonb @> (metadata - '@context')) "
             "         then 0 else 1 end)"
         )
         cur.execute(
             "select " + ", ".join(select_parts) + " from origin_intrinsic_metadata"
         )
         results = dict(zip(mapping_names + ["total", "non_empty"], cur.fetchone()))
         return {
             "total": results.pop("total"),
             "non_empty": results.pop("non_empty"),
             "per_mapping": results,
         }
 
     @timed
     @db_transaction()
     def indexer_configuration_add(self, tools, db=None, cur=None):
         db.mktemp_indexer_configuration(cur)
         db.copy_to(
             tools,
             "tmp_indexer_configuration",
             ["tool_name", "tool_version", "tool_configuration"],
             cur,
         )
 
         tools = db.indexer_configuration_add_from_temp(cur)
         results = [dict(zip(db.indexer_configuration_cols, line)) for line in tools]
         send_metric(
             "indexer_configuration:add",
             len(results),
             method_name="indexer_configuration_add",
         )
         return results
 
     @timed
     @db_transaction()
     def indexer_configuration_get(self, tool, db=None, cur=None):
         tool_conf = tool["tool_configuration"]
         if isinstance(tool_conf, dict):
             tool_conf = json.dumps(tool_conf)
         idx = db.indexer_configuration_get(
             tool["tool_name"], tool["tool_version"], tool_conf
         )
         if not idx:
             return None
         return dict(zip(db.indexer_configuration_cols, idx))
diff --git a/swh/indexer/storage/db.py b/swh/indexer/storage/db.py
index c5ea770..24d4758 100644
--- a/swh/indexer/storage/db.py
+++ b/swh/indexer/storage/db.py
@@ -1,566 +1,544 @@
 # Copyright (C) 2015-2018  The Software Heritage developers
 # See the AUTHORS file at the top-level directory of this distribution
 # License: GNU General Public License version 3, or any later version
 # See top-level LICENSE file for more information
 
 from typing import Dict, Iterable, Iterator, List
 
 from swh.core.db import BaseDb
 from swh.core.db.db_utils import execute_values_generator, stored_procedure
 from swh.model import hashutil
 
 from .interface import Sha1
 
 
 class Db(BaseDb):
     """Proxy to the SWH Indexer DB, with wrappers around stored procedures
 
     """
 
     content_mimetype_hash_keys = ["id", "indexer_configuration_id"]
 
     def _missing_from_list(
         self, table: str, data: Iterable[Dict], hash_keys: List[str], cur=None
     ):
         """Read from table the data with hash_keys that are missing.
 
         Args:
             table: Table name (e.g content_mimetype, content_language,
               etc...)
             data: Dict of data to read from
             hash_keys: List of keys to read in the data dict.
 
         Yields:
             The data which is missing from the db.
 
         """
         cur = self._cursor(cur)
         keys = ", ".join(hash_keys)
         equality = " AND ".join(("t.%s = c.%s" % (key, key)) for key in hash_keys)
         yield from execute_values_generator(
             cur,
             """
             select %s from (values %%s) as t(%s)
             where not exists (
                 select 1 from %s c
                 where %s
             )
             """
             % (keys, keys, table, equality),
             (tuple(m[k] for k in hash_keys) for m in data),
         )
 
     def content_mimetype_missing_from_list(
         self, mimetypes: Iterable[Dict], cur=None
     ) -> Iterator[Sha1]:
         """List missing mimetypes.
 
         """
         yield from self._missing_from_list(
             "content_mimetype", mimetypes, self.content_mimetype_hash_keys, cur=cur
         )
 
     content_mimetype_cols = [
         "id",
         "mimetype",
         "encoding",
         "tool_id",
         "tool_name",
         "tool_version",
         "tool_configuration",
     ]
 
     @stored_procedure("swh_mktemp_content_mimetype")
     def mktemp_content_mimetype(self, cur=None):
         pass
 
     def content_mimetype_add_from_temp(self, conflict_update, cur=None):
         cur = self._cursor(cur)
         cur.execute("select * from swh_content_mimetype_add(%s)", (conflict_update,))
         return cur.fetchone()[0]
 
     def _convert_key(self, key, main_table="c"):
         """Convert keys according to specific use in the module.
 
         Args:
             key (str): Key expression to change according to the alias
               used in the query
             main_table (str): Alias to use for the main table. Default
               to c for content_{something}.
 
         Expected:
             Tables content_{something} being aliased as 'c' (something
             in {language, mimetype, ...}), table indexer_configuration
             being aliased as 'i'.
 
         """
         if key == "id":
             return "%s.id" % main_table
         elif key == "tool_id":
             return "i.id as tool_id"
         elif key == "license":
             return (
                 """
                 (
                     select name
                     from fossology_license
                     where id = %s.license_id
                 )
                 as licenses"""
                 % main_table
             )
         return key
 
     def _get_from_list(self, table, ids, cols, cur=None, id_col="id"):
         """Fetches entries from the `table` such that their `id` field
         (or whatever is given to `id_col`) is in `ids`.
         Returns the columns `cols`.
         The `cur` parameter is used to connect to the database.
         """
         cur = self._cursor(cur)
         keys = map(self._convert_key, cols)
         query = """
             select {keys}
             from (values %s) as t(id)
             inner join {table} c
                 on c.{id_col}=t.id
             inner join indexer_configuration i
                 on c.indexer_configuration_id=i.id;
             """.format(
             keys=", ".join(keys), id_col=id_col, table=table
         )
         yield from execute_values_generator(cur, query, ((_id,) for _id in ids))
 
     content_indexer_names = {
         "mimetype": "content_mimetype",
         "fossology_license": "content_fossology_license",
     }
 
     def content_get_range(
         self,
         content_type,
         start,
         end,
         indexer_configuration_id,
         limit=1000,
         with_textual_data=False,
         cur=None,
     ):
         """Retrieve contents with content_type, within range [start, end]
            bound by limit and associated to the given indexer
            configuration id.
 
            When asking to work on textual content, that filters on the
            mimetype table with any mimetype that is not binary.
 
         """
         cur = self._cursor(cur)
         table = self.content_indexer_names[content_type]
         if with_textual_data:
             extra = """inner join content_mimetype cm
                          on (t.id=cm.id and cm.mimetype like 'text/%%' and
                              %(start)s <= cm.id and cm.id <= %(end)s)
                     """
         else:
             extra = ""
         query = f"""select t.id
                     from {table} t
                     {extra}
                     where t.indexer_configuration_id=%(tool_id)s
                           and %(start)s <= t.id and t.id <= %(end)s
                     order by t.indexer_configuration_id, t.id
                     limit %(limit)s"""
         cur.execute(
             query,
             {
                 "start": start,
                 "end": end,
                 "tool_id": indexer_configuration_id,
                 "limit": limit,
             },
         )
         yield from cur
 
     def content_mimetype_get_from_list(self, ids, cur=None):
         yield from self._get_from_list(
             "content_mimetype", ids, self.content_mimetype_cols, cur=cur
         )
 
     content_language_hash_keys = ["id", "indexer_configuration_id"]
 
     def content_language_missing_from_list(self, languages, cur=None):
         """List missing languages.
 
         """
         yield from self._missing_from_list(
             "content_language", languages, self.content_language_hash_keys, cur=cur
         )
 
     content_language_cols = [
         "id",
         "lang",
         "tool_id",
         "tool_name",
         "tool_version",
         "tool_configuration",
     ]
 
     @stored_procedure("swh_mktemp_content_language")
     def mktemp_content_language(self, cur=None):
         pass
 
     def content_language_add_from_temp(self, conflict_update, cur=None):
         cur = self._cursor(cur)
         cur.execute("select * from swh_content_language_add(%s)", (conflict_update,))
         return cur.fetchone()[0]
 
     def content_language_get_from_list(self, ids, cur=None):
         yield from self._get_from_list(
             "content_language", ids, self.content_language_cols, cur=cur
         )
 
     content_ctags_hash_keys = ["id", "indexer_configuration_id"]
 
     def content_ctags_missing_from_list(self, ctags, cur=None):
         """List missing ctags.
 
         """
         yield from self._missing_from_list(
             "content_ctags", ctags, self.content_ctags_hash_keys, cur=cur
         )
 
     content_ctags_cols = [
         "id",
         "name",
         "kind",
         "line",
         "lang",
         "tool_id",
         "tool_name",
         "tool_version",
         "tool_configuration",
     ]
 
     @stored_procedure("swh_mktemp_content_ctags")
     def mktemp_content_ctags(self, cur=None):
         pass
 
     def content_ctags_add_from_temp(self, conflict_update, cur=None):
         cur = self._cursor(cur)
         cur.execute("select * from swh_content_ctags_add(%s)", (conflict_update,))
         return cur.fetchone()[0]
 
     def content_ctags_get_from_list(self, ids, cur=None):
         cur = self._cursor(cur)
         keys = map(self._convert_key, self.content_ctags_cols)
         yield from execute_values_generator(
             cur,
             """
             select %s
             from (values %%s) as t(id)
             inner join content_ctags c
                 on c.id=t.id
             inner join indexer_configuration i
                 on c.indexer_configuration_id=i.id
             order by line
             """
             % ", ".join(keys),
             ((_id,) for _id in ids),
         )
 
     def content_ctags_search(self, expression, last_sha1, limit, cur=None):
         cur = self._cursor(cur)
         if not last_sha1:
             query = """SELECT %s
                        FROM swh_content_ctags_search(%%s, %%s)""" % (
                 ",".join(self.content_ctags_cols)
             )
             cur.execute(query, (expression, limit))
         else:
             if last_sha1 and isinstance(last_sha1, bytes):
                 last_sha1 = "\\x%s" % hashutil.hash_to_hex(last_sha1)
             elif last_sha1:
                 last_sha1 = "\\x%s" % last_sha1
 
             query = """SELECT %s
                        FROM swh_content_ctags_search(%%s, %%s, %%s)""" % (
                 ",".join(self.content_ctags_cols)
             )
             cur.execute(query, (expression, limit, last_sha1))
 
         yield from cur
 
     content_fossology_license_cols = [
         "id",
         "tool_id",
         "tool_name",
         "tool_version",
         "tool_configuration",
         "license",
     ]
 
     @stored_procedure("swh_mktemp_content_fossology_license")
     def mktemp_content_fossology_license(self, cur=None):
         pass
 
     def content_fossology_license_add_from_temp(self, conflict_update, cur=None):
         """Add new licenses per content.
 
         """
         cur = self._cursor(cur)
         cur.execute(
             "select * from swh_content_fossology_license_add(%s)", (conflict_update,)
         )
         return cur.fetchone()[0]
 
     def content_fossology_license_get_from_list(self, ids, cur=None):
         """Retrieve licenses per id.
 
         """
         cur = self._cursor(cur)
         keys = map(self._convert_key, self.content_fossology_license_cols)
         yield from execute_values_generator(
             cur,
             """
             select %s
             from (values %%s) as t(id)
             inner join content_fossology_license c on t.id=c.id
             inner join indexer_configuration i
                 on i.id=c.indexer_configuration_id
             """
             % ", ".join(keys),
             ((_id,) for _id in ids),
         )
 
     content_metadata_hash_keys = ["id", "indexer_configuration_id"]
 
     def content_metadata_missing_from_list(self, metadata, cur=None):
         """List missing metadata.
 
         """
         yield from self._missing_from_list(
             "content_metadata", metadata, self.content_metadata_hash_keys, cur=cur
         )
 
     content_metadata_cols = [
         "id",
         "metadata",
         "tool_id",
         "tool_name",
         "tool_version",
         "tool_configuration",
     ]
 
     @stored_procedure("swh_mktemp_content_metadata")
     def mktemp_content_metadata(self, cur=None):
         pass
 
     def content_metadata_add_from_temp(self, conflict_update, cur=None):
         cur = self._cursor(cur)
         cur.execute("select * from swh_content_metadata_add(%s)", (conflict_update,))
         return cur.fetchone()[0]
 
     def content_metadata_get_from_list(self, ids, cur=None):
         yield from self._get_from_list(
             "content_metadata", ids, self.content_metadata_cols, cur=cur
         )
 
     revision_intrinsic_metadata_hash_keys = ["id", "indexer_configuration_id"]
 
     def revision_intrinsic_metadata_missing_from_list(self, metadata, cur=None):
         """List missing metadata.
 
         """
         yield from self._missing_from_list(
             "revision_intrinsic_metadata",
             metadata,
             self.revision_intrinsic_metadata_hash_keys,
             cur=cur,
         )
 
     revision_intrinsic_metadata_cols = [
         "id",
         "metadata",
         "mappings",
         "tool_id",
         "tool_name",
         "tool_version",
         "tool_configuration",
     ]
 
     @stored_procedure("swh_mktemp_revision_intrinsic_metadata")
     def mktemp_revision_intrinsic_metadata(self, cur=None):
         pass
 
     def revision_intrinsic_metadata_add_from_temp(self, conflict_update, cur=None):
         cur = self._cursor(cur)
         cur.execute(
             "select * from swh_revision_intrinsic_metadata_add(%s)", (conflict_update,)
         )
         return cur.fetchone()[0]
 
-    def revision_intrinsic_metadata_delete(self, entries, cur=None):
-        cur = self._cursor(cur)
-        cur.execute(
-            "DELETE from revision_intrinsic_metadata "
-            "WHERE (id, indexer_configuration_id) IN "
-            "   (VALUES %s) "
-            "RETURNING id" % (", ".join("%s" for _ in entries)),
-            tuple((e["id"], e["indexer_configuration_id"]) for e in entries),
-        )
-        return len(cur.fetchall())
-
     def revision_intrinsic_metadata_get_from_list(self, ids, cur=None):
         yield from self._get_from_list(
             "revision_intrinsic_metadata",
             ids,
             self.revision_intrinsic_metadata_cols,
             cur=cur,
         )
 
     origin_intrinsic_metadata_cols = [
         "id",
         "metadata",
         "from_revision",
         "mappings",
         "tool_id",
         "tool_name",
         "tool_version",
         "tool_configuration",
     ]
 
     origin_intrinsic_metadata_regconfig = "pg_catalog.simple"
     """The dictionary used to normalize 'metadata' and queries.
     'pg_catalog.simple' provides no stopword, so it should be suitable
     for proper names and non-English content.
     When updating this value, make sure to add a new index on
     origin_intrinsic_metadata.metadata."""
 
     @stored_procedure("swh_mktemp_origin_intrinsic_metadata")
     def mktemp_origin_intrinsic_metadata(self, cur=None):
         pass
 
     def origin_intrinsic_metadata_add_from_temp(self, conflict_update, cur=None):
         cur = self._cursor(cur)
         cur.execute(
             "select * from swh_origin_intrinsic_metadata_add(%s)", (conflict_update,)
         )
         return cur.fetchone()[0]
 
-    def origin_intrinsic_metadata_delete(self, entries, cur=None):
-        cur = self._cursor(cur)
-        cur.execute(
-            "DELETE from origin_intrinsic_metadata "
-            "WHERE (id, indexer_configuration_id) IN"
-            "   (VALUES %s) "
-            "RETURNING id" % (", ".join("%s" for _ in entries)),
-            tuple((e["id"], e["indexer_configuration_id"]) for e in entries),
-        )
-        return len(cur.fetchall())
-
     def origin_intrinsic_metadata_get_from_list(self, ids, cur=None):
         yield from self._get_from_list(
             "origin_intrinsic_metadata",
             ids,
             self.origin_intrinsic_metadata_cols,
             cur=cur,
             id_col="id",
         )
 
     def origin_intrinsic_metadata_search_fulltext(self, terms, *, limit, cur):
         regconfig = self.origin_intrinsic_metadata_regconfig
         tsquery_template = " && ".join(
             "plainto_tsquery('%s', %%s)" % regconfig for _ in terms
         )
         tsquery_args = [(term,) for term in terms]
         keys = (
             self._convert_key(col, "oim") for col in self.origin_intrinsic_metadata_cols
         )
 
         query = (
             "SELECT {keys} FROM origin_intrinsic_metadata AS oim "
             "INNER JOIN indexer_configuration AS i "
             "ON oim.indexer_configuration_id=i.id "
             "JOIN LATERAL (SELECT {tsquery_template}) AS s(tsq) ON true "
             "WHERE oim.metadata_tsvector @@ tsq "
             "ORDER BY ts_rank(oim.metadata_tsvector, tsq, 1) DESC "
             "LIMIT %s;"
         ).format(keys=", ".join(keys), tsquery_template=tsquery_template)
         cur.execute(query, tsquery_args + [limit])
         yield from cur
 
     def origin_intrinsic_metadata_search_by_producer(
         self, last, limit, ids_only, mappings, tool_ids, cur
     ):
         if ids_only:
             keys = "oim.id"
         else:
             keys = ", ".join(
                 (
                     self._convert_key(col, "oim")
                     for col in self.origin_intrinsic_metadata_cols
                 )
             )
         query_parts = [
             "SELECT %s" % keys,
             "FROM origin_intrinsic_metadata AS oim",
             "INNER JOIN indexer_configuration AS i",
             "ON oim.indexer_configuration_id=i.id",
         ]
         args = []
 
         where = []
         if last:
             where.append("oim.id > %s")
             args.append(last)
         if mappings is not None:
             where.append("oim.mappings && %s")
             args.append(mappings)
         if tool_ids is not None:
             where.append("oim.indexer_configuration_id = ANY(%s)")
             args.append(tool_ids)
         if where:
             query_parts.append("WHERE")
             query_parts.append(" AND ".join(where))
 
         if limit:
             query_parts.append("LIMIT %s")
             args.append(limit)
 
         cur.execute(" ".join(query_parts), args)
         yield from cur
 
     indexer_configuration_cols = [
         "id",
         "tool_name",
         "tool_version",
         "tool_configuration",
     ]
 
     @stored_procedure("swh_mktemp_indexer_configuration")
     def mktemp_indexer_configuration(self, cur=None):
         pass
 
     def indexer_configuration_add_from_temp(self, cur=None):
         cur = self._cursor(cur)
         cur.execute(
             "SELECT %s from swh_indexer_configuration_add()"
             % (",".join(self.indexer_configuration_cols),)
         )
         yield from cur
 
     def indexer_configuration_get(
         self, tool_name, tool_version, tool_configuration, cur=None
     ):
         cur = self._cursor(cur)
         cur.execute(
             """select %s
                        from indexer_configuration
                        where tool_name=%%s and
                              tool_version=%%s and
                              tool_configuration=%%s"""
             % (",".join(self.indexer_configuration_cols)),
             (tool_name, tool_version, tool_configuration),
         )
 
         return cur.fetchone()
diff --git a/swh/indexer/storage/in_memory.py b/swh/indexer/storage/in_memory.py
index 5f8c517..96d585d 100644
--- a/swh/indexer/storage/in_memory.py
+++ b/swh/indexer/storage/in_memory.py
@@ -1,520 +1,496 @@
 # Copyright (C) 2018-2020  The Software Heritage developers
 # See the AUTHORS file at the top-level directory of this distribution
 # License: GNU General Public License version 3, or any later version
 # See top-level LICENSE file for more information
 
 from collections import Counter, defaultdict
 import itertools
 import json
 import math
 import operator
 import re
 from typing import (
     Any,
     Dict,
     Generic,
     Iterable,
     List,
     Optional,
     Set,
     Tuple,
     Type,
     TypeVar,
     Union,
 )
 
 from swh.core.collections import SortedList
 from swh.model.hashutil import hash_to_bytes, hash_to_hex
 from swh.model.model import SHA1_SIZE, Sha1Git
 from swh.storage.utils import get_partition_bounds_bytes
 
 from . import MAPPING_NAMES, check_id_duplicates
 from .exc import IndexerStorageArgumentException
 from .interface import PagedResult, Sha1
 from .model import (
     BaseRow,
     ContentCtagsRow,
     ContentLanguageRow,
     ContentLicenseRow,
     ContentMetadataRow,
     ContentMimetypeRow,
     OriginIntrinsicMetadataRow,
     RevisionIntrinsicMetadataRow,
 )
 
 SHA1_DIGEST_SIZE = 160
 
 
 def _transform_tool(tool):
     return {
         "id": tool["id"],
         "name": tool["tool_name"],
         "version": tool["tool_version"],
         "configuration": tool["tool_configuration"],
     }
 
 
 def check_id_types(data: List[Dict[str, Any]]):
     """Checks all elements of the list have an 'id' whose type is 'bytes'."""
     if not all(isinstance(item.get("id"), bytes) for item in data):
         raise IndexerStorageArgumentException("identifiers must be bytes.")
 
 
 def _key_from_dict(d):
     return tuple(sorted(d.items()))
 
 
 ToolId = int
 TValue = TypeVar("TValue", bound=BaseRow)
 
 
 class SubStorage(Generic[TValue]):
     """Implements common missing/get/add logic for each indexer type."""
 
     _data: Dict[Sha1, Dict[Tuple, Dict[str, Any]]]
     _tools_per_id: Dict[Sha1, Set[ToolId]]
 
     def __init__(self, row_class: Type[TValue], tools):
         self.row_class = row_class
         self._tools = tools
         self._sorted_ids = SortedList[bytes, Sha1]()
         self._data = defaultdict(dict)
         self._tools_per_id = defaultdict(set)
 
     def _key_from_dict(self, d) -> Tuple:
         """Like the global _key_from_dict, but filters out dict keys that don't
         belong in the unique key."""
         return _key_from_dict({k: d[k] for k in self.row_class.UNIQUE_KEY_FIELDS})
 
     def missing(self, keys: Iterable[Dict]) -> List[Sha1]:
         """List data missing from storage.
 
         Args:
             data (iterable): dictionaries with keys:
 
                 - **id** (bytes): sha1 identifier
                 - **indexer_configuration_id** (int): tool used to compute
                   the results
 
         Yields:
             missing sha1s
 
         """
         results = []
         for key in keys:
             tool_id = key["indexer_configuration_id"]
             id_ = key["id"]
             if tool_id not in self._tools_per_id.get(id_, set()):
                 results.append(id_)
         return results
 
     def get(self, ids: Iterable[Sha1]) -> List[TValue]:
         """Retrieve data per id.
 
         Args:
             ids (iterable): sha1 checksums
 
         Yields:
             dict: dictionaries with the following keys:
 
               - **id** (bytes)
               - **tool** (dict): tool used to compute metadata
               - arbitrary data (as provided to `add`)
 
         """
         results = []
         for id_ in ids:
             for entry in self._data[id_].values():
                 entry = entry.copy()
                 tool_id = entry.pop("indexer_configuration_id")
                 results.append(
                     self.row_class(
                         id=id_, tool=_transform_tool(self._tools[tool_id]), **entry,
                     )
                 )
         return results
 
     def get_all(self) -> List[TValue]:
         return self.get(self._sorted_ids)
 
     def get_partition(
         self,
         indexer_configuration_id: int,
         partition_id: int,
         nb_partitions: int,
         page_token: Optional[str] = None,
         limit: int = 1000,
     ) -> PagedResult[Sha1]:
         """Retrieve ids of content with `indexer_type` within partition partition_id
         bound by limit.
 
         Args:
             **indexer_type**: Type of data content to index (mimetype, language, etc...)
             **indexer_configuration_id**: The tool used to index data
             **partition_id**: index of the partition to fetch
             **nb_partitions**: total number of partitions to split into
             **page_token**: opaque token used for pagination
             **limit**: Limit result (default to 1000)
             **with_textual_data** (bool): Deal with only textual content (True) or all
                 content (all contents by defaults, False)
 
         Raises:
             IndexerStorageArgumentException for;
             - limit to None
             - wrong indexer_type provided
 
         Returns:
             PagedResult of Sha1. If next_page_token is None, there is no more data to
             fetch
 
         """
         if limit is None:
             raise IndexerStorageArgumentException("limit should not be None")
         (start, end) = get_partition_bounds_bytes(
             partition_id, nb_partitions, SHA1_SIZE
         )
 
         if page_token:
             start = hash_to_bytes(page_token)
         if end is None:
             end = b"\xff" * SHA1_SIZE
 
         next_page_token: Optional[str] = None
         ids: List[Sha1] = []
         sha1s = (sha1 for sha1 in self._sorted_ids.iter_from(start))
         for counter, sha1 in enumerate(sha1s):
             if sha1 > end:
                 break
             if counter >= limit:
                 next_page_token = hash_to_hex(sha1)
                 break
             ids.append(sha1)
 
         assert len(ids) <= limit
         return PagedResult(results=ids, next_page_token=next_page_token)
 
     def add(self, data: Iterable[TValue], conflict_update: bool) -> int:
         """Add data not present in storage.
 
         Args:
             data (iterable): dictionaries with keys:
 
               - **id**: sha1
               - **indexer_configuration_id**: tool used to compute the
                 results
               - arbitrary data
 
             conflict_update (bool): Flag to determine if we want to overwrite
               (true) or skip duplicates (false)
 
         """
         data = list(data)
         check_id_duplicates(data)
         count = 0
         for obj in data:
             item = obj.to_dict()
             id_ = item.pop("id")
             tool_id = item["indexer_configuration_id"]
             key = _key_from_dict(obj.unique_key())
             if not conflict_update and key in self._data[id_]:
                 # Duplicate, should not be updated
                 continue
             self._data[id_][key] = item
             self._tools_per_id[id_].add(tool_id)
             count += 1
             if id_ not in self._sorted_ids:
                 self._sorted_ids.add(id_)
         return count
 
-    def delete(self, entries: List[Dict]) -> int:
-        """Delete entries and return the number of entries deleted.
-
-        """
-        deleted = 0
-        for entry in entries:
-            (id_, tool_id) = (entry["id"], entry["indexer_configuration_id"])
-            if tool_id in self._tools_per_id[id_]:
-                self._tools_per_id[id_].remove(tool_id)
-            if id_ in self._data:
-                key = self._key_from_dict(entry)
-                if key in self._data[id_]:
-                    deleted += 1
-                    del self._data[id_][key]
-        return deleted
-
 
 class IndexerStorage:
     """In-memory SWH indexer storage."""
 
     def __init__(self):
         self._tools = {}
         self._mimetypes = SubStorage(ContentMimetypeRow, self._tools)
         self._languages = SubStorage(ContentLanguageRow, self._tools)
         self._content_ctags = SubStorage(ContentCtagsRow, self._tools)
         self._licenses = SubStorage(ContentLicenseRow, self._tools)
         self._content_metadata = SubStorage(ContentMetadataRow, self._tools)
         self._revision_intrinsic_metadata = SubStorage(
             RevisionIntrinsicMetadataRow, self._tools
         )
         self._origin_intrinsic_metadata = SubStorage(
             OriginIntrinsicMetadataRow, self._tools
         )
 
     def check_config(self, *, check_write):
         return True
 
     def content_mimetype_missing(
         self, mimetypes: Iterable[Dict]
     ) -> List[Tuple[Sha1, int]]:
         return self._mimetypes.missing(mimetypes)
 
     def content_mimetype_get_partition(
         self,
         indexer_configuration_id: int,
         partition_id: int,
         nb_partitions: int,
         page_token: Optional[str] = None,
         limit: int = 1000,
     ) -> PagedResult[Sha1]:
         return self._mimetypes.get_partition(
             indexer_configuration_id, partition_id, nb_partitions, page_token, limit
         )
 
     def content_mimetype_add(
         self, mimetypes: List[ContentMimetypeRow], conflict_update: bool = False
     ) -> Dict[str, int]:
         added = self._mimetypes.add(mimetypes, conflict_update)
         return {"content_mimetype:add": added}
 
     def content_mimetype_get(self, ids: Iterable[Sha1]) -> List[ContentMimetypeRow]:
         return self._mimetypes.get(ids)
 
     def content_language_missing(
         self, languages: Iterable[Dict]
     ) -> List[Tuple[Sha1, int]]:
         return self._languages.missing(languages)
 
     def content_language_get(self, ids: Iterable[Sha1]) -> List[ContentLanguageRow]:
         return self._languages.get(ids)
 
     def content_language_add(
         self, languages: List[ContentLanguageRow], conflict_update: bool = False
     ) -> Dict[str, int]:
         added = self._languages.add(languages, conflict_update)
         return {"content_language:add": added}
 
     def content_ctags_missing(self, ctags: Iterable[Dict]) -> List[Tuple[Sha1, int]]:
         return self._content_ctags.missing(ctags)
 
     def content_ctags_get(self, ids: Iterable[Sha1]) -> List[ContentCtagsRow]:
         return self._content_ctags.get(ids)
 
     def content_ctags_add(
         self, ctags: List[ContentCtagsRow], conflict_update: bool = False
     ) -> Dict[str, int]:
         added = self._content_ctags.add(ctags, conflict_update,)
         return {"content_ctags:add": added}
 
     def content_ctags_search(
         self, expression: str, limit: int = 10, last_sha1: Optional[Sha1] = None
     ) -> List[ContentCtagsRow]:
         nb_matches = 0
         items_per_id: Dict[Tuple[Sha1Git, ToolId], List[ContentCtagsRow]] = {}
         for item in sorted(self._content_ctags.get_all()):
             if item.id <= (last_sha1 or bytes(0 for _ in range(SHA1_DIGEST_SIZE))):
                 continue
             items_per_id.setdefault(
                 (item.id, item.indexer_configuration_id), []
             ).append(item)
 
         results = []
         for items in items_per_id.values():
             for item in items:
                 if item.name != expression:
                     continue
                 nb_matches += 1
                 if nb_matches > limit:
                     break
                 results.append(item)
 
         return results
 
     def content_fossology_license_get(
         self, ids: Iterable[Sha1]
     ) -> List[ContentLicenseRow]:
         return self._licenses.get(ids)
 
     def content_fossology_license_add(
         self, licenses: List[ContentLicenseRow], conflict_update: bool = False
     ) -> Dict[str, int]:
         added = self._licenses.add(licenses, conflict_update)
         return {"content_fossology_license:add": added}
 
     def content_fossology_license_get_partition(
         self,
         indexer_configuration_id: int,
         partition_id: int,
         nb_partitions: int,
         page_token: Optional[str] = None,
         limit: int = 1000,
     ) -> PagedResult[Sha1]:
         return self._licenses.get_partition(
             indexer_configuration_id, partition_id, nb_partitions, page_token, limit
         )
 
     def content_metadata_missing(
         self, metadata: Iterable[Dict]
     ) -> List[Tuple[Sha1, int]]:
         return self._content_metadata.missing(metadata)
 
     def content_metadata_get(self, ids: Iterable[Sha1]) -> List[ContentMetadataRow]:
         return self._content_metadata.get(ids)
 
     def content_metadata_add(
         self, metadata: List[ContentMetadataRow], conflict_update: bool = False
     ) -> Dict[str, int]:
         added = self._content_metadata.add(metadata, conflict_update)
         return {"content_metadata:add": added}
 
     def revision_intrinsic_metadata_missing(
         self, metadata: Iterable[Dict]
     ) -> List[Tuple[Sha1, int]]:
         return self._revision_intrinsic_metadata.missing(metadata)
 
     def revision_intrinsic_metadata_get(
         self, ids: Iterable[Sha1]
     ) -> List[RevisionIntrinsicMetadataRow]:
         return self._revision_intrinsic_metadata.get(ids)
 
     def revision_intrinsic_metadata_add(
         self,
         metadata: List[RevisionIntrinsicMetadataRow],
         conflict_update: bool = False,
     ) -> Dict[str, int]:
         added = self._revision_intrinsic_metadata.add(metadata, conflict_update)
         return {"revision_intrinsic_metadata:add": added}
 
-    def revision_intrinsic_metadata_delete(self, entries: List[Dict]) -> Dict:
-        deleted = self._revision_intrinsic_metadata.delete(entries)
-        return {"revision_intrinsic_metadata:del": deleted}
-
     def origin_intrinsic_metadata_get(
         self, urls: Iterable[str]
     ) -> List[OriginIntrinsicMetadataRow]:
         return self._origin_intrinsic_metadata.get(urls)
 
     def origin_intrinsic_metadata_add(
         self, metadata: List[OriginIntrinsicMetadataRow], conflict_update: bool = False
     ) -> Dict[str, int]:
         added = self._origin_intrinsic_metadata.add(metadata, conflict_update)
         return {"origin_intrinsic_metadata:add": added}
 
-    def origin_intrinsic_metadata_delete(self, entries: List[Dict]) -> Dict:
-        deleted = self._origin_intrinsic_metadata.delete(entries)
-        return {"origin_intrinsic_metadata:del": deleted}
-
     def origin_intrinsic_metadata_search_fulltext(
         self, conjunction: List[str], limit: int = 100
     ) -> List[OriginIntrinsicMetadataRow]:
         # A very crude fulltext search implementation, but that's enough
         # to work on English metadata
         tokens_re = re.compile("[a-zA-Z0-9]+")
         search_tokens = list(itertools.chain(*map(tokens_re.findall, conjunction)))
 
         def rank(data):
             # Tokenize the metadata
             text = json.dumps(data.metadata)
             text_tokens = tokens_re.findall(text)
             text_token_occurences = Counter(text_tokens)
 
             # Count the number of occurrences of search tokens in the text
             score = 0
             for search_token in search_tokens:
                 if text_token_occurences[search_token] == 0:
                     # Search token is not in the text.
                     return 0
                 score += text_token_occurences[search_token]
 
             # Normalize according to the text's length
             return score / math.log(len(text_tokens))
 
         results = [
             (rank(data), data) for data in self._origin_intrinsic_metadata.get_all()
         ]
         results = [(rank_, data) for (rank_, data) in results if rank_ > 0]
         results.sort(
             key=operator.itemgetter(0), reverse=True  # Don't try to order 'data'
         )
         return [result for (rank_, result) in results[:limit]]
 
     def origin_intrinsic_metadata_search_by_producer(
         self,
         page_token: str = "",
         limit: int = 100,
         ids_only: bool = False,
         mappings: Optional[List[str]] = None,
         tool_ids: Optional[List[int]] = None,
     ) -> PagedResult[Union[str, OriginIntrinsicMetadataRow]]:
         assert isinstance(page_token, str)
         nb_results = 0
         if mappings is not None:
             mapping_set = frozenset(mappings)
         if tool_ids is not None:
             tool_id_set = frozenset(tool_ids)
         rows = []
 
         # we go to limit+1 to check whether we should add next_page_token in
         # the response
         for entry in self._origin_intrinsic_metadata.get_all():
             if entry.id <= page_token:
                 continue
             if nb_results >= (limit + 1):
                 break
             if mappings and mapping_set.isdisjoint(entry.mappings):
                 continue
             if tool_ids and entry.tool["id"] not in tool_id_set:
                 continue
             rows.append(entry)
             nb_results += 1
 
         if len(rows) > limit:
             rows = rows[:limit]
             next_page_token = rows[-1].id
         else:
             next_page_token = None
         if ids_only:
             rows = [row.id for row in rows]
         return PagedResult(results=rows, next_page_token=next_page_token,)
 
     def origin_intrinsic_metadata_stats(self):
         mapping_count = {m: 0 for m in MAPPING_NAMES}
         total = non_empty = 0
         for data in self._origin_intrinsic_metadata.get_all():
             total += 1
             if set(data.metadata) - {"@context"}:
                 non_empty += 1
             for mapping in data.mappings:
                 mapping_count[mapping] += 1
         return {"per_mapping": mapping_count, "total": total, "non_empty": non_empty}
 
     def indexer_configuration_add(self, tools):
         inserted = []
         for tool in tools:
             tool = tool.copy()
             id_ = self._tool_key(tool)
             tool["id"] = id_
             self._tools[id_] = tool
             inserted.append(tool)
         return inserted
 
     def indexer_configuration_get(self, tool):
         return self._tools.get(self._tool_key(tool))
 
     def _tool_key(self, tool):
         return hash(
             (
                 tool["tool_name"],
                 tool["tool_version"],
                 json.dumps(tool["tool_configuration"], sort_keys=True),
             )
         )
diff --git a/swh/indexer/storage/interface.py b/swh/indexer/storage/interface.py
index e4563c6..7d857d1 100644
--- a/swh/indexer/storage/interface.py
+++ b/swh/indexer/storage/interface.py
@@ -1,572 +1,540 @@
 # Copyright (C) 2015-2020  The Software Heritage developers
 # See the AUTHORS file at the top-level directory of this distribution
 # License: GNU General Public License version 3, or any later version
 # See top-level LICENSE file for more information
 
 from typing import Dict, Iterable, List, Optional, Tuple, TypeVar, Union
 
 from typing_extensions import Protocol, runtime_checkable
 
 from swh.core.api import remote_api_endpoint
 from swh.core.api.classes import PagedResult as CorePagedResult
 from swh.indexer.storage.model import (
     ContentCtagsRow,
     ContentLanguageRow,
     ContentLicenseRow,
     ContentMetadataRow,
     ContentMimetypeRow,
     OriginIntrinsicMetadataRow,
     RevisionIntrinsicMetadataRow,
 )
 
 TResult = TypeVar("TResult")
 PagedResult = CorePagedResult[TResult, str]
 
 
 Sha1 = bytes
 
 
 @runtime_checkable
 class IndexerStorageInterface(Protocol):
     @remote_api_endpoint("check_config")
     def check_config(self, *, check_write):
         """Check that the storage is configured and ready to go."""
         ...
 
     @remote_api_endpoint("content_mimetype/missing")
     def content_mimetype_missing(
         self, mimetypes: Iterable[Dict]
     ) -> List[Tuple[Sha1, int]]:
         """Generate mimetypes missing from storage.
 
         Args:
             mimetypes (iterable): iterable of dict with keys:
 
               - **id** (bytes): sha1 identifier
               - **indexer_configuration_id** (int): tool used to compute the
                 results
 
         Returns:
             list of tuple (id, indexer_configuration_id) missing
 
         """
         ...
 
     @remote_api_endpoint("content_mimetype/range")
     def content_mimetype_get_partition(
         self,
         indexer_configuration_id: int,
         partition_id: int,
         nb_partitions: int,
         page_token: Optional[str] = None,
         limit: int = 1000,
     ) -> PagedResult[Sha1]:
         """Retrieve mimetypes within partition partition_id bound by limit.
 
         Args:
             **indexer_configuration_id**: The tool used to index data
             **partition_id**: index of the partition to fetch
             **nb_partitions**: total number of partitions to split into
             **page_token**: opaque token used for pagination
             **limit**: Limit result (default to 1000)
 
         Raises:
             IndexerStorageArgumentException for;
             - limit to None
             - wrong indexer_type provided
 
         Returns:
             PagedResult of Sha1. If next_page_token is None, there is no more data
             to fetch
 
         """
         ...
 
     @remote_api_endpoint("content_mimetype/add")
     def content_mimetype_add(
         self, mimetypes: List[ContentMimetypeRow], conflict_update: bool = False
     ) -> Dict[str, int]:
         """Add mimetypes not present in storage.
 
         Args:
             mimetypes: mimetype rows to be added, with their `tool` attribute set to
             None.
             conflict_update: Flag to determine if we want to
             overwrite (``True``) or skip duplicates (``False``, the
             default)
 
         Returns:
             Dict summary of number of rows added
 
         """
         ...
 
     @remote_api_endpoint("content_mimetype")
     def content_mimetype_get(self, ids: Iterable[Sha1]) -> List[ContentMimetypeRow]:
         """Retrieve full content mimetype per ids.
 
         Args:
             ids: sha1 identifiers
 
         Returns:
             mimetype row objects
 
         """
         ...
 
     @remote_api_endpoint("content_language/missing")
     def content_language_missing(
         self, languages: Iterable[Dict]
     ) -> List[Tuple[Sha1, int]]:
         """List languages missing from storage.
 
         Args:
             languages (iterable): dictionaries with keys:
 
                 - **id** (bytes): sha1 identifier
                 - **indexer_configuration_id** (int): tool used to compute
                   the results
 
         Returns:
             list of tuple (id, indexer_configuration_id) missing
 
         """
         ...
 
     @remote_api_endpoint("content_language")
     def content_language_get(self, ids: Iterable[Sha1]) -> List[ContentLanguageRow]:
         """Retrieve full content language per ids.
 
         Args:
             ids (iterable): sha1 identifier
 
         Returns:
             language row objects
 
         """
         ...
 
     @remote_api_endpoint("content_language/add")
     def content_language_add(
         self, languages: List[ContentLanguageRow], conflict_update: bool = False
     ) -> Dict[str, int]:
         """Add languages not present in storage.
 
         Args:
             languages: language row objects
 
             conflict_update (bool): Flag to determine if we want to
                 overwrite (true) or skip duplicates (false, the
                 default)
 
         Returns:
             Dict summary of number of rows added
 
         """
         ...
 
     @remote_api_endpoint("content/ctags/missing")
     def content_ctags_missing(self, ctags: Iterable[Dict]) -> List[Tuple[Sha1, int]]:
         """List ctags missing from storage.
 
         Args:
             ctags (iterable): dicts with keys:
 
                 - **id** (bytes): sha1 identifier
                 - **indexer_configuration_id** (int): tool used to compute
                   the results
 
         Returns:
             list of missing id for the tuple (id,
             indexer_configuration_id)
 
         """
         ...
 
     @remote_api_endpoint("content/ctags")
     def content_ctags_get(self, ids: Iterable[Sha1]) -> List[ContentCtagsRow]:
         """Retrieve ctags per id.
 
         Args:
             ids (iterable): sha1 checksums
 
         Returns:
             list of language rows
 
 
         """
         ...
 
     @remote_api_endpoint("content/ctags/add")
     def content_ctags_add(
         self, ctags: List[ContentCtagsRow], conflict_update: bool = False
     ) -> Dict[str, int]:
         """Add ctags not present in storage
 
         Args:
             ctags (iterable): dictionaries with keys:
 
                 - **id** (bytes): sha1
                 - **ctags** ([list): List of dictionary with keys: name, kind,
                   line, lang
 
         Returns:
             Dict summary of number of rows added
 
         """
         ...
 
     @remote_api_endpoint("content/ctags/search")
     def content_ctags_search(
         self, expression: str, limit: int = 10, last_sha1: Optional[Sha1] = None
     ) -> List[ContentCtagsRow]:
         """Search through content's raw ctags symbols.
 
         Args:
             expression (str): Expression to search for
             limit (int): Number of rows to return (default to 10).
             last_sha1 (str): Offset from which retrieving data (default to '').
 
         Returns:
             rows of ctags including id, name, lang, kind, line, etc...
 
         """
         ...
 
     @remote_api_endpoint("content/fossology_license")
     def content_fossology_license_get(
         self, ids: Iterable[Sha1]
     ) -> List[ContentLicenseRow]:
         """Retrieve licenses per id.
 
         Args:
             ids: sha1 identifiers
 
         Yields:
             license rows; possibly more than one per (sha1, tool_id) if there
             are multiple licenses.
 
         """
         ...
 
     @remote_api_endpoint("content/fossology_license/add")
     def content_fossology_license_add(
         self, licenses: List[ContentLicenseRow], conflict_update: bool = False
     ) -> Dict[str, int]:
         """Add licenses not present in storage.
 
         Args:
             license: license rows to be added, with their `tool` attribute set to
             None.
 
             conflict_update: Flag to determine if we want to overwrite (true)
                 or skip duplicates (false, the default)
 
         Returns:
             Dict summary of number of rows added
 
         """
         ...
 
     @remote_api_endpoint("content/fossology_license/range")
     def content_fossology_license_get_partition(
         self,
         indexer_configuration_id: int,
         partition_id: int,
         nb_partitions: int,
         page_token: Optional[str] = None,
         limit: int = 1000,
     ) -> PagedResult[Sha1]:
         """Retrieve licenses within the partition partition_id bound by limit.
 
         Args:
             **indexer_configuration_id**: The tool used to index data
             **partition_id**: index of the partition to fetch
             **nb_partitions**: total number of partitions to split into
             **page_token**: opaque token used for pagination
             **limit**: Limit result (default to 1000)
 
         Raises:
             IndexerStorageArgumentException for;
             - limit to None
             - wrong indexer_type provided
 
         Returns: PagedResult of Sha1. If next_page_token is None, there is no more data
             to fetch
 
         """
         ...
 
     @remote_api_endpoint("content_metadata/missing")
     def content_metadata_missing(
         self, metadata: Iterable[Dict]
     ) -> List[Tuple[Sha1, int]]:
         """List metadata missing from storage.
 
         Args:
             metadata (iterable): dictionaries with keys:
 
                 - **id** (bytes): sha1 identifier
                 - **indexer_configuration_id** (int): tool used to compute
                   the results
 
         Yields:
             missing sha1s
 
         """
         ...
 
     @remote_api_endpoint("content_metadata")
     def content_metadata_get(self, ids: Iterable[Sha1]) -> List[ContentMetadataRow]:
         """Retrieve metadata per id.
 
         Args:
             ids (iterable): sha1 checksums
 
         Yields:
             dictionaries with the following keys:
 
                 id (bytes)
                 metadata (str): associated metadata
                 tool (dict): tool used to compute metadata
 
         """
         ...
 
     @remote_api_endpoint("content_metadata/add")
     def content_metadata_add(
         self, metadata: List[ContentMetadataRow], conflict_update: bool = False
     ) -> Dict[str, int]:
         """Add metadata not present in storage.
 
         Args:
             metadata (iterable): dictionaries with keys:
 
                 - **id**: sha1
                 - **metadata**: arbitrary dict
 
             conflict_update: Flag to determine if we want to overwrite (true)
                 or skip duplicates (false, the default)
 
         Returns:
             Dict summary of number of rows added
 
         """
         ...
 
     @remote_api_endpoint("revision_intrinsic_metadata/missing")
     def revision_intrinsic_metadata_missing(
         self, metadata: Iterable[Dict]
     ) -> List[Tuple[Sha1, int]]:
         """List metadata missing from storage.
 
         Args:
             metadata (iterable): dictionaries with keys:
 
                - **id** (bytes): sha1_git revision identifier
                - **indexer_configuration_id** (int): tool used to compute
                  the results
 
         Returns:
             missing ids
 
         """
         ...
 
     @remote_api_endpoint("revision_intrinsic_metadata")
     def revision_intrinsic_metadata_get(
         self, ids: Iterable[Sha1]
     ) -> List[RevisionIntrinsicMetadataRow]:
         """Retrieve revision metadata per id.
 
         Args:
             ids (iterable): sha1 checksums
 
         Returns:
             ContentMetadataRow objects
 
         """
         ...
 
     @remote_api_endpoint("revision_intrinsic_metadata/add")
     def revision_intrinsic_metadata_add(
         self,
         metadata: List[RevisionIntrinsicMetadataRow],
         conflict_update: bool = False,
     ) -> Dict[str, int]:
         """Add metadata not present in storage.
 
         Args:
             metadata: ContentMetadataRow objects
 
             conflict_update: Flag to determine if we want to overwrite (true)
               or skip duplicates (false, the default)
 
         Returns:
             Dict summary of number of rows added
 
         """
         ...
 
-    @remote_api_endpoint("revision_intrinsic_metadata/delete")
-    def revision_intrinsic_metadata_delete(self, entries: List[Dict]) -> Dict:
-        """Remove revision metadata from the storage.
-
-        Args:
-            entries (dict): dictionaries with the following keys:
-
-                - **id** (bytes): revision identifier
-                - **indexer_configuration_id** (int): tool used to compute
-                  metadata
-
-        Returns:
-            Summary of number of rows deleted
-        """
-        ...
-
     @remote_api_endpoint("origin_intrinsic_metadata")
     def origin_intrinsic_metadata_get(
         self, urls: Iterable[str]
     ) -> List[OriginIntrinsicMetadataRow]:
         """Retrieve origin metadata per id.
 
         Args:
             urls (iterable): origin URLs
 
         Returns: list of OriginIntrinsicMetadataRow
         """
         ...
 
     @remote_api_endpoint("origin_intrinsic_metadata/add")
     def origin_intrinsic_metadata_add(
         self, metadata: List[OriginIntrinsicMetadataRow], conflict_update: bool = False
     ) -> Dict[str, int]:
         """Add origin metadata not present in storage.
 
         Args:
             metadata: list of OriginIntrinsicMetadataRow objects
 
             conflict_update: Flag to determine if we want to overwrite (true)
               or skip duplicates (false, the default)
 
         Returns:
             Dict summary of number of rows added
 
         """
         ...
 
-    @remote_api_endpoint("origin_intrinsic_metadata/delete")
-    def origin_intrinsic_metadata_delete(self, entries: List[Dict]) -> Dict:
-        """Remove origin metadata from the storage.
-
-        Args:
-            entries (dict): dictionaries with the following keys:
-
-                - **id** (str): origin urls
-                - **indexer_configuration_id** (int): tool used to compute
-                  metadata
-
-        Returns:
-            Summary of number of rows deleted
-        """
-        ...
-
     @remote_api_endpoint("origin_intrinsic_metadata/search/fulltext")
     def origin_intrinsic_metadata_search_fulltext(
         self, conjunction: List[str], limit: int = 100
     ) -> List[OriginIntrinsicMetadataRow]:
         """Returns the list of origins whose metadata contain all the terms.
 
         Args:
             conjunction: List of terms to be searched for.
             limit: The maximum number of results to return
 
         Returns:
             list of OriginIntrinsicMetadataRow
 
         """
         ...
 
     @remote_api_endpoint("origin_intrinsic_metadata/search/by_producer")
     def origin_intrinsic_metadata_search_by_producer(
         self,
         page_token: str = "",
         limit: int = 100,
         ids_only: bool = False,
         mappings: Optional[List[str]] = None,
         tool_ids: Optional[List[int]] = None,
     ) -> PagedResult[Union[str, OriginIntrinsicMetadataRow]]:
         """Returns the list of origins whose metadata contain all the terms.
 
         Args:
             page_token (str): Opaque token used for pagination.
             limit (int): The maximum number of results to return
             ids_only (bool): Determines whether only origin urls are
                 returned or the content as well
             mappings (List[str]): Returns origins whose intrinsic metadata
                 were generated using at least one of these mappings.
 
         Returns:
             OriginIntrinsicMetadataRow objects
 
         """
         ...
 
     @remote_api_endpoint("origin_intrinsic_metadata/stats")
     def origin_intrinsic_metadata_stats(self):
         """Returns counts of indexed metadata per origins, broken down
         into metadata types.
 
         Returns:
             dict: dictionary with keys:
 
                 - total (int): total number of origins that were indexed
                   (possibly yielding an empty metadata dictionary)
                 - non_empty (int): total number of origins that we extracted
                   a non-empty metadata dictionary from
                 - per_mapping (dict): a dictionary with mapping names as
                   keys and number of origins whose indexing used this
                   mapping. Note that indexing a given origin may use
                   0, 1, or many mappings.
         """
         ...
 
     @remote_api_endpoint("indexer_configuration/add")
     def indexer_configuration_add(self, tools):
         """Add new tools to the storage.
 
         Args:
             tools ([dict]): List of dictionary representing tool to
                 insert in the db. Dictionary with the following keys:
 
                 - **tool_name** (str): tool's name
                 - **tool_version** (str): tool's version
                 - **tool_configuration** (dict): tool's configuration
                   (free form dict)
 
         Returns:
             List of dict inserted in the db (holding the id key as
             well).  The order of the list is not guaranteed to match
             the order of the initial list.
 
         """
         ...
 
     @remote_api_endpoint("indexer_configuration/data")
     def indexer_configuration_get(self, tool):
         """Retrieve tool information.
 
         Args:
             tool (dict): Dictionary representing a tool with the
                 following keys:
 
                 - **tool_name** (str): tool's name
                 - **tool_version** (str): tool's version
                 - **tool_configuration** (dict): tool's configuration
                   (free form dict)
 
         Returns:
             The same dictionary with an `id` key, None otherwise.
 
         """
         ...
diff --git a/swh/indexer/tests/storage/test_storage.py b/swh/indexer/tests/storage/test_storage.py
index 36575fa..e1dbf6b 100644
--- a/swh/indexer/tests/storage/test_storage.py
+++ b/swh/indexer/tests/storage/test_storage.py
@@ -1,1891 +1,1798 @@
 # Copyright (C) 2015-2020  The Software Heritage developers
 # See the AUTHORS file at the top-level directory of this distribution
 # License: GNU General Public License version 3, or any later version
 # See top-level LICENSE file for more information
 
 import math
 import threading
-from typing import Any, Dict, List, Tuple, Type, cast
+from typing import Any, Dict, List, Tuple, Type
 
 import attr
 import pytest
 
 from swh.indexer.storage.exc import DuplicateId, IndexerStorageArgumentException
 from swh.indexer.storage.interface import IndexerStorageInterface, PagedResult
 from swh.indexer.storage.model import (
     BaseRow,
     ContentCtagsRow,
     ContentLanguageRow,
     ContentLicenseRow,
     ContentMetadataRow,
     ContentMimetypeRow,
     OriginIntrinsicMetadataRow,
     RevisionIntrinsicMetadataRow,
 )
 from swh.model.hashutil import hash_to_bytes
 
 
 def prepare_mimetypes_from_licenses(
     fossology_licenses: List[ContentLicenseRow],
 ) -> List[ContentMimetypeRow]:
     """Fossology license needs some consistent data in db to run.
 
     """
     mimetypes = []
     for c in fossology_licenses:
         mimetypes.append(
             ContentMimetypeRow(
                 id=c.id,
                 mimetype="text/plain",  # for filtering on textual data to work
                 encoding="utf-8",
                 indexer_configuration_id=c.indexer_configuration_id,
             )
         )
     return mimetypes
 
 
 def endpoint_name(etype: str, ename: str) -> str:
     """Compute the storage's endpoint's name
 
     >>> endpoint_name('content_mimetype', 'add')
     'content_mimetype_add'
     >>> endpoint_name('content_fosso_license', 'delete')
     'content_fosso_license_delete'
 
     """
     return f"{etype}_{ename}"
 
 
 def endpoint(storage, etype: str, ename: str):
     return getattr(storage, endpoint_name(etype, ename))
 
 
 def expected_summary(count: int, etype: str, ename: str = "add") -> Dict[str, int]:
     """Compute the expected summary
 
     The key is determine according to etype and ename
 
         >>> expected_summary(10, 'content_mimetype', 'add')
         {'content_mimetype:add': 10}
         >>> expected_summary(9, 'origin_intrinsic_metadata', 'delete')
         {'origin_intrinsic_metadata:del': 9}
 
     """
     pattern = ename[0:3]
     key = endpoint_name(etype, ename).replace(f"_{ename}", f":{pattern}")
     return {key: count}
 
 
 def test_check_config(swh_indexer_storage) -> None:
     assert swh_indexer_storage.check_config(check_write=True)
     assert swh_indexer_storage.check_config(check_write=False)
 
 
 class StorageETypeTester:
     """Base class for testing a series of common behaviour between a bunch of
     endpoint types supported by an IndexerStorage.
 
     This is supposed to be inherited with the following class attributes:
     - endpoint_type
     - tool_name
     - example_data
 
     See below for example usage.
     """
 
     endpoint_type: str
     tool_name: str
     example_data: List[Dict]
     row_class: Type[BaseRow]
 
     def test_missing(
         self, swh_indexer_storage_with_data: Tuple[IndexerStorageInterface, Any]
     ) -> None:
         storage, data = swh_indexer_storage_with_data
         etype = self.endpoint_type
         tool_id = data.tools[self.tool_name]["id"]
 
         # given 2 (hopefully) unknown objects
         query = [
             {"id": data.sha1_1, "indexer_configuration_id": tool_id,},
             {"id": data.sha1_2, "indexer_configuration_id": tool_id,},
         ]
 
         # we expect these are both returned by the xxx_missing endpoint
         actual_missing = endpoint(storage, etype, "missing")(query)
         assert list(actual_missing) == [
             data.sha1_1,
             data.sha1_2,
         ]
 
         # now, when we add one of them
         summary = endpoint(storage, etype, "add")(
             [
                 self.row_class.from_dict(
                     {
                         "id": data.sha1_2,
                         **self.example_data[0],
                         "indexer_configuration_id": tool_id,
                     }
                 )
             ]
         )
 
         assert summary == expected_summary(1, etype)
 
         # we expect only the other one returned
         actual_missing = endpoint(storage, etype, "missing")(query)
         assert list(actual_missing) == [data.sha1_1]
 
     def test_add__drop_duplicate(
         self, swh_indexer_storage_with_data: Tuple[IndexerStorageInterface, Any]
     ) -> None:
         storage, data = swh_indexer_storage_with_data
         etype = self.endpoint_type
         tool_id = data.tools[self.tool_name]["id"]
 
         # add the first object
         data_v1 = {
             "id": data.sha1_2,
             **self.example_data[0],
             "indexer_configuration_id": tool_id,
         }
         summary = endpoint(storage, etype, "add")([self.row_class.from_dict(data_v1)])
         assert summary == expected_summary(1, etype)
 
         # should be able to retrieve it
         actual_data = list(endpoint(storage, etype, "get")([data.sha1_2]))
         expected_data_v1 = [
             self.row_class.from_dict(
                 {
                     "id": data.sha1_2,
                     **self.example_data[0],
                     "tool": data.tools[self.tool_name],
                 }
             )
         ]
         assert actual_data == expected_data_v1
 
         # now if we add a modified version of the same object (same id)
         data_v2 = data_v1.copy()
         data_v2.update(self.example_data[1])
         summary2 = endpoint(storage, etype, "add")([self.row_class.from_dict(data_v2)])
         assert summary2 == expected_summary(0, etype)  # not added
 
         # we expect to retrieve the original data, not the modified one
         actual_data = list(endpoint(storage, etype, "get")([data.sha1_2]))
         assert actual_data == expected_data_v1
 
     def test_add__update_in_place_duplicate(
         self, swh_indexer_storage_with_data: Tuple[IndexerStorageInterface, Any]
     ) -> None:
         storage, data = swh_indexer_storage_with_data
         etype = self.endpoint_type
         tool = data.tools[self.tool_name]
 
         data_v1 = {
             "id": data.sha1_2,
             **self.example_data[0],
             "indexer_configuration_id": tool["id"],
         }
 
         # given
         summary = endpoint(storage, etype, "add")([self.row_class.from_dict(data_v1)])
         assert summary == expected_summary(1, etype)  # not added
 
         # when
         actual_data = list(endpoint(storage, etype, "get")([data.sha1_2]))
 
         expected_data_v1 = [
             self.row_class.from_dict(
                 {"id": data.sha1_2, **self.example_data[0], "tool": tool}
             )
         ]
 
         # then
         assert actual_data == expected_data_v1
 
         # given
         data_v2 = data_v1.copy()
         data_v2.update(self.example_data[1])
 
         endpoint(storage, etype, "add")(
             [self.row_class.from_dict(data_v2)], conflict_update=True
         )
         assert summary == expected_summary(1, etype)  # modified so counted
 
         actual_data = list(endpoint(storage, etype, "get")([data.sha1_2]))
 
         expected_data_v2 = [
             self.row_class.from_dict(
                 {"id": data.sha1_2, **self.example_data[1], "tool": tool,}
             )
         ]
 
         # data did change as the v2 was used to overwrite v1
         assert actual_data == expected_data_v2
 
     def test_add__update_in_place_deadlock(
         self, swh_indexer_storage_with_data: Tuple[IndexerStorageInterface, Any]
     ) -> None:
         storage, data = swh_indexer_storage_with_data
         etype = self.endpoint_type
         tool = data.tools[self.tool_name]
 
         hashes = [
             hash_to_bytes("34973274ccef6ab4dfaaf86599792fa9c3fe4{:03d}".format(i))
             for i in range(1000)
         ]
 
         data_v1 = [
             self.row_class.from_dict(
                 {
                     "id": hash_,
                     **self.example_data[0],
                     "indexer_configuration_id": tool["id"],
                 }
             )
             for hash_ in hashes
         ]
         data_v2 = [
             self.row_class.from_dict(
                 {
                     "id": hash_,
                     **self.example_data[1],
                     "indexer_configuration_id": tool["id"],
                 }
             )
             for hash_ in hashes
         ]
 
         # Remove one item from each, so that both queries have to succeed for
         # all items to be in the DB.
         data_v2a = data_v2[1:]
         data_v2b = list(reversed(data_v2[0:-1]))
 
         # given
         endpoint(storage, etype, "add")(data_v1)
 
         # when
         actual_data = list(endpoint(storage, etype, "get")(hashes))
 
         expected_data_v1 = [
             self.row_class.from_dict(
                 {"id": hash_, **self.example_data[0], "tool": tool}
             )
             for hash_ in hashes
         ]
 
         # then
         assert actual_data == expected_data_v1
 
         # given
         def f1() -> None:
             endpoint(storage, etype, "add")(data_v2a, conflict_update=True)
 
         def f2() -> None:
             endpoint(storage, etype, "add")(data_v2b, conflict_update=True)
 
         t1 = threading.Thread(target=f1)
         t2 = threading.Thread(target=f2)
         t2.start()
         t1.start()
 
         t1.join()
         t2.join()
 
         actual_data = sorted(
             (row.to_dict() for row in endpoint(storage, etype, "get")(hashes)),
             key=lambda x: x["id"],
         )
 
         expected_data_v2 = [
             {"id": hash_, **self.example_data[1], "tool": tool} for hash_ in hashes
         ]
 
         assert actual_data == expected_data_v2
 
     def test_add__duplicate_twice(
         self, swh_indexer_storage_with_data: Tuple[IndexerStorageInterface, Any]
     ) -> None:
         storage, data = swh_indexer_storage_with_data
         etype = self.endpoint_type
         tool = data.tools[self.tool_name]
 
         data_rev1 = self.row_class.from_dict(
             {
                 "id": data.revision_id_2,
                 **self.example_data[0],
                 "indexer_configuration_id": tool["id"],
             }
         )
 
         data_rev2 = self.row_class.from_dict(
             {
                 "id": data.revision_id_2,
                 **self.example_data[1],
                 "indexer_configuration_id": tool["id"],
             }
         )
 
         # when
         summary = endpoint(storage, etype, "add")([data_rev1])
         assert summary == expected_summary(1, etype)
 
         with pytest.raises(DuplicateId):
             endpoint(storage, etype, "add")(
                 [data_rev2, data_rev2], conflict_update=True
             )
 
         # then
         actual_data = list(
             endpoint(storage, etype, "get")([data.revision_id_2, data.revision_id_1])
         )
 
         expected_data = [
             self.row_class.from_dict(
                 {"id": data.revision_id_2, **self.example_data[0], "tool": tool}
             )
         ]
         assert actual_data == expected_data
 
     def test_get(
         self, swh_indexer_storage_with_data: Tuple[IndexerStorageInterface, Any]
     ) -> None:
         storage, data = swh_indexer_storage_with_data
         etype = self.endpoint_type
         tool = data.tools[self.tool_name]
 
         query = [data.sha1_2, data.sha1_1]
         data1 = self.row_class.from_dict(
             {
                 "id": data.sha1_2,
                 **self.example_data[0],
                 "indexer_configuration_id": tool["id"],
             }
         )
 
         # when
         summary = endpoint(storage, etype, "add")([data1])
         assert summary == expected_summary(1, etype)
 
         # then
         actual_data = list(endpoint(storage, etype, "get")(query))
 
         # then
         expected_data = [
             self.row_class.from_dict(
                 {"id": data.sha1_2, **self.example_data[0], "tool": tool}
             )
         ]
 
         assert actual_data == expected_data
 
 
 class TestIndexerStorageContentMimetypes(StorageETypeTester):
     """Test Indexer Storage content_mimetype related methods
     """
 
     endpoint_type = "content_mimetype"
     tool_name = "file"
     example_data = [
         {"mimetype": "text/plain", "encoding": "utf-8",},
         {"mimetype": "text/html", "encoding": "us-ascii",},
     ]
     row_class = ContentMimetypeRow
 
     def test_generate_content_mimetype_get_partition_failure(
         self, swh_indexer_storage: IndexerStorageInterface
     ) -> None:
         """get_partition call with wrong limit input should fail"""
         storage = swh_indexer_storage
         indexer_configuration_id = 42
         with pytest.raises(
             IndexerStorageArgumentException, match="limit should not be None"
         ):
             storage.content_mimetype_get_partition(
                 indexer_configuration_id, 0, 3, limit=None  # type: ignore
             )
 
     def test_generate_content_mimetype_get_partition_no_limit(
         self, swh_indexer_storage_with_data: Tuple[IndexerStorageInterface, Any]
     ) -> None:
         """get_partition should return result"""
         storage, data = swh_indexer_storage_with_data
         mimetypes = data.mimetypes
 
         expected_ids = set([c.id for c in mimetypes])
         indexer_configuration_id = mimetypes[0].indexer_configuration_id
 
         assert len(mimetypes) == 16
         nb_partitions = 16
 
         actual_ids = []
         for partition_id in range(nb_partitions):
             actual_result = storage.content_mimetype_get_partition(
                 indexer_configuration_id, partition_id, nb_partitions
             )
             assert actual_result.next_page_token is None
             actual_ids.extend(actual_result.results)
 
         assert len(actual_ids) == len(expected_ids)
         for actual_id in actual_ids:
             assert actual_id in expected_ids
 
     def test_generate_content_mimetype_get_partition_full(
         self, swh_indexer_storage_with_data: Tuple[IndexerStorageInterface, Any]
     ) -> None:
         """get_partition for a single partition should return available ids
 
         """
         storage, data = swh_indexer_storage_with_data
         mimetypes = data.mimetypes
         expected_ids = set([c.id for c in mimetypes])
         indexer_configuration_id = mimetypes[0].indexer_configuration_id
 
         actual_result = storage.content_mimetype_get_partition(
             indexer_configuration_id, 0, 1
         )
         assert actual_result.next_page_token is None
         actual_ids = actual_result.results
         assert len(actual_ids) == len(expected_ids)
         for actual_id in actual_ids:
             assert actual_id in expected_ids
 
     def test_generate_content_mimetype_get_partition_empty(
         self, swh_indexer_storage_with_data: Tuple[IndexerStorageInterface, Any]
     ) -> None:
         """get_partition when at least one of the partitions is empty"""
         storage, data = swh_indexer_storage_with_data
         mimetypes = data.mimetypes
         expected_ids = set([c.id for c in mimetypes])
         indexer_configuration_id = mimetypes[0].indexer_configuration_id
 
         # nb_partitions = smallest power of 2 such that at least one of
         # the partitions is empty
         nb_mimetypes = len(mimetypes)
         nb_partitions = 1 << math.floor(math.log2(nb_mimetypes) + 1)
 
         seen_ids = []
 
         for partition_id in range(nb_partitions):
             actual_result = storage.content_mimetype_get_partition(
                 indexer_configuration_id,
                 partition_id,
                 nb_partitions,
                 limit=nb_mimetypes + 1,
             )
 
             for actual_id in actual_result.results:
                 seen_ids.append(actual_id)
 
             # Limit is higher than the max number of results
             assert actual_result.next_page_token is None
 
         assert set(seen_ids) == expected_ids
 
     def test_generate_content_mimetype_get_partition_with_pagination(
         self, swh_indexer_storage_with_data: Tuple[IndexerStorageInterface, Any]
     ) -> None:
         """get_partition should return ids provided with pagination
 
         """
         storage, data = swh_indexer_storage_with_data
         mimetypes = data.mimetypes
         expected_ids = set([c.id for c in mimetypes])
         indexer_configuration_id = mimetypes[0].indexer_configuration_id
 
         nb_partitions = 4
 
         actual_ids = []
         for partition_id in range(nb_partitions):
             next_page_token = None
             while True:
                 actual_result = storage.content_mimetype_get_partition(
                     indexer_configuration_id,
                     partition_id,
                     nb_partitions,
                     limit=2,
                     page_token=next_page_token,
                 )
                 actual_ids.extend(actual_result.results)
                 next_page_token = actual_result.next_page_token
                 if next_page_token is None:
                     break
 
         assert len(set(actual_ids)) == len(set(expected_ids))
         for actual_id in actual_ids:
             assert actual_id in expected_ids
 
 
 class TestIndexerStorageContentLanguage(StorageETypeTester):
     """Test Indexer Storage content_language related methods
     """
 
     endpoint_type = "content_language"
     tool_name = "pygments"
     example_data = [
         {"lang": "haskell",},
         {"lang": "common-lisp",},
     ]
     row_class = ContentLanguageRow
 
 
 class TestIndexerStorageContentCTags(StorageETypeTester):
     """Test Indexer Storage content_ctags related methods
     """
 
     endpoint_type = "content_ctags"
     tool_name = "universal-ctags"
     example_data = [
         {"name": "done", "kind": "variable", "line": 119, "lang": "OCaml",},
         {"name": "done", "kind": "variable", "line": 100, "lang": "Python",},
         {"name": "main", "kind": "function", "line": 119, "lang": "Python",},
     ]
     row_class = ContentCtagsRow
 
     # the following tests are disabled because CTAGS behaves differently
     @pytest.mark.skip
     def test_add__drop_duplicate(self):
         pass
 
     @pytest.mark.skip
     def test_add__update_in_place_duplicate(self):
         pass
 
     @pytest.mark.skip
     def test_add__update_in_place_deadlock(self):
         pass
 
     @pytest.mark.skip
     def test_add__duplicate_twice(self):
         pass
 
     @pytest.mark.skip
     def test_get(self):
         pass
 
     def test_content_ctags_search(
         self, swh_indexer_storage_with_data: Tuple[IndexerStorageInterface, Any]
     ) -> None:
         storage, data = swh_indexer_storage_with_data
         # 1. given
         tool = data.tools["universal-ctags"]
         tool_id = tool["id"]
 
         ctags1 = [
             ContentCtagsRow(
                 id=data.sha1_1,
                 indexer_configuration_id=tool_id,
                 **kwargs,  # type: ignore
             )
             for kwargs in [
                 {"name": "hello", "kind": "function", "line": 133, "lang": "Python",},
                 {"name": "counter", "kind": "variable", "line": 119, "lang": "Python",},
                 {"name": "hello", "kind": "variable", "line": 210, "lang": "Python",},
             ]
         ]
         ctags1_with_tool = [
             attr.evolve(ctag, indexer_configuration_id=None, tool=tool)
             for ctag in ctags1
         ]
 
         ctags2 = [
             ContentCtagsRow(
                 id=data.sha1_2,
                 indexer_configuration_id=tool_id,
                 **kwargs,  # type: ignore
             )
             for kwargs in [
                 {"name": "hello", "kind": "variable", "line": 100, "lang": "C",},
                 {"name": "result", "kind": "variable", "line": 120, "lang": "C",},
             ]
         ]
         ctags2_with_tool = [
             attr.evolve(ctag, indexer_configuration_id=None, tool=tool)
             for ctag in ctags2
         ]
 
         storage.content_ctags_add(ctags1 + ctags2)
 
         # 1. when
         actual_ctags = list(storage.content_ctags_search("hello", limit=1))
 
         # 1. then
         assert actual_ctags == [ctags1_with_tool[0]]
 
         # 2. when
         actual_ctags = list(
             storage.content_ctags_search("hello", limit=1, last_sha1=data.sha1_1)
         )
 
         # 2. then
         assert actual_ctags == [ctags2_with_tool[0]]
 
         # 3. when
         actual_ctags = list(storage.content_ctags_search("hello"))
 
         # 3. then
         assert actual_ctags == [
             ctags1_with_tool[0],
             ctags1_with_tool[2],
             ctags2_with_tool[0],
         ]
 
         # 4. when
         actual_ctags = list(storage.content_ctags_search("counter"))
 
         # then
         assert actual_ctags == [ctags1_with_tool[1]]
 
         # 5. when
         actual_ctags = list(storage.content_ctags_search("result", limit=1))
 
         # then
         assert actual_ctags == [ctags2_with_tool[1]]
 
     def test_content_ctags_search_no_result(
         self, swh_indexer_storage: IndexerStorageInterface
     ) -> None:
         storage = swh_indexer_storage
         actual_ctags = list(storage.content_ctags_search("counter"))
 
         assert not actual_ctags
 
     def test_content_ctags_add__add_new_ctags_added(
         self, swh_indexer_storage_with_data: Tuple[IndexerStorageInterface, Any]
     ) -> None:
         storage, data = swh_indexer_storage_with_data
 
         # given
         tool = data.tools["universal-ctags"]
         tool_id = tool["id"]
 
         ctag1 = ContentCtagsRow(
             id=data.sha1_2,
             indexer_configuration_id=tool_id,
             name="done",
             kind="variable",
             line=100,
             lang="Scheme",
         )
         ctag1_with_tool = attr.evolve(ctag1, indexer_configuration_id=None, tool=tool)
 
         # given
         storage.content_ctags_add([ctag1])
         storage.content_ctags_add([ctag1])  # conflict does nothing
 
         # when
         actual_ctags = list(storage.content_ctags_get([data.sha1_2]))
 
         # then
         assert actual_ctags == [ctag1_with_tool]
 
         # given
         ctag2 = ContentCtagsRow(
             id=data.sha1_2,
             indexer_configuration_id=tool_id,
             name="defn",
             kind="function",
             line=120,
             lang="Scheme",
         )
         ctag2_with_tool = attr.evolve(ctag2, indexer_configuration_id=None, tool=tool)
 
         storage.content_ctags_add([ctag2])
 
         actual_ctags = list(storage.content_ctags_get([data.sha1_2]))
 
         assert actual_ctags == [ctag1_with_tool, ctag2_with_tool]
 
     def test_content_ctags_add__update_in_place(
         self, swh_indexer_storage_with_data: Tuple[IndexerStorageInterface, Any]
     ) -> None:
         storage, data = swh_indexer_storage_with_data
         # given
         tool = data.tools["universal-ctags"]
         tool_id = tool["id"]
 
         ctag1 = ContentCtagsRow(
             id=data.sha1_2,
             indexer_configuration_id=tool_id,
             name="done",
             kind="variable",
             line=100,
             lang="Scheme",
         )
         ctag1_with_tool = attr.evolve(ctag1, indexer_configuration_id=None, tool=tool)
 
         # given
         storage.content_ctags_add([ctag1])
 
         # when
         actual_ctags = list(storage.content_ctags_get([data.sha1_2]))
 
         # then
         assert actual_ctags == [ctag1_with_tool]
 
         # given
         ctag2 = ContentCtagsRow(
             id=data.sha1_2,
             indexer_configuration_id=tool_id,
             name="defn",
             kind="function",
             line=120,
             lang="Scheme",
         )
         ctag2_with_tool = attr.evolve(ctag2, indexer_configuration_id=None, tool=tool)
 
         storage.content_ctags_add([ctag1, ctag2], conflict_update=True)
 
         actual_ctags = list(storage.content_ctags_get([data.sha1_2]))
 
         assert actual_ctags == [ctag1_with_tool, ctag2_with_tool]
 
     def test_add_empty(
         self, swh_indexer_storage_with_data: Tuple[IndexerStorageInterface, Any]
     ) -> None:
         (storage, data) = swh_indexer_storage_with_data
         etype = self.endpoint_type
 
         summary = endpoint(storage, etype, "add")([])
         assert summary == {"content_ctags:add": 0}
 
         actual_ctags = list(endpoint(storage, etype, "get")([data.sha1_2]))
 
         assert actual_ctags == []
 
     def test_get_unknown(
         self, swh_indexer_storage_with_data: Tuple[IndexerStorageInterface, Any]
     ) -> None:
         (storage, data) = swh_indexer_storage_with_data
         etype = self.endpoint_type
 
         actual_ctags = list(endpoint(storage, etype, "get")([data.sha1_2]))
 
         assert actual_ctags == []
 
 
 class TestIndexerStorageContentMetadata(StorageETypeTester):
     """Test Indexer Storage content_metadata related methods
     """
 
     tool_name = "swh-metadata-detector"
     endpoint_type = "content_metadata"
     example_data = [
         {
             "metadata": {
                 "other": {},
                 "codeRepository": {
                     "type": "git",
                     "url": "https://github.com/moranegg/metadata_test",
                 },
                 "description": "Simple package.json test for indexer",
                 "name": "test_metadata",
                 "version": "0.0.1",
             },
         },
         {"metadata": {"other": {}, "name": "test_metadata", "version": "0.0.1"},},
     ]
     row_class = ContentMetadataRow
 
 
 class TestIndexerStorageRevisionIntrinsicMetadata(StorageETypeTester):
     """Test Indexer Storage revision_intrinsic_metadata related methods
     """
 
     tool_name = "swh-metadata-detector"
     endpoint_type = "revision_intrinsic_metadata"
     example_data = [
         {
             "metadata": {
                 "other": {},
                 "codeRepository": {
                     "type": "git",
                     "url": "https://github.com/moranegg/metadata_test",
                 },
                 "description": "Simple package.json test for indexer",
                 "name": "test_metadata",
                 "version": "0.0.1",
             },
             "mappings": ["mapping1"],
         },
         {
             "metadata": {"other": {}, "name": "test_metadata", "version": "0.0.1"},
             "mappings": ["mapping2"],
         },
     ]
     row_class = RevisionIntrinsicMetadataRow
 
-    def test_revision_intrinsic_metadata_delete(
-        self, swh_indexer_storage_with_data: Tuple[IndexerStorageInterface, Any]
-    ) -> None:
-        storage, data = swh_indexer_storage_with_data
-        etype = self.endpoint_type
-        tool = data.tools[self.tool_name]
-
-        query = [data.sha1_2, data.sha1_1]
-        data1 = RevisionIntrinsicMetadataRow(
-            id=data.sha1_2,
-            indexer_configuration_id=tool["id"],
-            **self.example_data[0],  # type: ignore
-        )
-
-        # when
-        summary = endpoint(storage, etype, "add")([data1])
-        assert summary == expected_summary(1, etype)
-
-        summary2 = endpoint(storage, etype, "delete")(
-            [{"id": data.sha1_2, "indexer_configuration_id": tool["id"],}]
-        )
-        assert summary2 == expected_summary(1, etype, "del")
-
-        # then
-        actual_data = list(endpoint(storage, etype, "get")(query))
-
-        # then
-        assert not actual_data
-
-    def test_revision_intrinsic_metadata_delete_nonexisting(
-        self, swh_indexer_storage_with_data: Tuple[IndexerStorageInterface, Any]
-    ) -> None:
-        storage, data = swh_indexer_storage_with_data
-        etype = self.endpoint_type
-        tool = data.tools[self.tool_name]
-        endpoint(storage, etype, "delete")(
-            [{"id": data.sha1_2, "indexer_configuration_id": tool["id"],}]
-        )
-
 
 class TestIndexerStorageContentFossologyLicense:
     endpoint_type = "content_fossology_license"
     tool_name = "nomos"
 
     row_class = ContentLicenseRow
 
     def test_content_fossology_license_add__new_license_added(
         self, swh_indexer_storage_with_data: Tuple[IndexerStorageInterface, Any]
     ) -> None:
         storage, data = swh_indexer_storage_with_data
         # given
         tool = data.tools["nomos"]
         tool_id = tool["id"]
 
         license1 = ContentLicenseRow(
             id=data.sha1_1, license="Apache-2.0", indexer_configuration_id=tool_id,
         )
 
         # given
         storage.content_fossology_license_add([license1])
         # conflict does nothing
         storage.content_fossology_license_add([license1])
 
         # when
         actual_licenses = list(storage.content_fossology_license_get([data.sha1_1]))
 
         # then
         expected_licenses = [
             ContentLicenseRow(id=data.sha1_1, license="Apache-2.0", tool=tool,)
         ]
         assert actual_licenses == expected_licenses
 
         # given
         license2 = ContentLicenseRow(
             id=data.sha1_1, license="BSD-2-Clause", indexer_configuration_id=tool_id,
         )
 
         storage.content_fossology_license_add([license2])
 
         actual_licenses = list(storage.content_fossology_license_get([data.sha1_1]))
 
         expected_licenses.append(
             ContentLicenseRow(id=data.sha1_1, license="BSD-2-Clause", tool=tool,)
         )
 
         # first license was not removed when the second one was added
         assert sorted(actual_licenses) == sorted(expected_licenses)
 
     def test_generate_content_fossology_license_get_partition_failure(
         self, swh_indexer_storage_with_data: Tuple[IndexerStorageInterface, Any]
     ) -> None:
         """get_partition call with wrong limit input should fail"""
         storage, data = swh_indexer_storage_with_data
         indexer_configuration_id = 42
         with pytest.raises(
             IndexerStorageArgumentException, match="limit should not be None"
         ):
             storage.content_fossology_license_get_partition(
                 indexer_configuration_id, 0, 3, limit=None,  # type: ignore
             )
 
     def test_generate_content_fossology_license_get_partition_no_limit(
         self, swh_indexer_storage_with_data: Tuple[IndexerStorageInterface, Any]
     ) -> None:
         """get_partition should return results"""
         storage, data = swh_indexer_storage_with_data
         # craft some consistent mimetypes
         fossology_licenses = data.fossology_licenses
         mimetypes = prepare_mimetypes_from_licenses(fossology_licenses)
         indexer_configuration_id = fossology_licenses[0].indexer_configuration_id
 
         storage.content_mimetype_add(mimetypes, conflict_update=True)
         # add fossology_licenses to storage
         storage.content_fossology_license_add(fossology_licenses)
 
         # All ids from the db
         expected_ids = set([c.id for c in fossology_licenses])
 
         assert len(fossology_licenses) == 10
         assert len(mimetypes) == 10
         nb_partitions = 4
 
         actual_ids = []
         for partition_id in range(nb_partitions):
 
             actual_result = storage.content_fossology_license_get_partition(
                 indexer_configuration_id, partition_id, nb_partitions
             )
             assert actual_result.next_page_token is None
             actual_ids.extend(actual_result.results)
 
         assert len(set(actual_ids)) == len(expected_ids)
         for actual_id in actual_ids:
             assert actual_id in expected_ids
 
     def test_generate_content_fossology_license_get_partition_full(
         self, swh_indexer_storage_with_data: Tuple[IndexerStorageInterface, Any]
     ) -> None:
         """get_partition for a single partition should return available ids
 
         """
         storage, data = swh_indexer_storage_with_data
         # craft some consistent mimetypes
         fossology_licenses = data.fossology_licenses
         mimetypes = prepare_mimetypes_from_licenses(fossology_licenses)
         indexer_configuration_id = fossology_licenses[0].indexer_configuration_id
 
         storage.content_mimetype_add(mimetypes, conflict_update=True)
         # add fossology_licenses to storage
         storage.content_fossology_license_add(fossology_licenses)
 
         # All ids from the db
         expected_ids = set([c.id for c in fossology_licenses])
 
         actual_result = storage.content_fossology_license_get_partition(
             indexer_configuration_id, 0, 1
         )
         assert actual_result.next_page_token is None
         actual_ids = actual_result.results
         assert len(set(actual_ids)) == len(expected_ids)
         for actual_id in actual_ids:
             assert actual_id in expected_ids
 
     def test_generate_content_fossology_license_get_partition_empty(
         self, swh_indexer_storage_with_data: Tuple[IndexerStorageInterface, Any]
     ) -> None:
         """get_partition when at least one of the partitions is empty"""
         storage, data = swh_indexer_storage_with_data
         # craft some consistent mimetypes
         fossology_licenses = data.fossology_licenses
         mimetypes = prepare_mimetypes_from_licenses(fossology_licenses)
         indexer_configuration_id = fossology_licenses[0].indexer_configuration_id
 
         storage.content_mimetype_add(mimetypes, conflict_update=True)
         # add fossology_licenses to storage
         storage.content_fossology_license_add(fossology_licenses)
 
         # All ids from the db
         expected_ids = set([c.id for c in fossology_licenses])
 
         # nb_partitions = smallest power of 2 such that at least one of
         # the partitions is empty
         nb_licenses = len(fossology_licenses)
         nb_partitions = 1 << math.floor(math.log2(nb_licenses) + 1)
 
         seen_ids = []
 
         for partition_id in range(nb_partitions):
             actual_result = storage.content_fossology_license_get_partition(
                 indexer_configuration_id,
                 partition_id,
                 nb_partitions,
                 limit=nb_licenses + 1,
             )
 
             for actual_id in actual_result.results:
                 seen_ids.append(actual_id)
 
             # Limit is higher than the max number of results
             assert actual_result.next_page_token is None
 
         assert set(seen_ids) == expected_ids
 
     def test_generate_content_fossology_license_get_partition_with_pagination(
         self, swh_indexer_storage_with_data: Tuple[IndexerStorageInterface, Any]
     ) -> None:
         """get_partition should return ids provided with paginationv
 
         """
         storage, data = swh_indexer_storage_with_data
         # craft some consistent mimetypes
         fossology_licenses = data.fossology_licenses
         mimetypes = prepare_mimetypes_from_licenses(fossology_licenses)
         indexer_configuration_id = fossology_licenses[0].indexer_configuration_id
 
         storage.content_mimetype_add(mimetypes, conflict_update=True)
         # add fossology_licenses to storage
         storage.content_fossology_license_add(fossology_licenses)
 
         # All ids from the db
         expected_ids = [c.id for c in fossology_licenses]
 
         nb_partitions = 4
 
         actual_ids = []
         for partition_id in range(nb_partitions):
             next_page_token = None
             while True:
                 actual_result = storage.content_fossology_license_get_partition(
                     indexer_configuration_id,
                     partition_id,
                     nb_partitions,
                     limit=2,
                     page_token=next_page_token,
                 )
                 actual_ids.extend(actual_result.results)
                 next_page_token = actual_result.next_page_token
                 if next_page_token is None:
                     break
 
         assert len(set(actual_ids)) == len(set(expected_ids))
         for actual_id in actual_ids:
             assert actual_id in expected_ids
 
     def test_add_empty(
         self, swh_indexer_storage_with_data: Tuple[IndexerStorageInterface, Any]
     ) -> None:
         (storage, data) = swh_indexer_storage_with_data
         etype = self.endpoint_type
 
         summary = endpoint(storage, etype, "add")([])
         assert summary == {"content_fossology_license:add": 0}
 
         actual_license = list(endpoint(storage, etype, "get")([data.sha1_2]))
 
         assert actual_license == []
 
     def test_get_unknown(
         self, swh_indexer_storage_with_data: Tuple[IndexerStorageInterface, Any]
     ) -> None:
         (storage, data) = swh_indexer_storage_with_data
         etype = self.endpoint_type
 
         actual_license = list(endpoint(storage, etype, "get")([data.sha1_2]))
 
         assert actual_license == []
 
 
 class TestIndexerStorageOriginIntrinsicMetadata:
     def test_origin_intrinsic_metadata_get(
         self, swh_indexer_storage_with_data: Tuple[IndexerStorageInterface, Any]
     ) -> None:
         storage, data = swh_indexer_storage_with_data
         # given
         tool_id = data.tools["swh-metadata-detector"]["id"]
 
         metadata = {
             "version": None,
             "name": None,
         }
         metadata_rev = RevisionIntrinsicMetadataRow(
             id=data.revision_id_2,
             metadata=metadata,
             mappings=["mapping1"],
             indexer_configuration_id=tool_id,
         )
         metadata_origin = OriginIntrinsicMetadataRow(
             id=data.origin_url_1,
             metadata=metadata,
             indexer_configuration_id=tool_id,
             mappings=["mapping1"],
             from_revision=data.revision_id_2,
         )
 
         # when
         storage.revision_intrinsic_metadata_add([metadata_rev])
         storage.origin_intrinsic_metadata_add([metadata_origin])
 
         # then
         actual_metadata = list(
             storage.origin_intrinsic_metadata_get([data.origin_url_1, "no://where"])
         )
 
         expected_metadata = [
             OriginIntrinsicMetadataRow(
                 id=data.origin_url_1,
                 metadata=metadata,
                 tool=data.tools["swh-metadata-detector"],
                 from_revision=data.revision_id_2,
                 mappings=["mapping1"],
             )
         ]
 
         assert actual_metadata == expected_metadata
 
-    def test_origin_intrinsic_metadata_delete(
-        self, swh_indexer_storage_with_data: Tuple[IndexerStorageInterface, Any]
-    ) -> None:
-        storage, data = swh_indexer_storage_with_data
-        # given
-        tool_id = data.tools["swh-metadata-detector"]["id"]
-
-        metadata = {
-            "version": None,
-            "name": None,
-        }
-        metadata_rev = RevisionIntrinsicMetadataRow(
-            id=data.revision_id_2,
-            indexer_configuration_id=tool_id,
-            metadata=metadata,
-            mappings=["mapping1"],
-        )
-        metadata_origin = OriginIntrinsicMetadataRow(
-            id=data.origin_url_1,
-            metadata=metadata,
-            indexer_configuration_id=tool_id,
-            mappings=["mapping1"],
-            from_revision=data.revision_id_2,
-        )
-        metadata_origin2 = attr.evolve(metadata_origin, id=data.origin_url_2)
-
-        # when
-        storage.revision_intrinsic_metadata_add([metadata_rev])
-        storage.origin_intrinsic_metadata_add([metadata_origin, metadata_origin2])
-
-        storage.origin_intrinsic_metadata_delete(
-            [{"id": data.origin_url_1, "indexer_configuration_id": tool_id}]
-        )
-
-        # then
-        actual_metadata = list(
-            storage.origin_intrinsic_metadata_get(
-                [data.origin_url_1, data.origin_url_2, "no://where"]
-            )
-        )
-        assert [
-            attr.evolve(m, indexer_configuration_id=cast(Dict, m.tool)["id"], tool=None)
-            for m in actual_metadata
-        ] == [metadata_origin2]
-
-    def test_origin_intrinsic_metadata_delete_nonexisting(
-        self, swh_indexer_storage_with_data: Tuple[IndexerStorageInterface, Any]
-    ) -> None:
-        storage, data = swh_indexer_storage_with_data
-        tool_id = data.tools["swh-metadata-detector"]["id"]
-        storage.origin_intrinsic_metadata_delete(
-            [{"id": data.origin_url_1, "indexer_configuration_id": tool_id}]
-        )
-
     def test_origin_intrinsic_metadata_add_drop_duplicate(
         self, swh_indexer_storage_with_data: Tuple[IndexerStorageInterface, Any]
     ) -> None:
         storage, data = swh_indexer_storage_with_data
         # given
         tool_id = data.tools["swh-metadata-detector"]["id"]
 
         metadata_v1: Dict[str, Any] = {
             "version": None,
             "name": None,
         }
         metadata_rev_v1 = RevisionIntrinsicMetadataRow(
             id=data.revision_id_1,
             metadata=metadata_v1.copy(),
             mappings=[],
             indexer_configuration_id=tool_id,
         )
         metadata_origin_v1 = OriginIntrinsicMetadataRow(
             id=data.origin_url_1,
             metadata=metadata_v1.copy(),
             indexer_configuration_id=tool_id,
             mappings=[],
             from_revision=data.revision_id_1,
         )
 
         # given
         storage.revision_intrinsic_metadata_add([metadata_rev_v1])
         storage.origin_intrinsic_metadata_add([metadata_origin_v1])
 
         # when
         actual_metadata = list(
             storage.origin_intrinsic_metadata_get([data.origin_url_1, "no://where"])
         )
 
         expected_metadata_v1 = [
             OriginIntrinsicMetadataRow(
                 id=data.origin_url_1,
                 metadata=metadata_v1,
                 tool=data.tools["swh-metadata-detector"],
                 from_revision=data.revision_id_1,
                 mappings=[],
             )
         ]
 
         assert actual_metadata == expected_metadata_v1
 
         # given
         metadata_v2 = metadata_v1.copy()
         metadata_v2.update(
             {"name": "test_metadata", "author": "MG",}
         )
         metadata_rev_v2 = attr.evolve(metadata_rev_v1, metadata=metadata_v2)
         metadata_origin_v2 = attr.evolve(metadata_origin_v1, metadata=metadata_v2)
 
         storage.revision_intrinsic_metadata_add([metadata_rev_v2])
         storage.origin_intrinsic_metadata_add([metadata_origin_v2])
 
         # then
         actual_metadata = list(
             storage.origin_intrinsic_metadata_get([data.origin_url_1])
         )
 
         # metadata did not change as the v2 was dropped.
         assert actual_metadata == expected_metadata_v1
 
     def test_origin_intrinsic_metadata_add_update_in_place_duplicate(
         self, swh_indexer_storage_with_data: Tuple[IndexerStorageInterface, Any]
     ) -> None:
         storage, data = swh_indexer_storage_with_data
         # given
         tool_id = data.tools["swh-metadata-detector"]["id"]
 
         metadata_v1: Dict[str, Any] = {
             "version": None,
             "name": None,
         }
         metadata_rev_v1 = RevisionIntrinsicMetadataRow(
             id=data.revision_id_2,
             metadata=metadata_v1,
             mappings=[],
             indexer_configuration_id=tool_id,
         )
         metadata_origin_v1 = OriginIntrinsicMetadataRow(
             id=data.origin_url_1,
             metadata=metadata_v1.copy(),
             indexer_configuration_id=tool_id,
             mappings=[],
             from_revision=data.revision_id_2,
         )
 
         # given
         storage.revision_intrinsic_metadata_add([metadata_rev_v1])
         storage.origin_intrinsic_metadata_add([metadata_origin_v1])
 
         # when
         actual_metadata = list(
             storage.origin_intrinsic_metadata_get([data.origin_url_1])
         )
 
         # then
         expected_metadata_v1 = [
             OriginIntrinsicMetadataRow(
                 id=data.origin_url_1,
                 metadata=metadata_v1,
                 tool=data.tools["swh-metadata-detector"],
                 from_revision=data.revision_id_2,
                 mappings=[],
             )
         ]
         assert actual_metadata == expected_metadata_v1
 
         # given
         metadata_v2 = metadata_v1.copy()
         metadata_v2.update(
             {"name": "test_update_duplicated_metadata", "author": "MG",}
         )
         metadata_rev_v2 = attr.evolve(metadata_rev_v1, metadata=metadata_v2)
         metadata_origin_v2 = OriginIntrinsicMetadataRow(
             id=data.origin_url_1,
             metadata=metadata_v2.copy(),
             indexer_configuration_id=tool_id,
             mappings=["npm"],
             from_revision=data.revision_id_1,
         )
 
         storage.revision_intrinsic_metadata_add([metadata_rev_v2], conflict_update=True)
         storage.origin_intrinsic_metadata_add(
             [metadata_origin_v2], conflict_update=True
         )
 
         actual_metadata = list(
             storage.origin_intrinsic_metadata_get([data.origin_url_1])
         )
 
         expected_metadata_v2 = [
             OriginIntrinsicMetadataRow(
                 id=data.origin_url_1,
                 metadata=metadata_v2,
                 tool=data.tools["swh-metadata-detector"],
                 from_revision=data.revision_id_1,
                 mappings=["npm"],
             )
         ]
 
         # metadata did change as the v2 was used to overwrite v1
         assert actual_metadata == expected_metadata_v2
 
     def test_origin_intrinsic_metadata_add__update_in_place_deadlock(
         self, swh_indexer_storage_with_data: Tuple[IndexerStorageInterface, Any]
     ) -> None:
         storage, data = swh_indexer_storage_with_data
         # given
         tool_id = data.tools["swh-metadata-detector"]["id"]
 
         ids = list(range(10))
 
         example_data1: Dict[str, Any] = {
             "metadata": {"version": None, "name": None,},
             "mappings": [],
         }
         example_data2: Dict[str, Any] = {
             "metadata": {"version": "v1.1.1", "name": "foo",},
             "mappings": [],
         }
 
         metadata_rev_v1 = RevisionIntrinsicMetadataRow(
             id=data.revision_id_2,
             metadata={"version": None, "name": None,},
             mappings=[],
             indexer_configuration_id=tool_id,
         )
 
         data_v1 = [
             OriginIntrinsicMetadataRow(
                 id="file:///tmp/origin%d" % id_,
                 from_revision=data.revision_id_2,
                 indexer_configuration_id=tool_id,
                 **example_data1,
             )
             for id_ in ids
         ]
         data_v2 = [
             OriginIntrinsicMetadataRow(
                 id="file:///tmp/origin%d" % id_,
                 from_revision=data.revision_id_2,
                 indexer_configuration_id=tool_id,
                 **example_data2,
             )
             for id_ in ids
         ]
 
         # Remove one item from each, so that both queries have to succeed for
         # all items to be in the DB.
         data_v2a = data_v2[1:]
         data_v2b = list(reversed(data_v2[0:-1]))
 
         # given
         storage.revision_intrinsic_metadata_add([metadata_rev_v1])
         storage.origin_intrinsic_metadata_add(data_v1)
 
         # when
         origins = ["file:///tmp/origin%d" % i for i in ids]
         actual_data = list(storage.origin_intrinsic_metadata_get(origins))
 
         expected_data_v1 = [
             OriginIntrinsicMetadataRow(
                 id="file:///tmp/origin%d" % id_,
                 from_revision=data.revision_id_2,
                 tool=data.tools["swh-metadata-detector"],
                 **example_data1,
             )
             for id_ in ids
         ]
 
         # then
         assert actual_data == expected_data_v1
 
         # given
         def f1() -> None:
             storage.origin_intrinsic_metadata_add(data_v2a, conflict_update=True)
 
         def f2() -> None:
             storage.origin_intrinsic_metadata_add(data_v2b, conflict_update=True)
 
         t1 = threading.Thread(target=f1)
         t2 = threading.Thread(target=f2)
         t2.start()
         t1.start()
 
         t1.join()
         t2.join()
 
         actual_data = list(storage.origin_intrinsic_metadata_get(origins))
 
         expected_data_v2 = [
             OriginIntrinsicMetadataRow(
                 id="file:///tmp/origin%d" % id_,
                 from_revision=data.revision_id_2,
                 tool=data.tools["swh-metadata-detector"],
                 **example_data2,
             )
             for id_ in ids
         ]
 
         assert len(actual_data) == len(expected_data_v2)
         assert sorted(actual_data, key=lambda x: x.id) == expected_data_v2
 
     def test_origin_intrinsic_metadata_add__duplicate_twice(
         self, swh_indexer_storage_with_data: Tuple[IndexerStorageInterface, Any]
     ) -> None:
         storage, data = swh_indexer_storage_with_data
         # given
         tool_id = data.tools["swh-metadata-detector"]["id"]
 
         metadata = {
             "developmentStatus": None,
             "name": None,
         }
         metadata_rev = RevisionIntrinsicMetadataRow(
             id=data.revision_id_2,
             metadata=metadata,
             mappings=["mapping1"],
             indexer_configuration_id=tool_id,
         )
         metadata_origin = OriginIntrinsicMetadataRow(
             id=data.origin_url_1,
             metadata=metadata,
             indexer_configuration_id=tool_id,
             mappings=["mapping1"],
             from_revision=data.revision_id_2,
         )
 
         # when
         storage.revision_intrinsic_metadata_add([metadata_rev])
 
         with pytest.raises(DuplicateId):
             storage.origin_intrinsic_metadata_add([metadata_origin, metadata_origin])
 
     def test_origin_intrinsic_metadata_search_fulltext(
         self, swh_indexer_storage_with_data: Tuple[IndexerStorageInterface, Any]
     ) -> None:
         storage, data = swh_indexer_storage_with_data
         # given
         tool_id = data.tools["swh-metadata-detector"]["id"]
 
         metadata1 = {
             "author": "John Doe",
         }
         metadata1_rev = RevisionIntrinsicMetadataRow(
             id=data.revision_id_1,
             metadata=metadata1,
             mappings=[],
             indexer_configuration_id=tool_id,
         )
         metadata1_origin = OriginIntrinsicMetadataRow(
             id=data.origin_url_1,
             metadata=metadata1,
             mappings=[],
             indexer_configuration_id=tool_id,
             from_revision=data.revision_id_1,
         )
         metadata2 = {
             "author": "Jane Doe",
         }
         metadata2_rev = RevisionIntrinsicMetadataRow(
             id=data.revision_id_2,
             metadata=metadata2,
             mappings=[],
             indexer_configuration_id=tool_id,
         )
         metadata2_origin = OriginIntrinsicMetadataRow(
             id=data.origin_url_2,
             metadata=metadata2,
             mappings=[],
             indexer_configuration_id=tool_id,
             from_revision=data.revision_id_2,
         )
 
         # when
         storage.revision_intrinsic_metadata_add([metadata1_rev])
         storage.origin_intrinsic_metadata_add([metadata1_origin])
         storage.revision_intrinsic_metadata_add([metadata2_rev])
         storage.origin_intrinsic_metadata_add([metadata2_origin])
 
         # then
         search = storage.origin_intrinsic_metadata_search_fulltext
         assert set([res.id for res in search(["Doe"])]) == set(
             [data.origin_url_1, data.origin_url_2]
         )
         assert [res.id for res in search(["John", "Doe"])] == [data.origin_url_1]
         assert [res.id for res in search(["John"])] == [data.origin_url_1]
         assert not list(search(["John", "Jane"]))
 
     def test_origin_intrinsic_metadata_search_fulltext_rank(
         self, swh_indexer_storage_with_data: Tuple[IndexerStorageInterface, Any]
     ) -> None:
         storage, data = swh_indexer_storage_with_data
         # given
         tool_id = data.tools["swh-metadata-detector"]["id"]
 
         # The following authors have "Random Person" to add some more content
         # to the JSON data, to work around normalization quirks when there
         # are few words (rank/(1+ln(nb_words)) is very sensitive to nb_words
         # for small values of nb_words).
         metadata1 = {"author": ["Random Person", "John Doe", "Jane Doe",]}
         metadata1_rev = RevisionIntrinsicMetadataRow(
             id=data.revision_id_1,
             metadata=metadata1,
             mappings=[],
             indexer_configuration_id=tool_id,
         )
         metadata1_origin = OriginIntrinsicMetadataRow(
             id=data.origin_url_1,
             metadata=metadata1,
             mappings=[],
             indexer_configuration_id=tool_id,
             from_revision=data.revision_id_1,
         )
         metadata2 = {"author": ["Random Person", "Jane Doe",]}
         metadata2_rev = RevisionIntrinsicMetadataRow(
             id=data.revision_id_2,
             metadata=metadata2,
             mappings=[],
             indexer_configuration_id=tool_id,
         )
         metadata2_origin = OriginIntrinsicMetadataRow(
             id=data.origin_url_2,
             metadata=metadata2,
             mappings=[],
             indexer_configuration_id=tool_id,
             from_revision=data.revision_id_2,
         )
 
         # when
         storage.revision_intrinsic_metadata_add([metadata1_rev])
         storage.origin_intrinsic_metadata_add([metadata1_origin])
         storage.revision_intrinsic_metadata_add([metadata2_rev])
         storage.origin_intrinsic_metadata_add([metadata2_origin])
 
         # then
         search = storage.origin_intrinsic_metadata_search_fulltext
         assert [res.id for res in search(["Doe"])] == [
             data.origin_url_1,
             data.origin_url_2,
         ]
         assert [res.id for res in search(["Doe"], limit=1)] == [data.origin_url_1]
         assert [res.id for res in search(["John"])] == [data.origin_url_1]
         assert [res.id for res in search(["Jane"])] == [
             data.origin_url_2,
             data.origin_url_1,
         ]
         assert [res.id for res in search(["John", "Jane"])] == [data.origin_url_1]
 
     def _fill_origin_intrinsic_metadata(
         self, swh_indexer_storage_with_data: Tuple[IndexerStorageInterface, Any]
     ) -> None:
         storage, data = swh_indexer_storage_with_data
         tool1_id = data.tools["swh-metadata-detector"]["id"]
         tool2_id = data.tools["swh-metadata-detector2"]["id"]
 
         metadata1 = {
             "@context": "foo",
             "author": "John Doe",
         }
         metadata1_rev = RevisionIntrinsicMetadataRow(
             id=data.revision_id_1,
             metadata=metadata1,
             mappings=["npm"],
             indexer_configuration_id=tool1_id,
         )
         metadata1_origin = OriginIntrinsicMetadataRow(
             id=data.origin_url_1,
             metadata=metadata1,
             mappings=["npm"],
             indexer_configuration_id=tool1_id,
             from_revision=data.revision_id_1,
         )
         metadata2 = {
             "@context": "foo",
             "author": "Jane Doe",
         }
         metadata2_rev = RevisionIntrinsicMetadataRow(
             id=data.revision_id_2,
             metadata=metadata2,
             mappings=["npm", "gemspec"],
             indexer_configuration_id=tool2_id,
         )
         metadata2_origin = OriginIntrinsicMetadataRow(
             id=data.origin_url_2,
             metadata=metadata2,
             mappings=["npm", "gemspec"],
             indexer_configuration_id=tool2_id,
             from_revision=data.revision_id_2,
         )
         metadata3 = {
             "@context": "foo",
         }
         metadata3_rev = RevisionIntrinsicMetadataRow(
             id=data.revision_id_3,
             metadata=metadata3,
             mappings=["npm", "gemspec"],
             indexer_configuration_id=tool2_id,
         )
         metadata3_origin = OriginIntrinsicMetadataRow(
             id=data.origin_url_3,
             metadata=metadata3,
             mappings=["pkg-info"],
             indexer_configuration_id=tool2_id,
             from_revision=data.revision_id_3,
         )
 
         storage.revision_intrinsic_metadata_add([metadata1_rev])
         storage.origin_intrinsic_metadata_add([metadata1_origin])
         storage.revision_intrinsic_metadata_add([metadata2_rev])
         storage.origin_intrinsic_metadata_add([metadata2_origin])
         storage.revision_intrinsic_metadata_add([metadata3_rev])
         storage.origin_intrinsic_metadata_add([metadata3_origin])
 
     def test_origin_intrinsic_metadata_search_by_producer(
         self, swh_indexer_storage_with_data: Tuple[IndexerStorageInterface, Any]
     ) -> None:
         storage, data = swh_indexer_storage_with_data
         self._fill_origin_intrinsic_metadata(swh_indexer_storage_with_data)
         tool1 = data.tools["swh-metadata-detector"]
         tool2 = data.tools["swh-metadata-detector2"]
         endpoint = storage.origin_intrinsic_metadata_search_by_producer
 
         # test pagination
         # no 'page_token' param, return all origins
         result = endpoint(ids_only=True)
         assert result == PagedResult(
             results=[data.origin_url_1, data.origin_url_2, data.origin_url_3,],
             next_page_token=None,
         )
 
         # 'page_token' is < than origin_1, return everything
         result = endpoint(page_token=data.origin_url_1[:-1], ids_only=True)
         assert result == PagedResult(
             results=[data.origin_url_1, data.origin_url_2, data.origin_url_3,],
             next_page_token=None,
         )
 
         # 'page_token' is origin_3, return nothing
         result = endpoint(page_token=data.origin_url_3, ids_only=True)
         assert result == PagedResult(results=[], next_page_token=None)
 
         # test limit argument
         result = endpoint(page_token=data.origin_url_1[:-1], limit=2, ids_only=True)
         assert result == PagedResult(
             results=[data.origin_url_1, data.origin_url_2],
             next_page_token=data.origin_url_2,
         )
 
         result = endpoint(page_token=data.origin_url_1, limit=2, ids_only=True)
         assert result == PagedResult(
             results=[data.origin_url_2, data.origin_url_3], next_page_token=None,
         )
 
         result = endpoint(page_token=data.origin_url_2, limit=2, ids_only=True)
         assert result == PagedResult(results=[data.origin_url_3], next_page_token=None,)
 
         # test mappings filtering
         result = endpoint(mappings=["npm"], ids_only=True)
         assert result == PagedResult(
             results=[data.origin_url_1, data.origin_url_2], next_page_token=None,
         )
 
         result = endpoint(mappings=["npm", "gemspec"], ids_only=True)
         assert result == PagedResult(
             results=[data.origin_url_1, data.origin_url_2], next_page_token=None,
         )
 
         result = endpoint(mappings=["gemspec"], ids_only=True)
         assert result == PagedResult(results=[data.origin_url_2], next_page_token=None,)
 
         result = endpoint(mappings=["pkg-info"], ids_only=True)
         assert result == PagedResult(results=[data.origin_url_3], next_page_token=None,)
 
         result = endpoint(mappings=["foobar"], ids_only=True)
         assert result == PagedResult(results=[], next_page_token=None,)
 
         # test pagination + mappings
         result = endpoint(mappings=["npm"], limit=1, ids_only=True)
         assert result == PagedResult(
             results=[data.origin_url_1], next_page_token=data.origin_url_1,
         )
 
         # test tool filtering
         result = endpoint(tool_ids=[tool1["id"]], ids_only=True)
         assert result == PagedResult(results=[data.origin_url_1], next_page_token=None,)
 
         result = endpoint(tool_ids=[tool2["id"]], ids_only=True)
         assert sorted(result.results) == [data.origin_url_2, data.origin_url_3]
         assert result.next_page_token is None
 
         result = endpoint(tool_ids=[tool1["id"], tool2["id"]], ids_only=True)
         assert sorted(result.results) == [
             data.origin_url_1,
             data.origin_url_2,
             data.origin_url_3,
         ]
         assert result.next_page_token is None
 
         # test ids_only=False
         assert endpoint(mappings=["gemspec"]) == PagedResult(
             results=[
                 OriginIntrinsicMetadataRow(
                     id=data.origin_url_2,
                     metadata={"@context": "foo", "author": "Jane Doe",},
                     mappings=["npm", "gemspec"],
                     tool=tool2,
                     from_revision=data.revision_id_2,
                 )
             ],
             next_page_token=None,
         )
 
     def test_origin_intrinsic_metadata_stats(
         self, swh_indexer_storage_with_data: Tuple[IndexerStorageInterface, Any]
     ) -> None:
         storage, data = swh_indexer_storage_with_data
         self._fill_origin_intrinsic_metadata(swh_indexer_storage_with_data)
 
         result = storage.origin_intrinsic_metadata_stats()
         assert result == {
             "per_mapping": {
                 "gemspec": 1,
                 "npm": 2,
                 "pkg-info": 1,
                 "codemeta": 0,
                 "maven": 0,
             },
             "total": 3,
             "non_empty": 2,
         }
 
 
 class TestIndexerStorageIndexerConfiguration:
     def test_indexer_configuration_add(
         self, swh_indexer_storage_with_data: Tuple[IndexerStorageInterface, Any]
     ) -> None:
         storage, data = swh_indexer_storage_with_data
         tool = {
             "tool_name": "some-unknown-tool",
             "tool_version": "some-version",
             "tool_configuration": {"debian-package": "some-package"},
         }
 
         actual_tool = storage.indexer_configuration_get(tool)
         assert actual_tool is None  # does not exist
 
         # add it
         actual_tools = list(storage.indexer_configuration_add([tool]))
 
         assert len(actual_tools) == 1
         actual_tool = actual_tools[0]
         assert actual_tool is not None  # now it exists
         new_id = actual_tool.pop("id")
         assert actual_tool == tool
 
         actual_tools2 = list(storage.indexer_configuration_add([tool]))
         actual_tool2 = actual_tools2[0]
         assert actual_tool2 is not None  # now it exists
         new_id2 = actual_tool2.pop("id")
 
         assert new_id == new_id2
         assert actual_tool == actual_tool2
 
     def test_indexer_configuration_add_multiple(
         self, swh_indexer_storage_with_data: Tuple[IndexerStorageInterface, Any]
     ) -> None:
         storage, data = swh_indexer_storage_with_data
         tool = {
             "tool_name": "some-unknown-tool",
             "tool_version": "some-version",
             "tool_configuration": {"debian-package": "some-package"},
         }
 
         actual_tools = list(storage.indexer_configuration_add([tool]))
         assert len(actual_tools) == 1
 
         new_tools = [
             tool,
             {
                 "tool_name": "yet-another-tool",
                 "tool_version": "version",
                 "tool_configuration": {},
             },
         ]
 
         actual_tools = list(storage.indexer_configuration_add(new_tools))
         assert len(actual_tools) == 2
 
         # order not guaranteed, so we iterate over results to check
         for tool in actual_tools:
             _id = tool.pop("id")
             assert _id is not None
             assert tool in new_tools
 
     def test_indexer_configuration_get_missing(
         self, swh_indexer_storage_with_data: Tuple[IndexerStorageInterface, Any]
     ) -> None:
         storage, data = swh_indexer_storage_with_data
         tool = {
             "tool_name": "unknown-tool",
             "tool_version": "3.1.0rc2-31-ga2cbb8c",
             "tool_configuration": {"command_line": "nomossa <filepath>"},
         }
 
         actual_tool = storage.indexer_configuration_get(tool)
 
         assert actual_tool is None
 
     def test_indexer_configuration_get(
         self, swh_indexer_storage_with_data: Tuple[IndexerStorageInterface, Any]
     ) -> None:
         storage, data = swh_indexer_storage_with_data
         tool = {
             "tool_name": "nomos",
             "tool_version": "3.1.0rc2-31-ga2cbb8c",
             "tool_configuration": {"command_line": "nomossa <filepath>"},
         }
 
         actual_tool = storage.indexer_configuration_get(tool)
         assert actual_tool
 
         expected_tool = tool.copy()
         del actual_tool["id"]
 
         assert expected_tool == actual_tool
 
     def test_indexer_configuration_metadata_get_missing_context(
         self, swh_indexer_storage_with_data: Tuple[IndexerStorageInterface, Any]
     ) -> None:
         storage, data = swh_indexer_storage_with_data
         tool = {
             "tool_name": "swh-metadata-translator",
             "tool_version": "0.0.1",
             "tool_configuration": {"context": "unknown-context"},
         }
 
         actual_tool = storage.indexer_configuration_get(tool)
 
         assert actual_tool is None
 
     def test_indexer_configuration_metadata_get(
         self, swh_indexer_storage_with_data: Tuple[IndexerStorageInterface, Any]
     ) -> None:
         storage, data = swh_indexer_storage_with_data
         tool = {
             "tool_name": "swh-metadata-translator",
             "tool_version": "0.0.1",
             "tool_configuration": {"type": "local", "context": "NpmMapping"},
         }
 
         storage.indexer_configuration_add([tool])
         actual_tool = storage.indexer_configuration_get(tool)
         assert actual_tool
 
         expected_tool = tool.copy()
         expected_tool["id"] = actual_tool["id"]
 
         assert expected_tool == actual_tool
diff --git a/swh/indexer/tests/test_origin_metadata.py b/swh/indexer/tests/test_origin_metadata.py
index 65e8af2..63ce2aa 100644
--- a/swh/indexer/tests/test_origin_metadata.py
+++ b/swh/indexer/tests/test_origin_metadata.py
@@ -1,246 +1,220 @@
 # Copyright (C) 2018-2020  The Software Heritage developers
 # See the AUTHORS file at the top-level directory of this distribution
 # License: GNU General Public License version 3, or any later version
 # See top-level LICENSE file for more information
 
 from unittest.mock import patch
 
 from swh.indexer.metadata import OriginMetadataIndexer
 from swh.indexer.storage.interface import IndexerStorageInterface
 from swh.indexer.storage.model import (
     OriginIntrinsicMetadataRow,
     RevisionIntrinsicMetadataRow,
 )
 from swh.model.model import Origin
 from swh.storage.interface import StorageInterface
 
 from .test_metadata import REVISION_METADATA_CONFIG
 from .utils import REVISION, YARN_PARSER_METADATA
 
 
 def test_origin_metadata_indexer(
     idx_storage: IndexerStorageInterface, storage: StorageInterface, obj_storage
 ) -> None:
 
     indexer = OriginMetadataIndexer(config=REVISION_METADATA_CONFIG)
     origin = "https://github.com/librariesio/yarn-parser"
     indexer.run([origin])
 
     tool = {
         "name": "swh-metadata-translator",
         "version": "0.0.2",
         "configuration": {"context": "NpmMapping", "type": "local"},
     }
 
     rev_id = REVISION.id
     rev_metadata = RevisionIntrinsicMetadataRow(
         id=rev_id, tool=tool, metadata=YARN_PARSER_METADATA, mappings=["npm"],
     )
     origin_metadata = OriginIntrinsicMetadataRow(
         id=origin,
         tool=tool,
         from_revision=rev_id,
         metadata=YARN_PARSER_METADATA,
         mappings=["npm"],
     )
 
     rev_results = list(indexer.idx_storage.revision_intrinsic_metadata_get([rev_id]))
     for rev_result in rev_results:
         assert rev_result.tool
         del rev_result.tool["id"]
     assert rev_results == [rev_metadata]
 
     orig_results = list(indexer.idx_storage.origin_intrinsic_metadata_get([origin]))
     for orig_result in orig_results:
         assert orig_result.tool
         del orig_result.tool["id"]
     assert orig_results == [origin_metadata]
 
 
 def test_origin_metadata_indexer_duplicate_origin(
     idx_storage: IndexerStorageInterface, storage: StorageInterface, obj_storage
 ) -> None:
     indexer = OriginMetadataIndexer(config=REVISION_METADATA_CONFIG)
     indexer.storage = storage
     indexer.idx_storage = idx_storage
     indexer.run(["https://github.com/librariesio/yarn-parser"])
     indexer.run(["https://github.com/librariesio/yarn-parser"] * 2)
 
     origin = "https://github.com/librariesio/yarn-parser"
     rev_id = REVISION.id
 
     rev_results = list(indexer.idx_storage.revision_intrinsic_metadata_get([rev_id]))
     assert len(rev_results) == 1
 
     orig_results = list(indexer.idx_storage.origin_intrinsic_metadata_get([origin]))
     assert len(orig_results) == 1
 
 
 def test_origin_metadata_indexer_missing_head(
     idx_storage: IndexerStorageInterface, storage: StorageInterface, obj_storage
 ) -> None:
     storage.origin_add([Origin(url="https://example.com")])
 
     indexer = OriginMetadataIndexer(config=REVISION_METADATA_CONFIG)
     indexer.run(["https://example.com"])
 
     origin = "https://example.com"
 
     results = list(indexer.idx_storage.origin_intrinsic_metadata_get([origin]))
     assert results == []
 
 
 def test_origin_metadata_indexer_partial_missing_head(
     idx_storage: IndexerStorageInterface, storage: StorageInterface, obj_storage
 ) -> None:
 
     origin1 = "https://example.com"
     origin2 = "https://github.com/librariesio/yarn-parser"
     storage.origin_add([Origin(url=origin1)])
     indexer = OriginMetadataIndexer(config=REVISION_METADATA_CONFIG)
     indexer.run([origin1, origin2])
 
     rev_id = REVISION.id
 
     rev_results = list(indexer.idx_storage.revision_intrinsic_metadata_get([rev_id]))
     assert rev_results == [
         RevisionIntrinsicMetadataRow(
             id=rev_id,
             metadata=YARN_PARSER_METADATA,
             mappings=["npm"],
             tool=rev_results[0].tool,
         )
     ]
 
     orig_results = list(
         indexer.idx_storage.origin_intrinsic_metadata_get([origin1, origin2])
     )
     for orig_result in orig_results:
         assert orig_results == [
             OriginIntrinsicMetadataRow(
                 id=origin2,
                 from_revision=rev_id,
                 metadata=YARN_PARSER_METADATA,
                 mappings=["npm"],
                 tool=orig_results[0].tool,
             )
         ]
 
 
 def test_origin_metadata_indexer_duplicate_revision(
     idx_storage: IndexerStorageInterface, storage: StorageInterface, obj_storage
 ) -> None:
     indexer = OriginMetadataIndexer(config=REVISION_METADATA_CONFIG)
     indexer.storage = storage
     indexer.idx_storage = idx_storage
     indexer.catch_exceptions = False
     origin1 = "https://github.com/librariesio/yarn-parser"
     origin2 = "https://github.com/librariesio/yarn-parser.git"
     indexer.run([origin1, origin2])
 
     rev_id = REVISION.id
 
     rev_results = list(indexer.idx_storage.revision_intrinsic_metadata_get([rev_id]))
     assert len(rev_results) == 1
 
     orig_results = list(
         indexer.idx_storage.origin_intrinsic_metadata_get([origin1, origin2])
     )
     assert len(orig_results) == 2
 
 
 def test_origin_metadata_indexer_no_metadata_file(
     idx_storage: IndexerStorageInterface, storage: StorageInterface, obj_storage
 ) -> None:
 
     indexer = OriginMetadataIndexer(config=REVISION_METADATA_CONFIG)
     origin = "https://github.com/librariesio/yarn-parser"
     with patch("swh.indexer.metadata_dictionary.npm.NpmMapping.filename", b"foo.json"):
         indexer.run([origin])
 
     rev_id = REVISION.id
 
     rev_results = list(indexer.idx_storage.revision_intrinsic_metadata_get([rev_id]))
     assert rev_results == []
 
     orig_results = list(indexer.idx_storage.origin_intrinsic_metadata_get([origin]))
     assert orig_results == []
 
 
 def test_origin_metadata_indexer_no_metadata(
     idx_storage: IndexerStorageInterface, storage: StorageInterface, obj_storage
 ) -> None:
 
     indexer = OriginMetadataIndexer(config=REVISION_METADATA_CONFIG)
     origin = "https://github.com/librariesio/yarn-parser"
     with patch(
         "swh.indexer.metadata.RevisionMetadataIndexer"
         ".translate_revision_intrinsic_metadata",
         return_value=(["npm"], {"@context": "foo"}),
     ):
         indexer.run([origin])
 
     rev_id = REVISION.id
 
     rev_results = list(indexer.idx_storage.revision_intrinsic_metadata_get([rev_id]))
     assert rev_results == []
 
     orig_results = list(indexer.idx_storage.origin_intrinsic_metadata_get([origin]))
     assert orig_results == []
 
 
 def test_origin_metadata_indexer_error(
     idx_storage: IndexerStorageInterface, storage: StorageInterface, obj_storage
 ) -> None:
 
     indexer = OriginMetadataIndexer(config=REVISION_METADATA_CONFIG)
     origin = "https://github.com/librariesio/yarn-parser"
     with patch(
         "swh.indexer.metadata.RevisionMetadataIndexer"
         ".translate_revision_intrinsic_metadata",
         return_value=None,
     ):
         indexer.run([origin])
 
     rev_id = REVISION.id
 
     rev_results = list(indexer.idx_storage.revision_intrinsic_metadata_get([rev_id]))
     assert rev_results == []
 
     orig_results = list(indexer.idx_storage.origin_intrinsic_metadata_get([origin]))
     assert orig_results == []
 
 
-def test_origin_metadata_indexer_delete_metadata(
-    idx_storage: IndexerStorageInterface, storage: StorageInterface, obj_storage
-) -> None:
-
-    indexer = OriginMetadataIndexer(config=REVISION_METADATA_CONFIG)
-    origin = "https://github.com/librariesio/yarn-parser"
-    indexer.run([origin])
-
-    rev_id = REVISION.id
-
-    rev_results = list(indexer.idx_storage.revision_intrinsic_metadata_get([rev_id]))
-    assert rev_results != []
-
-    orig_results = list(indexer.idx_storage.origin_intrinsic_metadata_get([origin]))
-    assert orig_results != []
-
-    with patch("swh.indexer.metadata_dictionary.npm.NpmMapping.filename", b"foo.json"):
-        indexer.run([origin])
-
-    rev_results = list(indexer.idx_storage.revision_intrinsic_metadata_get([rev_id]))
-    assert rev_results == []
-
-    orig_results = list(indexer.idx_storage.origin_intrinsic_metadata_get([origin]))
-    assert orig_results == []
-
-
 def test_origin_metadata_indexer_unknown_origin(
     idx_storage: IndexerStorageInterface, storage: StorageInterface, obj_storage
 ) -> None:
 
     indexer = OriginMetadataIndexer(config=REVISION_METADATA_CONFIG)
     result = indexer.index_list(["https://unknown.org/foo"])
     assert not result