Partager via

Opérateurs pouvant accepter la valeur Null dans les requêtes

  • Article

Les opérateurs pouvant accepter la valeur Null sont des opérateurs de comparaison ou arithmétiques binaires qui fonctionnent avec des types arithmétiques pouvant accepter la valeur Null d’un côté ou des deux. Les types Nullables se produisent lorsque vous utilisez des données provenant de sources telles que des bases de données qui autorisent la valeur Null à la place de valeurs réelles. Les opérateurs pouvant accepter la valeur Null sont utilisés dans les expressions de requête. En plus des opérateurs pouvant accepter la valeur Null pour l’arithmétique et la comparaison, les opérateurs de conversion peuvent être utilisés pour réaliser des conversions entre différents types Nullables. Certains opérateurs de requête ont aussi des versions pouvant accepter la valeur Null.

Notes

En général, les opérateurs pouvant accepter la valeur Null sont utilisés uniquement dans les expressions de requête. Si vous n’utilisez pas d’expressions de requête, vous n’avez pas besoin de connaître ou d’utiliser ces opérateurs.

Tableau des opérateurs pouvant accepter la valeur Null

Le tableau suivant répertorie les opérateurs pouvant accepter la valeur Null pris en charge dans F#.

Pouvant accepter la valeur Null à gauche Pouvant accepter la valeur Null à droite Pouvant accepter la valeur Null des deux côtés
?>= >=? ?>=?
?> >? ?>?
?<= <=? ?<=?
?< <? ?<?
?= =? ?=?
?<> <>? ?<>?
?+ +? ?+?
?- -? ?-?
?* *? ?*?
?/ /? ?/?
?% %? ?%?

Notes

Les opérateurs pouvant accepter la valeur Null sont inclus dans le module NullableOperators de l’espace de noms FSharp.Linq. Le type des données pouvant accepter la valeur Null est System.Nullable<'T>.

Dans les expressions de requête, les types Nullables se produisent lors de la sélection de données à partir d’une source de données qui autorise la valeur Null au lieu de valeurs. Dans une base de données SQL Server, chaque colonne de données d’une table a un attribut qui indique si les valeurs Null sont autorisées. Si les valeurs Null sont autorisées, les données retournées par la base de données peuvent contenir des valeurs Null qui ne peuvent pas être représentées par un type de données primitif tel que int ou float, par exemple. Par conséquent, les données sont retournées en tant que System.Nullable<int> au lieu de int, et System.Nullable<float> au lieu de float. La valeur réelle peut être obtenue à partir d’un objet System.Nullable<'T> à l’aide de la propriété Value, et vous pouvez déterminer si un objet System.Nullable<'T> a une valeur en appelant la méthode HasValue. Une autre méthode utile est la méthode System.Nullable<'T>.GetValueOrDefault, qui vous permet d’obtenir la valeur ou une valeur par défaut du type approprié. La valeur par défaut est une forme de valeur « zéro », par exemple 0, 0.0 ou false.

Les types Nullables peuvent être convertis en types primitifs non Nullables à l’aide des opérateurs de conversion habituels tels que int ou float. Il est également possible de convertir d’un type Nullable vers un autre type Nullable à l’aide des opérateurs de conversion pour les types Nullables. Les opérateurs de conversion appropriés ont le même nom que les opérateurs standard, mais ils se trouvent dans un module distinct, à savoir le module Nullable dans l’espace de noms FSharp.Linq. En règle générale, vous ouvrez cet espace de noms lorsque vous utilisez des expressions de requête. Dans ce cas, vous pouvez utiliser les opérateurs de conversion Nullables en ajoutant le préfixe Nullable. à l’opérateur de conversion approprié, comme indiqué dans le code suivant.

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 sortie est 10.000000.

Il existe également des opérateurs de requête sur les champs de données Nullables, tels que sumByNullable, pour une utilisation dans les expressions de requête. Les opérateurs de requête pour les types non Nullables ne sont pas compatibles avec les types Nullables. Vous devez donc utiliser la version Nullable de l’opérateur de requête approprié lorsque vous travaillez avec des valeurs de données pouvant accepter la valeur Null. Pour plus d’informations, consultez Expressions de requête.

L’exemple suivant montre l’utilisation d’opérateurs pouvant accepter la valeur Null dans une expression de requête F#. La première requête montre comment écrire une requête sans opérateur pouvant accepter la valeur Null ; la deuxième requête montre une requête équivalente qui utilise un opérateur pouvant accepter la valeur Null. Pour connaître le contexte complet, y compris la configuration de la base de données pour utiliser cet exemple de code, consultez Procédure pas à pas : accès à une base de données SQL Database à l’aide des fournisseurs de type.

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}")

Voir aussi