Funzioni di conversione

Vengono elencate le funzioni di conversione disponibili.


Funzione	Descrizione
`Base64Decode(Arg1)`	Decodifica una stringa base64 in un oggetto binary grande per consentirne la visualizzazione come immagine in Spotfire. Esempio: `Base64Decode([Column])`
`Base64Encode(Arg1)`	Codifica un oggetto binary grande come stringa base64. Questa funzione può essere utile se si desidera esportare i dati di Spotfire in altre applicazioni. Esempio: `Base64Encode([Column])`
`Boolean(Arg1)`	Converte la colonna o un valore in un valore `Boolean`. Esempio: `Boolean([Column])`
`Cast(Arg1 as type)`	Esegue il cast di un'espressione convertendola in qualsiasi tipo (tranne Null/Non definito). I valori non validi vengono propagati. Il casting eseguito per i vari tipi di input e di output porta a diversi output. Per ulteriori informazioni, vedere il Metodo di cast. Esempio: `Cast([IntegerColumn] as Currency)`
`Currency(Arg1)`	Converte la colonna o il valore in un valore `Currency`. Esempio: `Currency([Column])`
`Date(Arg1, ..., Arg3)`	Converte la colonna o i valori in un valore `Date`. Se viene fornito un singolo argomento, `Arg1` può essere di tipo `String` o `DateTime`. Se viene specificato un valore `String`, la data deve essere scritta in un formato riconoscibile da Spotfire. Inoltre, devono essere presenti tutte le parti di una data (anno, mese e giorno). Vedere gli esempi seguenti. Se viene specificato un valore `DateTime`, la parte di ora viene rimossa. Se vengono forniti tre argomenti, devono essere valori `Integer`. Se il primo argomento è l'anno, il secondo il mese e il terzo il giorno del mese. Se viene fornito un solo argomento `Integer`, la funzione `Date` interpreterà il valore `Integer` come tick. I tick vengono conteggiati in base all'unità di 100 nanosecondi, a partire dalla data 01-01-01 (primo gennaio dell'anno uno). Vedere anche Funzioni data e ora e Metodo di cast. Esempi: `Date("2003-03-21")` → 3/21/2003 `Date("3/21/03")` → 3/21/2003 `Date("10")` → (Vuoto) `Date(null)` → (Vuoto) `Date("2003-03-21 11:37:00")` → 3/21/2003 `Date(2003,03, 21)` → 3/21/2003 `Date(605000000000000000l)` → 3/4/1918 (I formati di output disponibili dipendono dalle impostazioni locali correnti).
`DateTime(Arg1, Arg2,..., Arg7)`	Converte la colonna o i valori in un `DateTime`. Se viene fornito un singolo argomento, `Arg1` può essere di tipo `String` o `Date`. Se viene specificato un valore `String`, la data deve essere scritta in un formato riconoscibile da Spotfire. Inoltre, devono essere presenti almeno tutte le parti di una data (anno, mese e giorno). Se viene specificato un valore `Date`, la parte di ora è impostata su 00:00:00 (12:00:00 AM). Se vengono forniti sette argomenti, devono essere valori `Integer`. Il primo argomento è l'anno, il secondo il mese, il terzo il giorno del mese, il quarto l'ora, il quinto i minuti, il sesto i secondi e il settimo i millisecondi. Se viene fornito un solo argomento `Integer`, la funzione `DateTime` interpreterà il valore Integer come tick. I tick vengono conteggiati in base all'unità di 100 nanosecondi, a partire dalla data 01-01-01 (primo gennaio dell'anno uno). Vedere anche Funzioni data e ora e Metodo di cast. Esempi: `DateTime("2003-03-21 11:37:00")` → 3/21/2003 11:37:00 AM `DateTime("10")` → (Vuoto) `DateTime(null)` → (Vuoto) `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 (I formati di output disponibili dipendono dalle impostazioni locali correnti).
`FirstValidAfter(Arg1)`	Sostituisce i valori null di una colonna con il primo valore valido dopo il valore mancante. Esempio: `FirstValidAfter([Column])`
`FromEpochMilliseconds(Arg1)`	Converte la colonna o il valore in un DateTime, in cui i valori sono interpretati come numero di millisecondi trascorsi a partire dal 01/01/1970. Esempio: `FromEpochMilliseconds(231312)`
`FromEpochSeconds(Arg1)`	Converte la colonna o il valore in un DateTime, in cui i valori sono interpretati come numero di secondi trascorsi a partire dal 01/01/1970. Esempio: `FromEpochSeconds(231312)`
`Integer(Arg1)`	Converte la colonna o il valore in un `Integer`. Se la conversione fallisce, viene restituito un errore. `Arg1` può essere di tipo `Integer`, `Real` o `String` e il risultato è di tipo `Integer`. I numeri `Real` vengono troncati, ovvero viene utilizzata solo la parte di Integer. Esempi: `Integer("-123")` → -123 `Integer(-2.99)` → -2 `Integer("0%")` → (Vuoto) `Integer(1e20)` → (Vuoto) `Integer(null)` → (Vuoto)
`LastValidBefore(Arg1)`	Sostituisce i valori null di una colonna con l'ultimo valore valido prima del valore mancante. Esempio: `LastValidBefore([Column])`
`LongInteger(Arg1)`	Converte la colonna o il valore in un `LongInteger`. Esempio: `LongInteger([Column])`
`ParseDate(Arg1, ..., Arg3)`	Analizza una data da una stringa in un formato `Date`. Il primo argomento è una stringa o una colonna stringa contenente una data. Il secondo argomento è una stringa formato che spiega come è composta la data e il terzo argomento (opzionale) è un codice culturale. Esempi: `ParseDate("2013-09-17", "yyyy-MM-dd")` `ParseDate("17-okt-2013","dd-MMM-yyyy","sv-SE")`
`ParseDateTime(Arg1, ..., Arg3)`	Analizza informazioni data/ora da una stringa in un formato `DateTime`. Il primo argomento è una stringa o una colonna stringa contenente informazioni su data/ora. Il secondo argomento è una stringa formato che spiega come è composta l'informazione e il terzo argomento (opzionale) è un codice culturale. Esempi: `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)`	Analizza una stringa in un valore `Real`. Il primo argomento è una stringa o una colonna stringa. Il secondo argomento (opzionale) è un codice culturale. Esempi: `ParseReal([Column], "en-US")` `ParseReal("7.25")`
`ParseTime(Arg1, ..., Arg3)`	Analizza un orario da una stringa in un formato `Time`. Il primo argomento è una stringa o una colonna stringa contenente un orario. Il secondo argomento è una stringa formato che spiega come è composta l'ora e il terzo argomento (opzionale) è un codice culturale. Esempi: `ParseTime("9:25", "h:mm")` `ParseTime("17:30", "HH:mm","sv-SE")`
`ParseTimeSpan(Arg1, ..., Arg3)`	Analizza le informazioni TimeSpan da una stringa in un formato `TimeSpan`. Il primo argomento è una stringa o una colonna stringa contenente una informazione TimeSpan. Il secondo argomento è una stringa formato che spiega come è composta l'informazione e il terzo argomento (opzionale) è un codice culturale. Esempi: `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 la colonna o il valore in un numero `Real`. Se la conversione fallisce, viene restituito un errore. `Arg1` può essere di tipo `Integer`, `Real` o `String` e il risultato è di tipo `Real`. Esempi: `Real(1.23)` → 1.23 `Real(2)` → 2 `Real("0%")` → (Vuoto) `Real(null)` → (Vuoto)
`SingleReal(Arg1)`	Converte la colonna o il valore in un `SingleReal`. Esempio: `SingleReal([Column])`
`SN(Arg1, Arg2)`	Sostituisce i valori null. Restituisce `Arg1` se non è null, altrimenti `Arg2`. `Arg1` e `Arg2` possono essere di qualsiasi tipo, ma entrambi devono essere dello stesso tipo o null. Il risultato è dello stesso tipo degli argomenti. Di norma, si usa per sostituire i valori null in una colonna. Se `Arg1` è una colonna, `Arg2` può essere un valore dello stesso tipo dei contenuti della colonna o una colonna con lo stesso tipo di contenuto. Se anche `Arg2` è una colonna, l'errore di `Arg1` verrà sostituito con il valore della stessa riga in `Arg2`. Esempi: `SN(1, 2)` → 1 `SN(null, 2)` → 2 `SN(0/0, 2)` → #NA `SN([Column], 1)` → 1 (se valore null nella colonna) `SN([Column1], [Column2])` → (valore di `Column2` se in `Column1` c'è valore null)
`String(Arg1)`	Converte la colonna o il valore in una `String`. `Arg1` può essere di qualsiasi tipo e il risultato è di tipo String. Nota: Questa funzione utilizza sempre la formattazione del valore predefinita. Ciò potrebbe comportare una perdita di precisione nella conversione di valori numerici. Esempi: `String(1.23)` → "1.23" `String(null)` → (Vuoto)
`Time(Arg1, Arg2,..., Arg4)`	Converte la colonna o i valori in un valore `Time`. Se la conversione fallisce, viene restituito un errore. Se viene fornito un singolo argomento, `Arg1` può essere di tipo `String` o `DateTime`. Se viene specificato un valore `String`, l'ora deve essere scritta in un formato riconoscibile da Spotfire. Inoltre, devono essere specificati sia l'ora che i minuti. Vedere gli esempi seguenti. Se viene specificato un valore `DateTime`, la parte di data viene rimossa. Se vengono forniti quattro argomenti, devono essere valori `Integer`. Se il primo argomento è l'ora, il secondo i minuti, il terzo i secondi e il quarto i millisecondi. Se viene fornito un solo argomento `Integer`, la funzione `Time` interpreterà il valore Integer come tick. I tick vengono conteggiati in base all'unità di 100 nanosecondi, a partire dalla data 01-01-01 (primo gennaio dell'anno uno). Vedere anche Funzioni data e ora e Metodo di cast. Esempi: `Time("11:37:00")` → 11:37:00 `Time("10")` → (Vuoto) `Time(null)` → (Vuoto) `Time(11, 30, 20, 4)` → 11:30:20 `Time(605000000000000000l)` → 11:33:20 AM (I formati di output disponibili dipendono dalle impostazioni locali correnti).
`TimeSpan(Arg1, Arg2,...,Arg5))`	Crea un `TimeSpan` da una colonna o dai valori. Se viene fornito un singolo argomento, la colonna di input può essere di tipo `String`, `TimeSpan` o `Integer`. Se viene specificato `String`, il TimeSpan deve essere scritto nel formato "[-]d.h:m:s.ms". Se vengono forniti cinque argomenti, il primo argomento sono i giorni, il secondo le ore, il terzo i minuti, il quarto i secondi e il quinto i millisecondi. I primi quattro argomenti sono `Integer`, l'ultimo è un numero `Real`. Se viene fornito un solo argomento Integer, `TimeSpan` interpreterà il valore `Integer` come tick. I tick vengono contati con unità di 100 nanosecondi. Ciò significa che il `TimeSpan` verrà prodotto in frazioni di secondo utilizzando i decimi di microsecondo (tick), 7 decimali, come base. Se viene fornito 10000, `TimeSpan` sarà 0.0:0:0.001. Esempi: `TimeSpan([Column])` `TimeSpan("247.5:17:11.5002")` `TimeSpan(247, 05, 17, 11, 500.2)`
`ToEpochMilliseconds([Arg1])`	Converte la colonna o il valore da un DateTime a un numero che rappresenta il numero di millisecondi trascorsi a partire dal 01/01/1970. Esempio: `ToEpochMilliseconds([Date])`
`ToEpochSeconds([Arg1])`	Converte la colonna o il valore da un DateTime a un numero che rappresenta il numero di secondi trascorsi a partire dal 01/01/1970. Esempio: `ToEpochSeconds([Date])`

Per un elenco dei tipi di dati disponibili per la conversione, vedere Tipi di dati.

Vedere anche Funzioni.