Operadores anuláveis em consultas

Operadores anuláveis são operadores aritméticos binários ou de comparação que trabalham com tipos aritméticos anuláveis em um ou ambos os lados. Tipos anuláveis surgem quando você trabalha com dados de fontes como bancos de dados que permitem nulos no lugar de valores reais. Operadores anuláveis são usados em expressões de consulta. Além de serem operadores anuláveis para aritmética e comparação, os operadores de conversão podem ser usados para converter entre tipos anuláveis. Também há versões anuláveis de determinados operadores de consulta.

Tabela de operadores anuláveis

A tabela a seguir lista operadores anuláveis com suporte em F#.

Comentários

Os operadores anuláveis estão incluídos no módulo NullableOperators no namespace FSharp.Linq. O tipo para dados anuláveis é System.Nullable<'T>.

Em expressões de consulta, tipos anuláveis surgem ao selecionar dados de uma fonte de dados que permite nulos em vez de valores. Em um banco de dados SQL Server, cada coluna de dados em uma tabela tem um atributo que indica se os nulos são permitidos. Se forem permitidos nulos, os dados retornados do banco de dados poderão conter nulos que não podem ser representados por um tipo de dados primitivo como int, float e assim por diante. Portanto, os dados são retornados como System.Nullable<int> em vez de int, e System.Nullable<float> em vez de float. O valor real pode ser obtido de um objeto System.Nullable<'T> usando a propriedade Value, e você pode determinar se um objeto System.Nullable<'T> tem um valor chamando o método HasValue. Outro método útil é o método System.Nullable<'T>.GetValueOrDefault, que permite obter o valor ou um valor padrão do tipo apropriado. O valor padrão é uma forma de valor "zero", como 0, 0,0 ou false.

Tipos anuláveis podem ser convertidos em tipos primitivos não anuláveis usando os operadores de conversão usuais, como int ou float. Também é possível converter de um tipo anulável para outro tipo anulável usando os operadores de conversão para tipos anuláveis. Os operadores de conversão apropriados têm o mesmo nome dos operadores padrão, mas estão em um módulo separado, o módulo Nullable no namespace FSharp.Linq. Normalmente, você abre esse namespace ao trabalhar com expressões de consulta. Nesse caso, você pode usar os operadores de conversão anuláveis adicionando o prefixo Nullable. ao operador de conversão apropriado, conforme mostrado no código a seguir.

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

A saída é 10.000000.

Operadores de consulta em campos de dados anuláveis, como sumByNullable, também estão disponíveis para uso em expressões de consulta. Os operadores de consulta para tipos não anuláveis não são compatíveis com tipos anuláveis. Portanto, você deve usar a versão anulável do operador de consulta apropriado quando estiver trabalhando com valores de dados anuláveis. Para obter mais informações, consulte Expressões de consulta.

O exemplo a seguir mostra o uso de operadores anuláveis em uma expressão de consulta F#. A primeira consulta mostra como você escreveria uma consulta sem um operador anulável; a segunda consulta mostra uma consulta equivalente que usa um operador anulável. Para obter o contexto completo, incluindo como configurar o banco de dados para usar esse código de exemplo, consulte Passo a passo: acessar um Banco de Dados SQL usando provedores de tipo.

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

Confira também

• Provedores de tipos
• Expressões de Consulta