“Boş veya boş değer” kontrol etmenin en iyi yolu

Postgres sql ifadelerinde değerin null veya boş dize olup olmadığını kontrol etmenin en iyi yolu nedir?

Değer uzun ifade olabilir, bu nedenle kontrolde yalnızca bir kez yazılması tercih edilir.

Şu anda kullanıyorum:

coalesce( trim(stringexpression),'')=''

Ama biraz çirkin gözüküyor.

stringexpressionchar(n)sütun veya char(n)sondaki boşluklu sütunlar içeren ifade olabilir .

En iyi yol nedir?

İfade şu sonuçları stringexpression = ''verir:

TRUE   .. için ''(veya yalnızca veri türüne sahip boşluklardan oluşan herhangi bir dize   için char(n))
NULL.. için NULL
FALSE .. başka bir şey için

Bu yüzden kontrol etmek için: " stringexpressionboş veya boş" :

(stringexpression = '') IS NOT FALSE

Veya tersine yaklaşım (okunması daha kolay olabilir):

(stringexpression <> '') IS NOT TRUE

Dahil herhangi bir karakter türü için çalışır char(n). Karşılaştırma operatörleri kılavuzu.

Veya orijinal ifadenizi kullanmayın trim(), bu maliyet char(n)düşüktür (aşağıya bakın) veya diğer karakter türleri için yanlıştır: yalnızca boşluklardan oluşan dizeler boş dize olarak geçer.

coalesce(stringexpression, '') = ''

Ancak üstteki ifadeler daha hızlıdır.

Aksini iddia etmek daha da basittir: " stringexpressionne NULL ne de boş" :

stringexpression <> ''

hakkında char(n)

Bu, veri türüyle ilgilidir char(n): kısaltması character(n). ( char/ characterİçin kısa char(1)/ ' character(1).) Kullanımı edilir Postgres cesaretini :

Çoğu durumda textveya character varyingbunun yerine kullanılmalıdır.

Karıştırmayın char(n)diğer yararlı, karakter tipleri varchar(n), varchar, textveya"char" (çift tırnak).

Gelen char(n)bir boş bir dizge , boşluklar oluşan her hangi bir başka dizisinden farklı değildir. Bunların tümü , tip tanımına göre n boşluğa katlanır char(n). Yukarıdaki ifadelerin char(n)de aynı şekilde (diğer karakter türleri için işe yaramayacak kadar) işe yaradığı mantıklı bir şekilde sonuçlanır:

coalesce(stringexpression, '  ') = '  '
coalesce(stringexpression, '') = '       '

gösteri

Boş dize, şuraya verildiğinde boşluk dizesine eşittir char(n):

SELECT ''::char(5) = ''::char(5)     AS eq1
     , ''::char(5) = '  '::char(5)   AS eq2
     , ''::char(5) = '    '::char(5) AS eq3;

Sonuç:

 eq1 | eq2 | eq3
 ----+-----+----
 t   | t   | t

Şununla "boş veya boş dize" için test yapın char(n):

SELECT stringexpression 
     , stringexpression = ''                   AS base_test
     , (stringexpression = '')  IS NOT FALSE   AS test1
     , (stringexpression <> '') IS NOT TRUE    AS test2
     , coalesce(stringexpression, '') = ''     AS coalesce1
     , coalesce(stringexpression, '  ') = '  ' AS coalesce2
     , coalesce(stringexpression, '') = '  '   AS coalesce3
FROM  (
   VALUES
     ('foo'::char(5))
   , ('')
   , ('   ')                -- not different from '' in char(n)
   , (NULL)
   ) sub(stringexpression);

Sonuç:

stringexpression | base_test | test1 | test2 | birleşme1 | coalesce2 | coalesce3
------------------ + ----------- + ------- + ------- + --- -------- + ----------- + -----------
 foo | f | f | f | f | f | f
                  | t | t | t | t | t | t
                  | t | t | t | t | t | t
 null              | null       | t | t | t | t | t

Şununla "boş veya boş dize" için test yapın text:

SELECT stringexpression 
     , stringexpression = ''                   AS base_test
     , (stringexpression = '')  IS NOT FALSE   AS test1
     , (stringexpression <> '') IS NOT TRUE    AS test2
     , coalesce(stringexpression, '') = ''     AS coalesce1
     , coalesce(stringexpression, '  ') = '  ' AS coalesce2
     , coalesce(stringexpression, '') = '  '   AS coalesce3
FROM  (
   VALUES
     ('foo'::text)
   , ('')
   , ('   ')                -- different from '' in a sane character types
   , (NULL)
   ) sub(stringexpression);

Sonuç:

stringexpression | base_test | test1 | test2 | birleşme1 | coalesce2 | coalesce3
------------------ + ----------- + ------- + ------- + --- -------- + ----------- + -----------
 foo | f | f | f | f | f | f
                  | t | t | t | t | f | f
                  | f | f | f | f | f | f
 null              | null       | t | t | t | t | f

db <> keman burada
_{Eski sqlfiddle}

İlişkili:

• Dizeleri saklamak için "metin" veri türünü kullanmanın herhangi bir olumsuz yanı var mı?

Boş ve boş olup olmadığını kontrol etmek için:

coalesce(string, '') = ''

Boş, boş ve boşluk olup olmadığını kontrol etmek için (ipi kırpın)

coalesce(TRIM(string), '') = ''

Dizenin uzunluğunu kontrol etmek de çalışır ve kompakttır:

where length(stringexpression) > 0;

Boş arka boşluklar varsa, muhtemelen daha iyi bir çözüm yoktur. COALESCEsadece sizinki gibi problemler içindir.

İnsanların kullandığını gördüğüm bir şey stringexpression > '' . Bu en hızlı olmayabilir, ancak en kısa olanlardan biri olur.

MS SQL ve PostgreSQL üzerinde denedim.

başka bir yol

nullif(trim(stringExpression),'') is not null

Null alanlarını karşılaştırmak için tercih ettiğim yol: NULLIF (nulllablefield,: ParameterValue) IS NULL AND NULLIF (: ParameterValue, nullablefield) IS NULL. Bu hantal ama evrensel kullanımdayken, Coalesce bazı durumlarda imkansız.

NULLIF'in ikinci ve ters kullanımı, ilk parametre null olduğunda "NULLIF (boş alan,: ParameterValue) IS NULL" her zaman "true" döndürür.

Çok sayıda kayda sahip veritabanı null checkdaha fazla zaman alabilirse, null kontrolü aşağıdaki gibi farklı şekillerde kullanabilirsiniz: 1) where columnname is null 2) where not exists() 3)WHERE (case when columnname is null then true end)

Bir çok yanıt en kısa yoldur, sütunun çok sayıda boş değeri olması gerekiyorsa mutlaka en iyi yol değildir. Kontrolleri kaldırmak, optimize edicinin diğer şartlarda çalışması gerekmediğinden kontrolü daha hızlı değerlendirmesini sağlar.

(stringexpression IS NOT NULL AND trim(stringexpression) != '')

İlk koşul yanlış olduğundan dize karşılaştırmasının değerlendirilmesi gerekmez.