Funções de Conversão

As funções de conversão disponíveis estão listadas.


Função	Descrição
`Base64Decode(Arg1)`	Decodifica uma string de base64 em um grande objeto binário para que ele possa ser visto como uma imagem no Spotfire. Exemplo: `Base64Decode([Column])`
`Base64Encode(Arg1)`	Codifica um grande objeto binário como uma string base64. Isso pode ser do seu interesse caso os dados do Spotfire devam ser exportados para outros aplicativos. Exemplo: `Base64Encode([Column])`
`Boolean(Arg1)`	Converte a coluna ou o valor em um `Boolean`. Exemplo: `Boolean([Column])`
`Cast(Arg1 as type)`	Lança qualquer expressão para qualquer tipo (exceto nulo/indefinido). Valores inválidos são propagados. Lançamento realizado a diferentes tipos de tipos de entrada e de saída resulta em diferentes saídas. Veja Método Lançar para maiores informações. Exemplo: `Cast([IntegerColumn] as Currency)`
`Currency(Arg1)`	Converte a coluna ou o valor em uma `Currency`. Exemplo: `Currency([Column])`
`Date(Arg1, ..., Arg3)`	Converte a coluna ou o valor em uma `Date`. Se um único argumento for usado, `Arg1` poderá ser do tipo `String` ou `DateTime`. Se uma `String` for especificada, a data deverá ser escrita em um formato que o Spotfire reconheça. Além disso, todas as partes da data (ano, mês e dia) devem estar presentes. Consulte os exemplos abaixo. Se `DateTime` for especificado, a parte da hora será removida. Se três argumentos forem determinados, eles deverão ter valores `Integer`. O primeiro argumento é o ano, o segundo é o mês e o terceiro é o dia do mês. Se um único argumento `Integer` for determinado, a função `Date` interpretará `Integer` como marcas. As marcas são contadas com a unidade de 100 nanossegundos, começando na data 01-01-01 (primeiro de janeiro, ano um). Consulte também Funções de data e hora e Método Lançar. Exemplos: `Date("2003-03-21")` → 3/21/2003 `Date("3/21/03")` → 3/21/2003 `Date("10")` → (Vazio) `Date(null)` → (Vazio) `Date("2003-03-21 11:37:00")` → 3/21/2003 `Date(2003,03, 21)` → 3/21/2003 `Date(605000000000000000l)` → 3/4/1918 (Os formatos de saída disponíveis dependem da sua localidade atual.)
`DateTime(Arg1, Arg2,..., Arg7)`	Converte a coluna ou os valores em `DateTime`. Se um único argumento for usado, `Arg1` poderá ser do tipo `String` ou `Date`. Se uma `String` for especificada, a data deverá ser escrita em um formato que o Spotfire reconheça. Além disso, pelo menos todas as partes da data (ano, mês e dia) devem estar presentes. Se `Date` for especificado, a parte da hora será definida como 00:00:00 (12:00:00 AM). Se sete argumentos forem fornecidos, eles deverão ter valores `Integer`. O primeiro argumento é o ano, o segundo é o mês, o terceiro é o dia do mês, o quarto é a hora, o quinto é o minuto, o sexto é o segundo e o sétimo argumento é o milissegundo. Se um único argumento `Integer` for determinado, a função `DateTime` interpretará o inteiro como marcas. As marcas são contadas com a unidade de 100 nanossegundos, começando na data 01-01-01 (primeiro de janeiro, ano um). Consulte também Funções de data e hora e Método Lançar. Exemplos: `DateTime("2003-03-21 11:37:00")` → 3/21/2003 11:37:00 AM `DateTime("10")` → (Vazio) `DateTime(null)` → (Vazio) `DateTime("2003-03-21")` → 2003-03-21 00:00:00 `DateTime(2003, 03, 21, 11, 37, 00)` → 2003-03-21 11:37:00 `DateTime(605000000000000000l)` → 3/4/1918 11:33:20 AM (Os formatos de saída disponíveis dependem da sua localidade atual.)
`FirstValidAfter(Arg1)`	Substitui valores nulos em uma coluna pelo primeiro valor válido após o valor ausente. Exemplo: `FirstValidAfter([Column])`
`FromEpochMilliseconds(Arg1)`	Converte a coluna ou o valor em uma data/hora, em que os números são interpretados como o número de milissegundos que se passaram desde 1970-01-01. Exemplo: `FromEpochMilliseconds(231312)`
`FromEpochSeconds(Arg1)`	Converte a coluna ou o valor em uma data/hora, em que os números são interpretados como o número de segundos que se passaram desde 1970-01-01. Exemplo: `FromEpochSeconds(231312)`
`Integer(Arg1)`	Converte a coluna ou o valor em um número `Integer`. Se a conversão falhar, um erro é retornado. `Arg1` pode ser do tipo `Integer`, `Real` ou `String`, e o resultado é do tipo `Integer`. Números `Real` são truncados, ou seja, somente a parte inteira é utilizada. Exemplos: `Integer("-123")` → -123 `Integer(-2.99)` → -2 `Integer("0%")` → (Vazio) `Integer(1e20)` → (Vazio) `Integer(null)` → (Vazio)
`LastValidBefore(Arg1)`	Substitui valores nulos em uma coluna pelo último valor válido antes do valor ausente. Exemplo: `LastValidBefore([Column])`
`LongInteger(Arg1)`	Converte a coluna ou o valor em `LongInteger`. Exemplo: `LongInteger([Column])`
`ParseDate(Arg1, ..., Arg3)`	Analisa uma data a partir de uma string para um formato `Date`. O primeiro argumento é uma string ou uma coluna de string que contém uma data. O segundo argumento é uma string de formato, que explica como a data é criada, e o terceiro argumento (opcional) é um código de cultura. Exemplos: `ParseDate("2013-09-17", "yyyy-MM-dd")` `ParseDate("17-okt-2013","dd-MMM-yyyy","sv-SE")`
`ParseDateTime(Arg1, ..., Arg3)`	Analisa uma informação de data/hora a partir de uma string para um formato `DateTime`. O primeiro argumento é uma string ou uma coluna de string que contém uma informação de data/hora. O segundo argumento é uma string de formato, que explica como a data é criada, e o terceiro argumento (opcional) é um código de cultura. Exemplos: `ParseDateTime("2013-09-17 10:30", "yyyy-MM-dd h:mm")` `ParseDateTime("17-okt-2013 13:25","dd-MMM-yyyy HH:mm","sv-SE")`
`ParseReal(Arg1, Arg2)`	Analisa uma string para um valor `Real`. O primeiro argumento é uma string ou uma coluna de string. O segundo argumento (opcional) é um código de cultura. Exemplos: `ParseReal([Column], "en-US")` `ParseReal("7.25")`
`ParseTime(Arg1, ..., Arg3)`	Analisa uma hora a partir de uma string para um formato `Time`. O primeiro argumento é uma string ou uma coluna de string que contém uma hora. O segundo argumento é uma string de formato, que explica como a hora é criada, e o terceiro argumento (opcional) é um código de cultura. Exemplos: `ParseTime("9:25", "h:mm")` `ParseTime("17:30", "HH:mm","sv-SE")`
`ParseTimeSpan(Arg1, ..., Arg3)`	Analisa informações de extensão de tempo de uma string para um formato `TimeSpan`. O primeiro argumento é uma string ou uma coluna de string contendo informações de extensão de tempo. O segundo argumento é uma string de formato, que explicam como a data é criada, e o terceiro argumento (opcional) é um código de cultura. Exemplos: `ParseTimeSpan("5.7:11:3.1", "d.h:m:s.f", "sv-SE")` `ParseTimeSpan("123 3 11 7 -5", "f s m h d")`
`Real(Arg1)`	Converte a coluna ou o valor em um número `Real`. Se a conversão falhar, um erro é retornado. `Arg1` pode ser do tipo `Integer`, `Real` ou `String`, e o resultado é do tipo `Real`. Exemplos: `Real(1.23)` → 1.23 `Real(2)` → 2 `Real("0%")` → (Vazio) `Real(null)` → (Vazio)
`SingleReal(Arg1)`	Converte a coluna ou o valor em `SingleReal`. Exemplo: `SingleReal([Column])`
`SN(Arg1, Arg2)`	Substitui valores nulos. Retorna o `Arg1` se ele não é nulo, o `Arg2` de outra forma. `O Arg1` e o `Arg2` podem ser de qualquer tipo, mas todos precisam ser do mesmo tipo ou nulos. O resultado é do mesmo tipo que os argumentos. Um uso comum é substituir valores nulos em uma coluna. Se o `Arg1` é uma coluna, o `Arg2` pode ser um valor do mesmo tipo que o conteúdo da coluna ou uma coluna com o mesmo tipo de conteúdo. Se o `Arg2` for uma coluna, o erro no `Arg1` será substituído com o valor da mesma linha no `Arg2`. Exemplos: `SN(1, 2)` → 1 `SN(null, 2)` → 2 `SN(0/0, 2)` → #NA `SN([Column], 1)` → 1 (se valor nulo na coluna) `SN([Column1], [Column2])` → (valor de `Column2` se valor nulo em `Column1`)
`String(Arg1)`	Converte a coluna ou o valor em `String`. `Arg1` pode ser de qualquer tipo, e o resultado é do tipo string. Nota: Essa função sempre usa a formatação do valor padrão. Isso pode provocar perda de precisão ao converter valores numéricos. Exemplos: `String(1.23)` → "1.23" `String(null)` → (Vazio)
`Time(Arg1, Arg2,..., Arg4)`	Converte a coluna ou o valor em `Time`. Se a conversão falhar, um erro é retornado. Se um único argumento for usado, `Arg1` poderá ser do tipo `String` ou `DateTime`. Se `String` for especificado, a hora deverá ser escrita em um formato que o Spotfire reconheça. Além disso, tanto a hora e os minutos devem ser especificados. Consulte os exemplos abaixo. Se `DateTime` for especificado, a parte da data será removida. Se quatro argumentos forem especificados, eles deverão ser valores `Integer`. O primeiro argumento é a hora, o segundo é o minuto, o terceiro é o segundo e o quarto é o milissegundo. Se um único argumento `Integer` for especificado, a função `Time` interpretará o Inteiro como marcas. As marcas são contadas com a unidade de 100 nanossegundos, começando na data 01-01-01 (primeiro de janeiro, ano um). Consulte também Funções de data e hora e Método Lançar. Exemplos: `Time("11:37:00")` → 11:37:00 `Time("10")` → (Vazio) `Time(null)` → (Vazio) `Time(11, 30, 20, 4)` → 11:30:20 `Time(605000000000000000l)` → 11:33:20 AM (Os formatos de saída disponíveis dependem da sua localidade atual.)
`TimeSpan(Arg1, Arg2,...,Arg5))`	Cria um `TimeSpan` a partir de uma coluna ou valores. Se um único argumento for fornecido, a coluna de entrada poderá ser do tipo `String`, `TimeSpan` ou `Integer`. Se `String` for especificado, o intervalo deverá ser escrito no formato "[-]d.h:m:s.ms". Se cinco argumentos são dados, então o primeiro argumento são os dias, o segundo são as horas, o terceiro são os minutos, o quarto são os segundos e o quinto são os milissegundos. Os primeiros quatro argumentos são do tipo `Integer`, o último é um número `Real`. Se um único argumento Integer for fornecido, o `TimeSpan` interpretará o `Integer` como marcações. As marcações são contadas com a unidade de 100 nanossegundos. Isso significa que o `TimeSpan` será produzido como frações de segundos usando décimos de microssegundos (marcações), 7 casas decimais, como base. Se for fornecido 10.000, o `TimeSpan` será 0.0:0:0.001. Exemplos: `TimeSpan([Column])` `TimeSpan("247.5:17:11.5002")` `TimeSpan(247, 05, 17, 11, 500.2)`
`ToEpochMilliseconds([Arg1])`	Converte a coluna ou o valor de data/hora em um número que representa o número de milissegundos que se passaram desde 1970-01-01. Exemplo: `ToEpochMilliseconds([Date])`
`ToEpochSeconds([Arg1])`	Converte a coluna ou o valor de data/hora em um número que representa o número de segundos que se passaram desde 1970-01-01. Exemplo: `ToEpochSeconds([Date])`

Para obter uma lista dos tipos de dados disponíveis para a conversão, veja Tipos de dados.

Veja tambémFunções.