Operadores que aceptan valores NULL en consultas

Los operadores que aceptan valores NULL son operadores aritméticos binarios o de comparación que funcionan con tipos aritméticos que aceptan valores NULL en uno o ambos lados. Los tipos que aceptan 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 aceptan valores NULL se usan en expresiones de consulta. Además de los operadores que aceptan valores NULL para la comparación y aritmética, los operadores de conversión se pueden usar para convertir entre tipos que aceptan valores NULL. También hay versiones que aceptan valores NULL de determinados operadores de consulta.

Nota:

Por lo general, los operadores que aceptan 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 aceptan valores NULL

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

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

Observaciones

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

En las expresiones de consulta, surgen tipos que aceptan valores NULL al seleccionar datos de un origen de datos que permite valores NULL en lugar de valores . En una base de datos de SQL Server, cada columna de datos de una tabla tiene un atributo que indica si se permiten valores NULL. Si se permiten 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 en System.Nullable<int> lugar de inty System.Nullable<float> en lugar de float. El valor real se puede obtener de un System.Nullable<'T> objeto mediante la Value propiedad y puede determinar si un System.Nullable<'T> objeto tiene un valor llamando al HasValue método . Otro método útil es el System.Nullable<'T>.GetValueOrDefault método , que permite obtener el valor o un valor predeterminado del tipo adecuado. El valor predeterminado es algún tipo 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 acepta valores NULL a otro tipo que acepta valores NULL mediante los operadores de conversión para tipos que aceptan 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 acepta 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 aceptan 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 aceptan valores NULL, como sumByNullable, también existen para su uso en expresiones de consulta. Los operadores de consulta para tipos que no aceptan valores NULL no son compatibles con tipos que aceptan valores NULL, por lo que debe usar la versión que acepta valores NULL del operador de consulta adecuado cuando se trabaja con valores de datos que aceptan valores NULL. Para obtener más información, vea Expresiones de consulta.

En el ejemplo siguiente se muestra el uso de operadores que aceptan valores NULL en una expresión de consulta de F#. La primera consulta muestra cómo escribiría una consulta sin un operador que acepta valores NULL; la segunda consulta muestra una consulta equivalente que usa un operador que acepta valores NULL. Para obtener el contexto completo, incluido cómo configurar la base de datos para usar este código de ejemplo, consulte Tutorial: Acceso a una base de datos SQL 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

• Proveedores de tipos
• Expresiones de consulta