then - replace null postgresql
La mejor manera de verificar si hay "valor vacío o nulo" (6)
Algo que vi que la gente usa es stringexpression > '''' . Este puede no ser el más rápido, pero pasa a ser uno de los más cortos.
Lo intenté en MS SQL y en PostgreSQL.
¿Cuál es la mejor manera de verificar si el valor es cadena nula o vacía en las sentencias SQL de Postgres?
El valor puede ser una expresión larga, por lo que es preferible que se escriba solo una vez bajo control.
Actualmente estoy usando:
coalesce( trim(stringexpression),'''')=''''
Pero se ve un poco feo
stringexpression puede ser una columna char(n) o una expresión que contenga columnas char(n) con espacios finales.
¿Cuál es la mejor manera?
La expresión stringexpression = '''' produce:
TRUE .. for '''' (o para cualquier cadena que consista de solo espacios con el tipo de datos char(n) )
NULL .. para NULL
FALSE ... para cualquier otra cosa
Entonces, para verificar: " stringexpression es NULL o está vacío" :
(stringexpression = '''') IS NOT FALSE
O el enfoque inverso (puede ser más fácil de leer):
(stringexpression <> '''') IS NOT TRUE
Funciona para cualquier tipo de personaje, incluido el char(n) obsoleto char(n) que casi nunca es útil.
El manual sobre operadores de comparación.
O use la expresión que ya tenía, solo sin el trim() que sería inútil para char(n) (ver más abajo), o incluiría cadenas que consisten en espacios únicos en la prueba para otros tipos de caracteres:
coalesce(stringexpression, '''') = ''''
Pero las expresiones en la parte superior son más rápidas.
Afirmando lo contrario: " stringexpression no es NULL ni está vacío" es aún más simple:
stringexpression <> ''''
Acerca de char(n)
No confunda este tipo de datos con otros tipos de caracteres como varchar(n) , varchar , text o "char" (con comillas), que son todos tipos de datos útiles. Se trata del tipo de datos obsoletos con una utilidad muy limitada: char(n) , abreviatura de: character(n) . Además, char y character son abreviatura de char(1) / character(1) (lo mismo).
En char(n) (¡a diferencia de otros tipos de cadenas!) Una cadena vacía no es diferente de cualquier otra cadena que consista en espacios únicos. Todos estos están plegados en n espacios en char(n) por definición del tipo. De esto se deduce lógicamente que esto también funciona para char(n) :
coalesce(stringexpression, '''') = ''''
Tanto como estos (que no funcionaría para otros tipos de caracteres):
coalesce(stringexpression, '' '') = '' ''
coalesce(stringexpression, '''') = '' ''
Manifestación
La cadena vacía es igual a cualquier cadena de espacios cuando se convierte en char(n) :
SELECT ''''::char(5) = ''''::char(5) AS eq1
,''''::char(5) = '' ''::char(5) AS eq2
,''''::char(5) = '' ''::char(5) AS eq3;
eq1 | eq2 | eq3 ----+-----+---- t | t | t
Prueba de "cadena nula o vacía" con char(n) :
SELECT stringexpression
,stringexpression = '''' AS simple_test
,(stringexpression = '''') IS NOT FALSE AS test1
,(stringexpression <> '''') IS NOT TRUE AS test2
,coalesce(stringexpression, '''') = '''' AS test_coalesce1
,coalesce(stringexpression, '' '') = '' '' AS test_coalesce2
,coalesce(stringexpression, '''') = '' '' AS test_coalesce3
FROM (
VALUES
(''foo''::char(5))
, ('''')
, (NULL)
, ('' '') -- not different from '''' in char(n)
) sub(stringexpression);
stringexpression | simple_test | test1 | test2 | test_coalesce1 | test_coalesce2 | test_coalesce3 ------------------+-------------+-------+-------+----------------+----------------+---------------- foo | f | f | f | f | f | f | t | t | t | t | t | t | | t | t | t | t | t | t | t | t | t | t | t
Prueba de "cadena vacía o nula" con text
SELECT stringexpression
,stringexpression = '''' AS simple_test
,(stringexpression = '''') IS NOT FALSE AS test1
,(stringexpression <> '''') IS NOT TRUE AS test2
,coalesce(stringexpression, '''') = '''' AS test_coalesce1
,coalesce(stringexpression, '' '') = '' '' AS test_coalesce2
,coalesce(stringexpression, '''') = '' '' AS test_coalesce3
FROM (
VALUES
(''foo''::text)
, ('''')
, (NULL)
, ('' '') -- different from '''' in a sane character type like text
) sub(stringexpression);
stringexpression | simple_test | test1 | test2 | test_coalesce1 | test_coalesce2 | test_coalesce3 ------------------+-------------+-------+-------+----------------+----------------+---------------- foo | f | f | f | f | f | f | t | t | t | t | f | f | | t | t | t | t | f | f | f | f | f | f | f
dbfiddle here
Viejo SQL Fiddle
Relacionado:
Mi forma preferida de comparar campos con nulos es: NULLIF (nullablefield,: ParameterValue) IS NULL Y NULLIF (: ParameterValue, nullablefield) IS NULL. Esto es engorroso pero es de uso universal mientras que Coalesce es imposible en algunos casos.
El segundo uso inverso de NULLIF es porque "NULLIF (nullablefield,: ParameterValue) IS NULL" siempre devolverá "verdadero" si el primer parámetro es nulo.
Para verificar nulo y vacío:
coalesce(string, '''') = ''''
Para comprobar nulo, vacío y espacios (recortar la cadena)
coalesce(TRIM(string), '''') = ''''
Si la base de datos tiene un gran número de registros, la null check puede llevar más tiempo, puede usar la verificación nula de diferentes maneras, como: 1) where columnname is null 2) where not exists() 3) WHERE (case when columnname is null then true end)
Si puede haber espacios finales vacíos, probablemente no haya una mejor solución. COALESCE es solo para problemas como el tuyo.