diff --git a/sql/swh-func.sql b/sql/swh-func.sql
index 6cd78e1..c4096f6 100644
--- a/sql/swh-func.sql
+++ b/sql/swh-func.sql
@@ -1,391 +1,381 @@
 -- Postgresql index helper function
 create or replace function hash_sha1(text)
     returns text
     language sql strict immutable
 as $$
     select encode(public.digest($1, 'sha1'), 'hex')
 $$;
 
 comment on function hash_sha1(text) is 'Compute sha1 hash as text';
 
--- create a temporary table with a single "bytea" column for fast object lookup.
-create or replace function swh_mktemp_bytea()
-    returns void
-    language sql
-as $$
-    create temporary table tmp_bytea (
-      id bytea
-    ) on commit drop;
-$$;
-
 -- create a temporary table called tmp_TBLNAME, mimicking existing table
 -- TBLNAME
 --
 -- Args:
 --     tblname: name of the table to mimick
 create or replace function swh_mktemp(tblname regclass)
     returns void
     language plpgsql
 as $$
 begin
     execute format('
 	create temporary table tmp_%1$I
 	    (like %1$I including defaults)
 	    on commit drop;
       alter table tmp_%1$I drop column if exists object_id;
 	', tblname);
     return;
 end
 $$;
 
 -- create a temporary table for content_mimetype tmp_content_mimetype,
 create or replace function swh_mktemp_content_mimetype()
     returns void
     language sql
 as $$
   create temporary table tmp_content_mimetype (
     like content_mimetype including defaults
   ) on commit drop;
 $$;
 
 comment on function swh_mktemp_content_mimetype() IS 'Helper table to add mimetype information';
 
 -- add tmp_content_mimetype entries to content_mimetype, overwriting
 -- duplicates if conflict_update is true, skipping duplicates otherwise.
 --
 -- If filtering duplicates is in order, the call to
 -- swh_content_mimetype_missing must take place before calling this
 -- function.
 --
 --
 -- operates in bulk: 0. swh_mktemp(content_mimetype), 1. COPY to tmp_content_mimetype,
 -- 2. call this function
 create or replace function swh_content_mimetype_add(conflict_update boolean)
     returns void
     language plpgsql
 as $$
 begin
     if conflict_update then
         insert into content_mimetype (id, mimetype, encoding, indexer_configuration_id)
         select id, mimetype, encoding, indexer_configuration_id
         from tmp_content_mimetype tcm
             on conflict(id, indexer_configuration_id)
                 do update set mimetype = excluded.mimetype,
                               encoding = excluded.encoding;
 
     else
         insert into content_mimetype (id, mimetype, encoding, indexer_configuration_id)
         select id, mimetype, encoding, indexer_configuration_id
         from tmp_content_mimetype tcm
             on conflict(id, indexer_configuration_id) do nothing;
     end if;
     return;
 end
 $$;
 
 comment on function swh_content_mimetype_add(boolean) IS 'Add new content mimetypes';
 
 -- add tmp_content_language entries to content_language, overwriting
 -- duplicates if conflict_update is true, skipping duplicates otherwise.
 --
 -- If filtering duplicates is in order, the call to
 -- swh_content_language_missing must take place before calling this
 -- function.
 --
 -- operates in bulk: 0. swh_mktemp(content_language), 1. COPY to
 -- tmp_content_language, 2. call this function
 create or replace function swh_content_language_add(conflict_update boolean)
     returns void
     language plpgsql
 as $$
 begin
     if conflict_update then
       insert into content_language (id, lang, indexer_configuration_id)
       select id, lang, indexer_configuration_id
     	from tmp_content_language tcl
             on conflict(id, indexer_configuration_id)
                 do update set lang = excluded.lang;
 
     else
         insert into content_language (id, lang, indexer_configuration_id)
         select id, lang, indexer_configuration_id
     	  from tmp_content_language tcl
             on conflict(id, indexer_configuration_id)
             do nothing;
     end if;
     return;
 end
 $$;
 
 comment on function swh_content_language_add(boolean) IS 'Add new content languages';
 
 -- create a temporary table for retrieving content_language
 create or replace function swh_mktemp_content_language()
     returns void
     language sql
 as $$
   create temporary table tmp_content_language (
     like content_language including defaults
   ) on commit drop;
 $$;
 
 comment on function swh_mktemp_content_language() is 'Helper table to add content language';
 
 
 -- create a temporary table for content_ctags tmp_content_ctags,
 create or replace function swh_mktemp_content_ctags()
     returns void
     language sql
 as $$
   create temporary table tmp_content_ctags (
     like content_ctags including defaults
   ) on commit drop;
 $$;
 
 comment on function swh_mktemp_content_ctags() is 'Helper table to add content ctags';
 
 
 -- add tmp_content_ctags entries to content_ctags, overwriting
 -- duplicates if conflict_update is true, skipping duplicates otherwise.
 --
 -- operates in bulk: 0. swh_mktemp(content_ctags), 1. COPY to tmp_content_ctags,
 -- 2. call this function
 create or replace function swh_content_ctags_add(conflict_update boolean)
     returns void
     language plpgsql
 as $$
 begin
     if conflict_update then
         delete from content_ctags
         where id in (select tmp.id
                      from tmp_content_ctags tmp
                      inner join indexer_configuration i on i.id=tmp.indexer_configuration_id);
     end if;
 
     insert into content_ctags (id, name, kind, line, lang, indexer_configuration_id)
     select id, name, kind, line, lang, indexer_configuration_id
     from tmp_content_ctags tct
         on conflict(id, hash_sha1(name), kind, line, lang, indexer_configuration_id)
         do nothing;
     return;
 end
 $$;
 
 comment on function swh_content_ctags_add(boolean) IS 'Add new ctags symbols per content';
 
 create type content_ctags_signature as (
   id sha1,
   name text,
   kind text,
   line bigint,
   lang ctags_languages,
   tool_id integer,
   tool_name text,
   tool_version text,
   tool_configuration jsonb
 );
 
 -- Search within ctags content.
 --
 create or replace function swh_content_ctags_search(
        expression text,
        l integer default 10,
        last_sha1 sha1 default '\x0000000000000000000000000000000000000000')
     returns setof content_ctags_signature
     language sql
 as $$
     select c.id, name, kind, line, lang,
            i.id as tool_id, tool_name, tool_version, tool_configuration
     from content_ctags c
     inner join indexer_configuration i on i.id = c.indexer_configuration_id
     where hash_sha1(name) = hash_sha1(expression)
     and c.id > last_sha1
     order by id
     limit l;
 $$;
 
 comment on function swh_content_ctags_search(text, integer, sha1) IS 'Equality search through ctags'' symbols';
 
 
 -- create a temporary table for content_fossology_license tmp_content_fossology_license,
 create or replace function swh_mktemp_content_fossology_license()
     returns void
     language sql
 as $$
   create temporary table tmp_content_fossology_license (
     id                       sha1,
     license                  text,
     indexer_configuration_id integer
   ) on commit drop;
 $$;
 
 comment on function swh_mktemp_content_fossology_license() is 'Helper table to add content license';
 
 -- add tmp_content_fossology_license entries to content_fossology_license, overwriting
 -- duplicates if conflict_update is true, skipping duplicates otherwise.
 --
 -- operates in bulk: 0. swh_mktemp(content_fossology_license), 1. COPY to
 -- tmp_content_fossology_license, 2. call this function
 create or replace function swh_content_fossology_license_add(conflict_update boolean)
     returns void
     language plpgsql
 as $$
 begin
     -- insert unknown licenses first
     insert into fossology_license (name)
     select distinct license from tmp_content_fossology_license tmp
     where not exists (select 1 from fossology_license where name=tmp.license)
     on conflict(name) do nothing;
 
     if conflict_update then
         -- delete from content_fossology_license c
         --   using tmp_content_fossology_license tmp, indexer_configuration i
         --   where c.id = tmp.id and i.id=tmp.indexer_configuration_id
         delete from content_fossology_license
         where id in (select tmp.id
                      from tmp_content_fossology_license tmp
                      inner join indexer_configuration i on i.id=tmp.indexer_configuration_id);
     end if;
 
     insert into content_fossology_license (id, license_id, indexer_configuration_id)
     select tcl.id,
           (select id from fossology_license where name = tcl.license) as license,
           indexer_configuration_id
     from tmp_content_fossology_license tcl
         on conflict(id, license_id, indexer_configuration_id)
         do nothing;
     return;
 end
 $$;
 
 comment on function swh_content_fossology_license_add(boolean) IS 'Add new content licenses';
 
 -- content_metadata functions
 
 -- add tmp_content_metadata entries to content_metadata, overwriting
 -- duplicates if conflict_update is true, skipping duplicates otherwise.
 --
 -- If filtering duplicates is in order, the call to
 -- swh_content_metadata_missing must take place before calling this
 -- function.
 --
 -- operates in bulk: 0. swh_mktemp(content_language), 1. COPY to
 -- tmp_content_metadata, 2. call this function
 create or replace function swh_content_metadata_add(conflict_update boolean)
     returns void
     language plpgsql
 as $$
 begin
     if conflict_update then
       insert into content_metadata (id, translated_metadata, indexer_configuration_id)
       select id, translated_metadata, indexer_configuration_id
     	from tmp_content_metadata tcm
             on conflict(id, indexer_configuration_id)
                 do update set translated_metadata = excluded.translated_metadata;
 
     else
         insert into content_metadata (id, translated_metadata, indexer_configuration_id)
         select id, translated_metadata, indexer_configuration_id
     	from tmp_content_metadata tcm
             on conflict(id, indexer_configuration_id)
             do nothing;
     end if;
     return;
 end
 $$;
 
 comment on function swh_content_metadata_add(boolean) IS 'Add new content metadata';
 
 -- create a temporary table for retrieving content_metadata
 create or replace function swh_mktemp_content_metadata()
     returns void
     language sql
 as $$
   create temporary table tmp_content_metadata (
     like content_metadata including defaults
   ) on commit drop;
 $$;
 
 comment on function swh_mktemp_content_metadata() is 'Helper table to add content metadata';
 
 -- end content_metadata functions
 
 -- add tmp_revision_metadata entries to revision_metadata, overwriting
 -- duplicates if conflict_update is true, skipping duplicates otherwise.
 --
 -- If filtering duplicates is in order, the call to
 -- swh_revision_metadata_missing must take place before calling this
 -- function.
 --
 -- operates in bulk: 0. swh_mktemp(content_language), 1. COPY to
 -- tmp_revision_metadata, 2. call this function
 create or replace function swh_revision_metadata_add(conflict_update boolean)
     returns void
     language plpgsql
 as $$
 begin
     if conflict_update then
       insert into revision_metadata (id, translated_metadata, indexer_configuration_id)
       select id, translated_metadata, indexer_configuration_id
     	from tmp_revision_metadata tcm
             on conflict(id, indexer_configuration_id)
                 do update set translated_metadata = excluded.translated_metadata;
 
     else
         insert into revision_metadata (id, translated_metadata, indexer_configuration_id)
         select id, translated_metadata, indexer_configuration_id
     	from tmp_revision_metadata tcm
             on conflict(id, indexer_configuration_id)
             do nothing;
     end if;
     return;
 end
 $$;
 
 comment on function swh_revision_metadata_add(boolean) IS 'Add new revision metadata';
 
 -- create a temporary table for retrieving revision_metadata
 create or replace function swh_mktemp_revision_metadata()
     returns void
     language sql
 as $$
   create temporary table tmp_revision_metadata (
     like revision_metadata including defaults
   ) on commit drop;
 $$;
 
 comment on function swh_mktemp_revision_metadata() is 'Helper table to add revision metadata';
 
 create or replace function swh_mktemp_indexer_configuration()
     returns void
     language sql
 as $$
     create temporary table tmp_indexer_configuration (
       like indexer_configuration including defaults
     ) on commit drop;
     alter table tmp_indexer_configuration drop column id;
 $$;
 
 
 -- add tmp_indexer_configuration entries to indexer_configuration,
 -- skipping duplicates if any.
 --
 -- operates in bulk: 0. create temporary tmp_indexer_configuration, 1. COPY to
 -- it, 2. call this function to insert and filtering out duplicates
 create or replace function swh_indexer_configuration_add()
     returns setof indexer_configuration
     language plpgsql
 as $$
 begin
       insert into indexer_configuration(tool_name, tool_version, tool_configuration)
       select tool_name, tool_version, tool_configuration from tmp_indexer_configuration tmp
       on conflict(tool_name, tool_version, tool_configuration) do nothing;
 
       return query
           select id, tool_name, tool_version, tool_configuration
           from tmp_indexer_configuration join indexer_configuration
               using(tool_name, tool_version, tool_configuration);
 
       return;
 end
 $$;
diff --git a/sql/upgrades/115.sql b/sql/upgrades/115.sql
index 1e4b823..49dd8fa 100644
--- a/sql/upgrades/115.sql
+++ b/sql/upgrades/115.sql
@@ -1,40 +1,42 @@
 -- SWH Indexer DB schema upgrade
 -- from_version: 114
 -- to_version: 115
 -- description: Remove temporary table use in reading api
 
 insert into dbversion(version, release, description)
 values(115, now(), 'Work In Progress');
 
 drop function swh_mktemp_content_mimetype_missing();
 drop function swh_content_mimetype_missing();
 
 drop function swh_content_mimetype_get();
 drop type content_mimetype_signature;
 
 drop function swh_mktemp_content_language_missing();
 drop function swh_content_language_missing();
 
 drop function swh_content_language_get();
 drop type content_language_signature;
 
 drop function swh_mktemp_content_ctags_missing();
 drop function swh_content_ctags_missing();
 
 drop function swh_content_ctags_get();
 --drop type content_ctags_signature;  -- still used in swh_content_ctags_search
 
 drop function swh_content_fossology_license_get();
 drop type content_fossology_license_signature;
 
 drop function swh_mktemp_content_metadata_missing();
 drop function swh_content_metadata_missing();
 
 drop function swh_content_metadata_get();
 drop type content_metadata_signature;
 
 drop function swh_mktemp_revision_metadata_missing();
 drop function swh_revision_metadata_missing();
 
 drop function swh_revision_metadata_get();
 drop type revision_metadata_signature;
+
+drop function swh_mktemp_bytea();
diff --git a/swh/indexer/storage/db.py b/swh/indexer/storage/db.py
index 5d79dbb..3ab6906 100644
--- a/swh/indexer/storage/db.py
+++ b/swh/indexer/storage/db.py
@@ -1,387 +1,376 @@
 # 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 swh.model import hashutil
 
 from swh.storage.db import BaseDb, stored_procedure, cursor_to_bytes
 from swh.storage.db import line_to_bytes, execute_values_to_bytes
 
 
 class Db(BaseDb):
     """Proxy to the SWH Indexer DB, with wrappers around stored procedures
 
     """
-    @stored_procedure('swh_mktemp_bytea')
-    def mktemp_bytea(self, cur=None): pass
-
-    def store_tmp_bytea(self, ids, cur=None):
-        """Store the given identifiers in a new tmp_bytea table"""
-        cur = self._cursor(cur)
-
-        self.mktemp_bytea(cur)
-        self.copy_to(({'id': elem} for elem in ids), 'tmp_bytea',
-                     ['id'], cur)
-
     content_mimetype_hash_keys = ['id', 'indexer_configuration_id']
 
     def content_mimetype_missing_from_list(self, mimetypes, cur=None):
         """List missing mimetypes.
 
         """
         cur = self._cursor(cur)
         keys = ', '.join(self.content_mimetype_hash_keys)
         equality = ' AND '.join(
             ('t.%s = c.%s' % (key, key))
             for key in self.content_mimetype_hash_keys
         )
         yield from execute_values_to_bytes(
             cur, """
             select %s from (values %%s) as t(%s)
             where not exists (
                 select 1 from content_mimetype c
                 where %s
             )
             """ % (keys, keys, equality),
             (tuple(m[k] for k in self.content_mimetype_hash_keys)
              for m in mimetypes)
         )
 
     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):
         self._cursor(cur).execute("SELECT swh_content_mimetype_add(%s)",
                                   (conflict_update, ))
 
     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 == 'licenses':
             return '''
                 array(select name
                       from fossology_license
                       where id = ANY(
                          array_agg(%s.license_id))) as licenses''' % main_table
         return key
 
     def content_mimetype_get_from_list(self, ids, cur=None):
         cur = self._cursor(cur)
         keys = map(self._convert_key, self.content_mimetype_cols)
         yield from execute_values_to_bytes(
             cur, """
             select %s
             from (values %%s) as t(id)
             inner join content_mimetype c
                 on c.id=t.id
             inner join indexer_configuration i
                 on c.indexer_configuration_id=i.id;
             """ % ', '.join(keys),
             ((_id,) for _id in ids)
         )
 
     content_language_hash_keys = ['id', 'indexer_configuration_id']
 
     def content_language_missing_from_list(self, languages, cur=None):
         """List missing languages.
 
         """
         cur = self._cursor(cur)
         keys = ', '.join(self.content_language_hash_keys)
         equality = ' AND '.join(
             ('t.%s = c.%s' % (key, key))
             for key in self.content_language_hash_keys
         )
         yield from execute_values_to_bytes(
             cur, """
             select %s from (values %%s) as t(%s)
             where not exists (
                 select 1 from content_language c
                 where %s
             )
             """ % (keys, keys, equality),
             (tuple(l[k] for k in self.content_language_hash_keys)
              for l in languages)
         )
 
     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):
         self._cursor(cur).execute("SELECT swh_content_language_add(%s)",
                                   (conflict_update, ))
 
     def content_language_get_from_list(self, ids, cur=None):
         cur = self._cursor(cur)
         keys = map(self._convert_key, self.content_language_cols)
         yield from execute_values_to_bytes(
             cur, """
             select %s
             from (values %%s) as t(id)
             inner join content_language c
                 on c.id=t.id
             inner join indexer_configuration i
                 on c.indexer_configuration_id=i.id;
             """ % ', '.join(keys),
             ((_id,) for _id in ids)
         )
 
     content_ctags_hash_keys = ['id', 'indexer_configuration_id']
 
     def content_ctags_missing_from_list(self, ctags, cur=None):
         """List missing ctags.
 
         """
         cur = self._cursor(cur)
         keys = ', '.join(self.content_ctags_hash_keys)
         equality = ' AND '.join(
             ('t.%s = c.%s' % (key, key))
             for key in self.content_ctags_hash_keys
         )
         yield from execute_values_to_bytes(
             cur, """
             select %s from (values %%s) as t(%s)
             where not exists (
                 select 1 from content_ctags c
                 where %s
             )
             """ % (keys, keys, equality),
             (tuple(c[k] for k in self.content_ctags_hash_keys)
              for c in ctags)
         )
 
     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):
         self._cursor(cur).execute("SELECT swh_content_ctags_add(%s)",
                                   (conflict_update, ))
 
     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_to_bytes(
             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 cursor_to_bytes(cur)
 
     content_fossology_license_cols = [
         'id', 'tool_id', 'tool_name', 'tool_version', 'tool_configuration',
         'licenses']
 
     @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.
 
         """
         self._cursor(cur).execute(
             "SELECT swh_content_fossology_license_add(%s)",
             (conflict_update, ))
 
     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_to_bytes(
             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
             group by c.id, i.id, i.tool_name, i.tool_version,
                      i.tool_configuration;
             """ % ', '.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.
 
         """
         cur = self._cursor(cur)
         keys = ', '.join(self.content_metadata_hash_keys)
         equality = ' AND '.join(
             ('t.%s = c.%s' % (key, key))
             for key in self.content_metadata_hash_keys
         )
         yield from execute_values_to_bytes(
             cur, """
             select %s from (values %%s) as t(%s)
             where not exists (
                 select 1 from content_metadata c
                 where %s
             )
             """ % (keys, keys, equality),
             (tuple(m[k] for k in self.content_metadata_hash_keys)
              for m in metadata)
         )
 
     content_metadata_cols = [
         'id', 'translated_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):
         self._cursor(cur).execute("SELECT swh_content_metadata_add(%s)",
                                   (conflict_update, ))
 
     def content_metadata_get_from_list(self, ids, cur=None):
         cur = self._cursor(cur)
         keys = map(self._convert_key, self.content_metadata_cols)
         yield from execute_values_to_bytes(
             cur, """
             select %s
             from (values %%s) as t(id)
             inner join content_metadata c
                 on c.id=t.id
             inner join indexer_configuration i
                 on c.indexer_configuration_id=i.id;
             """ % ', '.join(keys),
             ((_id,) for _id in ids)
         )
 
     content_revision_metadata_hash_keys = ['id', 'indexer_configuration_id']
 
     def revision_metadata_missing_from_list(self, metadata, cur=None):
         """List missing metadata.
 
         """
         cur = self._cursor(cur)
         keys = ', '.join(self.content_revision_metadata_hash_keys)
         equality = ' AND '.join(
             ('t.%s = r.%s' % (key, key))
             for key in self.content_revision_metadata_hash_keys
         )
         yield from execute_values_to_bytes(
             cur, """
             select %s from (values %%s) as t(%s)
             where not exists (
                 select 1 from revision_metadata r
                 where %s
             )
             """ % (keys, keys, equality),
             (tuple(m[k] for k in self.content_revision_metadata_hash_keys)
              for m in metadata)
         )
 
     revision_metadata_cols = [
         'id', 'translated_metadata',
         'tool_id', 'tool_name', 'tool_version', 'tool_configuration']
 
     @stored_procedure('swh_mktemp_revision_metadata')
     def mktemp_revision_metadata(self, cur=None): pass
 
     def revision_metadata_add_from_temp(self, conflict_update, cur=None):
         self._cursor(cur).execute("SELECT swh_revision_metadata_add(%s)",
                                   (conflict_update, ))
 
     def revision_metadata_get_from_list(self, ids, cur=None):
         cur = self._cursor(cur)
         keys = map(lambda k: self._convert_key(k, main_table='r'),
                    self.revision_metadata_cols)
         yield from execute_values_to_bytes(
             cur, """
             select %s
             from (values %%s) as t(id)
             inner join revision_metadata r
                 on r.id=t.id
             inner join indexer_configuration i
                 on r.indexer_configuration_id=i.id;
             """ % ', '.join(keys),
             ((_id,) for _id in ids)
         )
 
     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 cursor_to_bytes(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))
 
         data = cur.fetchone()
         if not data:
             return None
         return line_to_bytes(data)