Operadores que admiten valores NULL en las consultas

  • Artículo

Los operadores que admiten valores NULL son operadores aritméticos binarios o de comparación que funcionan con tipos aritméticos que admiten valores NULL en uno o ambos lados. Los tipos que admiten valores NULL surgen cuando se trabaja con datos de orígenes como bases de datos que permiten valores NULL en lugar de valores reales. Los operadores que admiten valores NULL se usan en expresiones de consulta. Además de los operadores que admiten valores NULL para la comparación y aritmética, los operadores de conversión se pueden usar para convertir entre tipos que admiten valores NULL. También hay versiones que admiten valores NULL de determinados operadores de consulta.

Nota

Por lo general, los operadores que admiten valores NULL solo se usan en expresiones de consulta. Si no usa expresiones de consulta, no es necesario conocer ni usar estos operadores.

Tabla de operadores que admiten valores NULL

En la tabla siguiente se enumeran los operadores que admiten valores NULL admitidos en F#.

Admite valores NULL a la izquierda Admite valores NULL a la derecha Ambos lados admiten valores NULL
?>= >=? ?>=?
?> >? ?>?
?<= <=? ?<=?
?< <? ?<?
?= =? ?=?
?<> <>? ?<>?
?+ +? ?+?
?- -? ?-?
?* *? ?*?
?/ /? ?/?
?% %? ?%?

Comentarios

Los operadores que admiten valores NULL se incluyen en el módulo NullableOperators del espacio de nombres FSharp.Linq. El tipo de datos que admiten valores NULL es System.Nullable<'T>.

En las expresiones de consulta, surgen tipos que admiten valores NULL al seleccionar datos de un origen de datos que permite valores NULL en lugar de valores. En una base de datos SQL Server, cada columna de datos de una tabla tiene un atributo que indica si se admiten valores NULL. Si se admiten valores NULL, los datos devueltos desde la base de datos pueden contener valores NULL que no se pueden representar mediante un tipo de datos primitivo como int, float, etc. Por lo tanto, los datos se devuelven como System.Nullable<int> en lugar de int, y System.Nullable<float> en lugar de float. El valor real se puede obtener de un objeto System.Nullable<'T> mediante la propiedad Value y puede determinar si un objeto System.Nullable<'T> tiene un valor llamando al método HasValue. Otro método útil es el método System.Nullable<'T>.GetValueOrDefault, que permite obtener el valor o un valor predeterminado del tipo adecuado. El valor predeterminado es alguna forma de valor "cero", como 0, 0,0 o false.

Los tipos que aceptan valores NULL se pueden convertir en tipos primitivos que no aceptan valores NULL mediante los operadores de conversión habituales, como int o float. También es posible convertir de un tipo que admite valores NULL a otro tipo que admite valores NULL mediante los operadores de conversión para tipos que admiten valores NULL. Los operadores de conversión adecuados tienen el mismo nombre que los estándar, pero están en un módulo independiente, el módulo que admite valores NULL en el espacio de nombres FSharp.Linq. Normalmente, se abre este espacio de nombres al trabajar con expresiones de consulta. En ese caso, puede usar los operadores de conversión que admiten valores NULL agregando el prefijo Nullable. al operador de conversión adecuado, como se muestra en el código siguiente.

open Microsoft.FSharp.Linq

let nullableInt = new System.Nullable<int>(10)

// Use the Nullable.float conversion operator to convert from one nullable type to another nullable type.
let nullableFloat = Nullable.float nullableInt

// Use the regular non-nullable float operator to convert to a non-nullable float.
printfn $"%f{float nullableFloat}"

La salida es 10.000000.

Los operadores de consulta en campos de datos que admiten valores NULL, como sumByNullable, también existen para su uso en expresiones de consulta. Los operadores de consulta para tipos que no admiten valores NULL no son compatibles con tipos que admiten valores NULL, por lo que debe usar la versión que admite valores NULL del operador de consulta adecuado cuando se trabaja con valores de datos que admiten valores NULL. Para obtener más información, consulte Expresiones de consulta.

En el ejemplo siguiente se muestra el uso de operadores que admiten valores NULL en una expresión de consulta de F#. La primera consulta muestra cómo escribiría una consulta sin un operador que admite valores NULL; la segunda consulta muestra una consulta equivalente que usa un operador que admite valores NULL. Para obtener el contexto completo, incluida la configuración de la base de datos para usar este código de ejemplo, consulte Tutorial: Acceso a un SQL Database mediante proveedores de tipos.

open System
open System.Data
open System.Data.Linq
open Microsoft.FSharp.Data.TypeProviders
open Microsoft.FSharp.Linq

[<Generate>]
type dbSchema = SqlDataConnection<"Data Source=MYSERVER\INSTANCE;Initial Catalog=MyDatabase;Integrated Security=SSPI;">

let db = dbSchema.GetDataContext()

query {
    for row in db.Table2 do
    where (row.TestData1.HasValue && row.TestData1.Value > 2)
    select row
} |> Seq.iter (fun row -> printfn $"%d{row.TestData1.Value} %s{row.Name}")

query {
    for row in db.Table2 do
    // Use a nullable operator ?>
    where (row.TestData1 ?> 2)
    select row
} |> Seq.iter (fun row -> printfn "%d{row.TestData1.GetValueOrDefault()} %s{row.Name}")

Consulte también