Encontrar uma linha por chave primária, quando você não sabe em qual tabela ela está?

Todas as tabelas usarão bigint como chave primária e todas (indiretamente) herdarão da mesma tabela base

Não tenho certeza se gosto disso "todas as tabelas herdam da tabela base", mas, considerando isso, parece factível com o Postgres:

Para gerar a chave primária para todas as tabelas, crie uma sequência:

create sequence one_for_all as bigint;

Crie a tabela base usando essa sequência para gerar os valores:

create table base (id integer primary key default nextval('one_for_all'));

Observe que a chave primária não será aplicada para as tabelas filhas!

Em seguida, crie as tabelas filhas:

create table t1 (t1_data integer, primary key (id)) inherits (base);
create table t2 (t2_data integer, primary key (id)) inherits (base);

Se você agora inserir nas tabelas filhas, a sequência será usada para gerar o ID:

insert into t1 (t1_data) values (100);
insert into t2 (t2_data) values (200);

Para descobrir em qual tabela uma linha está localizada, selecione na tabela base e inclua a tableoidcoluna que identifica a tabela real na qual a linha está localizada:

select b.*, tableoid::regclass as actual_table
from base b
where id = 42;

Você ainda precisará de outra consulta para retornar a linha completa da tabela filha.

Exemplo online: https://dbfiddle.uk/?rdbms=postgres_11&fiddle=4305e86b996e7a94c24faed733257232

Outra abordagem que não precisa de herança é gerar valores de ID que codificam o nome da tabela (shudder).

Algo na linha:

create sequence one_for_all as bigint;
create table lookup (table_name text primary key, code serial unique);
insert into lookup (table_name) values ('base'), ('t1'), ('t2');

create function get_id(p_tablename text)
  returns bigint
as
$$
  select nextval('one_for_all') * 1000 + code
  from lookup
  where table_name = p_tablename;
$$
language sql;

create function get_tablename(p_id bigint)
  returns text
as
$$
  select table_name
  from lookup
  where code = p_id % 1000;  
$$
language sql;

Ao multiplicar o valor da sequência por 1000, temos essencialmente os 3 dígitos inferiores disponíveis para codificar um número único para cada tabela. Para poder pesquisar esses números, precisamos dessa tabela adicional.

Observe que isso falhará miseravelmente se a tabela de pesquisa não contiver todas as tabelas!

Então, em vez de usar nextval()use, a get_id()função:

create table base (id integer primary key default get_id('base'));
create table t1 (id integer primary key default get_id('t1'), some_value integer);
create table t2 (id integer primary key default get_id('t2'), some_data text);

Então você pode fazer:

insert into t1 (some_value) values (42);
insert into t2 (some_data) values ('foo');
insert into t1 (some_value) values (117);
insert into t2 (some_data) values ('bar');

Assim, as linhas em t2 agora vão para os IDs 2003 e 4003. A função get_tablename()pode ser usada para recuperar o nome da tabela à qual um ID pertence:

select get_tablename(2003);

get_tablename
-------------
t2           

Isso é certamente mais rápido em termos de procurar o nome da tabela e não carrega a bagagem de uma enorme árvore de herança. Portanto, em termos de desempenho, provavelmente é mais rápido. No entanto, tornar-se-á um pesadelo de manutenção.

O preenchimento da tabela de pesquisa talvez possa ser feito por meio de acionadores de eventos sempre que uma tabela for criada ou descartada.

Se você puder alterar seu aplicativo para oferecer suporte a chaves primárias varchar, em vez de bigint (e puder conviver com os requisitos de armazenamento um pouco mais altos), também poderá gerar o ID como uma string que simplesmente contém o nome da tabela:

create function get_id(p_tablename text)
  returns text
as
$$
  select concat(nextval('one_for_all'), '_', p_tablename)
$$
language sql;

No entanto, coisas como classificação e consultas de intervalo serão complicadas.