Recherche de colonnes vides d'une table dans PostgreSQL

Quelle requête retournerait le nom des colonnes d'une table où toutes les lignes sont NULL?

banc d'essai:

create role stack;
create schema authorization stack;
set role stack;

create table my_table as 
select generate_series(0,9) as id, 1 as val1, null::integer as val2;

create table my_table2 as 
select generate_series(0,9) as id, 1 as val1, null::integer as val2, 3 as val3;

une fonction:

create function has_nonnulls(p_schema in text, p_table in text, p_column in text)
                returns boolean language plpgsql as $$
declare 
  b boolean;
begin
  execute 'select exists(select * from '||
          p_table||' where '||p_column||' is not null)' into b;
  return b;
end;$$;

requete:

select table_schema, table_name, column_name, 
       has_nonnulls(table_schema, table_name, column_name)
from information_schema.columns
where table_schema='stack';

résultat:

 table_schema | table_name | column_name | has_nonnulls
--------------+------------+-------------+--------------
 stack        | my_table   | id          | t
 stack        | my_table   | val1        | t
 stack        | my_table   | val2        | f
 stack        | my_table2  | id          | t
 stack        | my_table2  | val1        | t
 stack        | my_table2  | val2        | f
 stack        | my_table2  | val3        | t
(7 rows)

De plus, vous pouvez obtenir une réponse approximative en interrogeant le catalogue - si null_fracest zéro qui n'indique pas de null mais doit être revérifié par rapport aux données «réelles»:

select tablename, attname, null_frac from pg_stats where schemaname='stack';

 tablename | attname | null_frac
-----------+---------+-----------
 my_table  | id      |         0
 my_table  | val1    |         0
 my_table  | val2    |         1
 my_table2 | id      |         0
 my_table2 | val1    |         0
 my_table2 | val2    |         1
 my_table2 | val3    |         0
(7 rows)

Dans Postgresql, vous pouvez obtenir les données directement à partir des statistiques:

vacuum analyze; -- if needed

select schemaname, tablename, attname
from pg_stats
where most_common_vals is null
and most_common_freqs is null
and histogram_bounds is null
and correlation is null
and null_frac = 1;

Vous pourriez obtenir quelques faux positifs, donc une nouvelle vérification est en ordre après avoir trouvé les candidats.

Je vais vous montrer ma solution en T-SQL, travaillant pour SQL Server 2008. Je ne connais pas PostgreSQL, mais j'espère que vous trouverez quelques conseils dans ma solution.

-- create test table
IF object_id ('dbo.TestTable') is not null
    DROP table testTable
go
create table testTable (
    id int identity primary key clustered,
    nullColumn varchar(100) NULL,
    notNullColumn varchar(100) not null,
    combinedColumn varchar(100) NULL,
    testTime datetime default getdate()
);
go

-- insert test data:
INSERT INTO testTable(nullColumn, notNullColumn, combinedColumn)
SELECT NULL, 'Test', 'Combination'
from sys.objects
union all
SELECT NULL, 'Test2', NULL
from sys.objects

select *
from testTable

-- FIXED SCRIPT FOR KNOWN TABLE (known structure) - find all completely NULL columns
select sum(datalength(id)) as SumColLength,
    'id' as ColumnName
from dbo.testTable
UNION ALL
select sum(datalength(nullColumn)) as SumColLength,
    'nullColumn' as ColumnName
from dbo.testTable
UNION ALL
select sum(datalength(notNullColumn)) as SumColLength,
    'notNullColumn' as ColumnName
from dbo.testTable
UNION ALL
select sum(datalength(combinedColumn)) as SumColLength,
    'combinedColumn' as ColumnName
from dbo.testTable
UNION ALL
select sum(datalength(testTime)) as SumColLength,
    'testTime' as ColumnName
from dbo.testTable

-- DYNAMIC SCRIPT (unknown structure) - find all completely NULL columns
declare @sql varchar(max) = '', @tableName sysname = 'testTable';

SELECT @sql +=
        'select sum(datalength(' + c.COLUMN_NAME + ')) as SumColLength,
    ''' + c.COLUMN_NAME + ''' as ColumnName
from ' + c.TABLE_SCHEMA + '.' + c.TABLE_NAME --as StatementToExecute
+ '
UNION ALL
'
FROM INFORMATION_SCHEMA.COLUMNS c
WHERE c.TABLE_NAME = @tableName;

SET @sql = left(@sql, len(@sql)-11)
print @sql;
exec (@sql);

Ce que j'ai fait, en bref, a été de créer une table de test avec 5 colonnes, ID et testTime étant générées par la fonction d'identité et getdate (), tandis que les 3 colonnes varchar sont celles qui nous intéressent. L'un n'aura que des valeurs NULL, l'un n'aura aucun NULL, l'autre sera une colonne combinée. Le résultat final du script sera que le script signalera la colonne nullColumn comme ayant toutes les lignes NULL.

L'idée était de calculer la fonction DATALENGTH pour chaque colonne (calcule le nombre d'octets pour une expression donnée). J'ai donc calculé la valeur DATALENGTH pour chaque ligne de chaque colonne et fait un SUM par colonne. Si la somme par colonne est NULL, alors la colonne complète a des lignes NULL, sinon il y a des données à l'intérieur.

Maintenant, vous devez trouver la traduction pour PostgreSQL et j'espère qu'un collègue pourra vous aider avec cela. Ou peut-être qu'il y a une belle vue du système qui montrera à quel point je suis stupide de réinventer la roue :-).

Vous devez interroger le catalogue d'informations pour ces informations:

SELECT column_name FROM information_schema.columns WHERE table_name='your_table'

vous donne les tableaux correspondants pour vos colonnes.

Je n'ai pas d'installation de postgres à portée de main mais le reste devrait être simple

   loop over the results of the above query and foreach result
        send a COUNT(*) to the table
        if the count is null, give back the column,
                 else ignore it
   end foreach

Après avoir combiné à partir de plusieurs ressources, j'ai trouvé cette fonction et cette requête pour trouver toutes les colonnes vides dans toutes les tables de base de données

CREATE OR REPLACE FUNCTION public.isEmptyColumn(IN table_name varchar, IN column_name varchar)
RETURNS boolean AS $$
declare 
    count integer;
BEGIN
    execute FORMAT('SELECT COUNT(*) from %s WHERE %s IS NOT NULL', table_name, quote_ident(column_name)) into count;
    RETURN (count = 0);
END; $$
LANGUAGE PLPGSQL; 


SELECT s.table_name, s.column_name
FROM information_schema.columns s
WHERE (s.table_schema LIKE 'public') AND
      (s.table_name NOT LIKE 'pg_%') AND
      (public.isEmptyColumn(s.table_name, s.column_name))

Prendre plaisir :)