Postgres 9.5 of hoger
Of gebruik array_position()
. Kortom:
SELECT array_position(arr, NULL) IS NOT NULL AS array_has_null
Zie demo hieronder.
Postgres 9.3 of hoger
U kunt testen met de ingebouwde functies array_remove()
of array_replace()
.
Postgres 9.1 of welke versie dan ook
Als je weet een enkel element dat nooit in uw arrays kan voorkomen, kunt u dit snel . gebruiken uitdrukking. Stel, je hebt een array van positieve getallen, en -1
kan er nooit in zitten:
-1 = ANY(arr) IS NULL
Gerelateerd antwoord met gedetailleerde uitleg:
- Is array alle NULL's in PostgreSQL
Als u niet helemaal zeker weet , je zou terugvallen op een van de dure maar veilige methoden met unnest()
. Vind ik leuk:
(SELECT bool_or(x IS NULL) FROM unnest(arr) x)
of:
EXISTS (SELECT 1 FROM unnest(arr) x WHERE x IS NULL)
Maar u kunt snel en veilig met een CASE
uitdrukking. Gebruik een onwaarschijnlijk getal en val terug op de veilige methode als deze zou bestaan. Misschien wilt u de zaak behandelen arr IS NULL
afzonderlijk. Zie demo hieronder.
Demo
SELECT num, arr, expect
, -1 = ANY(arr) IS NULL AS t_1 -- 50 ms
, (SELECT bool_or(x IS NULL) FROM unnest(arr) x) AS t_2 -- 754 ms
, EXISTS (SELECT 1 FROM unnest(arr) x WHERE x IS NULL) AS t_3 -- 521 ms
, CASE -1 = ANY(arr)
WHEN FALSE THEN FALSE
WHEN TRUE THEN EXISTS (SELECT 1 FROM unnest(arr) x WHERE x IS NULL)
ELSE NULLIF(arr IS NOT NULL, FALSE) -- catch arr IS NULL -- 55 ms
-- ELSE TRUE -- simpler for columns defined NOT NULL -- 51 ms
END AS t_91
, array_replace(arr, NULL, 0) <> arr AS t_93a -- 99 ms
, array_remove(arr, NULL) <> arr AS t_93b -- 96 ms
, cardinality(array_remove(arr, NULL)) <> cardinality(arr) AS t_94 -- 81 ms
, COALESCE(array_position(arr, NULL::int), 0) > 0 AS t_95a -- 49 ms
, array_position(arr, NULL) IS NOT NULL AS t_95b -- 45 ms
, CASE WHEN arr IS NOT NULL
THEN array_position(arr, NULL) IS NOT NULL END AS t_95c -- 48 ms
FROM (
VALUES (1, '{1,2,NULL}'::int[], true) -- extended test case
, (2, '{-1,NULL,2}' , true)
, (3, '{NULL}' , true)
, (4, '{1,2,3}' , false)
, (5, '{-1,2,3}' , false)
, (6, NULL , null)
) t(num, arr, expect);
Resultaat:
num | arr | expect | t_1 | t_2 | t_3 | t_91 | t_93a | t_93b | t_94 | t_95a | t_95b | t_95c -----+-------------+--------+--------+------+-----+------+-------+-------+------+-------+-------+------- 1 | {1,2,NULL} | t | t | t | t | t | t | t | t | t | t | t 2 | {-1,NULL,2} | t | f --!! | t | t | t | t | t | t | t | t | t 3 | {NULL} | t | t | t | t | t | t | t | t | t | t | t 4 | {1,2,3} | f | f | f | f | f | f | f | f | f | f | f 5 | {-1,2,3} | f | f | f | f | f | f | f | f | f | f | f 6 | NULL | NULL | t --!! | NULL | f | NULL | NULL | NULL | NULL | f | f | NULL
Merk op dat array_remove()
en array_position()
zijn niet toegestaan voor multidimensionale arrays . Alle uitdrukkingen rechts van t_93a
werken alleen voor 1-dimensionale arrays.
db<>viool hier - Postgres 13, met meer tests
Oude sqlfiddle
Benchmark-configuratie
De toegevoegde tijden zijn afkomstig van een benchmarktest met 200k rijen in Postgres 9.5 . Dit is mijn opstelling:
CREATE TABLE t AS
SELECT row_number() OVER() AS num
, array_agg(elem) AS arr
, bool_or(elem IS NULL) AS expected
FROM (
SELECT CASE WHEN random() > .95 THEN NULL ELSE g END AS elem -- 5% NULL VALUES
, count(*) FILTER (WHERE random() > .8)
OVER (ORDER BY g) AS grp -- avg 5 element per array
FROM generate_series (1, 1000000) g -- increase for big test case
) sub
GROUP BY grp;
Functieomslag
Voor herhaaldelijk gebruik , ik zou een functie maken in Postgres 9.5 zoals dit:
CREATE OR REPLACE FUNCTION f_array_has_null (anyarray)
RETURNS bool
LANGUAGE sql IMMUTABLE PARALLEL SAFE AS
'SELECT array_position($1, NULL) IS NOT NULL';
PARALLEL SAFE
alleen voor Postgres 9.6 of hoger.
Als u een polymorf invoertype gebruikt, werkt dit voor elke arraytype, niet alleen int[]
.
Maak het IMMUTABLE
om prestatie-optimalisatie en indexexpressies mogelijk te maken.
- Ondersteunt PostgreSQL "accentongevoelige" sorteringen?
Maar maak het niet STRICT
, wat "function inlining" zou uitschakelen en de prestaties zou verminderen omdat array_position()
is niet STRICT
zelf. Zie:
- Functie wordt sneller uitgevoerd zonder STRIKTE modifier?
Als je de zaak moet pakken arr IS NULL
:
CREATE OR REPLACE FUNCTION f_array_has_null (anyarray)
RETURNS bool
LANGUAGE sql IMMUTABLE PARALLEL SAFE AS
'SELECT CASE WHEN $1 IS NOT NULL
THEN array_position($1, NULL) IS NOT NULL END';
Voor Postgres 9.1 gebruik de t_91
uitdrukking van bovenaf. De rest blijft ongewijzigd.
Nauw verwant:
- Hoe te bepalen of NULL in een array in Postgres staat?