Caricare i dati dai file nel cloud

Crea credenziali

Scopri come memorizzare le credenziali dello storage degli oggetti cloud utilizzando la procedura DBMS_CLOUD.CREATE_CREDENTIAL.

Eseguire la procedura DBMS_CLOUD.CREATE_CREDENTIAL utilizzando qualsiasi strumento di database, ad esempio SQL*Plus, SQL Developer o Database Actions (strumento SQL Developer basato su Web). Ad esempio:

BEGIN
  DBMS_CLOUD.CREATE_CREDENTIAL(
    credential_name => 'DEF_CRED_NAME',
    username => 'adb_user@oracle.com',
    password => 'password'
  );
END;
/

I valori forniti per username e password dipendono dal servizio di storage degli oggetti cloud che si sta utilizzando:

Oracle Cloud Infrastructure Object Storage: username è il nome utente di Oracle Cloud Infrastructure e password è il token di autenticazione di Oracle Cloud Infrastructure. Vedere Utilizzo dei token di autenticazione.
Oracle Cloud Infrastructure Object Storage Classic: username è il tuo nome utente Oracle Cloud Infrastructure Classic e password è la tua password Oracle Cloud Infrastructure Classic.

Questa operazione memorizza le credenziali nel database in formato cifrato. È possibile utilizzare qualsiasi nome per il nome della credenziale. Tenere presente che questo passo è necessario una sola volta a meno che le credenziali dell'area di memorizzazione degli oggetti non vengano modificate. Dopo aver memorizzato le credenziali, è possibile utilizzare lo stesso nome di credenziale per tutti i caricamenti dati.

Carica dati da file di testo

Scopri come caricare i dati dai file di testo nel cloud in Autonomous Database utilizzando la procedura DBMS_CLOUD.COPY_DATA.

Il file di origine in questo esempio, channels.txt, contiene i seguenti dati:

S,Direct Sales,Direct
T,Tele Sales,Direct
C,Catalog,Indirect
I,Internet,Indirect
P,Partners,Others

Memorizzare le credenziali dello storage degli oggetti cloud utilizzando la procedura DBMS_CREDENTIAL.CREATE_CREDENTIAL. Vedere Crea credenziali per ulteriori dettagli.

Creare la tabella che conterrà i dati. Ad esempio:

CREATE TABLE CHANNELS
   (channel_id CHAR(1),
    channel_desc VARCHAR2(20),
    channel_class VARCHAR2(20)
   );
/

Caricare i dati nella tabella utilizzando la procedura DBMS_CLOUD.COPY_DATA. Ad esempio:
```
BEGIN
 DBMS_CLOUD.COPY_DATA(
    table_name =>'CHANNELS',
    credential_name =>'DEF_CRED_NAME',
    file_uri_list =>'https://swiftobjectstorage.us-phoenix-1.oraclecloud.com/v1/idthydc0kinr/mybucket/channels.txt',
    format => json_object('delimiter' value ',')
 );
END;
/
```
Di seguito sono riportati i parametri disponibili.
- table_name: è il nome della tabella di destinazione.
- credential_name: è il nome della credenziale creata nel passo precedente.
- file_uri_list: è una lista delimitata da virgole dei file di origine che si desidera caricare.
  
  In questo esempio, file_uri_list è un URI Swift di Oracle Cloud Infrastructure che specifica il file channels.txt nel bucket mybucket nell'area us-phoenix-1. (idthydc0kinr è lo spazio di nomi dello storage degli oggetti in cui risiede il bucket). Per informazioni sui formati URI supportati, vedere Formati URI di storage degli oggetti cloud.
- format: definisce le opzioni specificate per descrivere il formato del file di origine. Per informazioni sulle opzioni di formato che è possibile specificare, vedere Parametro formato.
Per ulteriori informazioni, vedere Procedura COPY_DATA.

Carica un file JSON di documenti delimitati in una raccolta

Scopri come caricare un file JSON di documenti delimitati in una raccolta in Autonomous Database utilizzando la procedura DBMS_CLOUD.COPY_DATA.

In questo esempio vengono caricati i valori JSON da un file delimitato da righe e viene utilizzato il file JSON myCollection.json. Ogni valore, ogni riga, viene caricato in una raccolta in Autonomous Database come singolo documento.

Ecco un esempio di tale file. Ha tre linee, con un oggetto per riga. Ciascuno di questi oggetti viene caricato come documento JSON separato.

{ "name" : "apple", "count": 20 }
{ "name" : "orange", "count": 42 }
{ "name" : "pear", "count": 10 }

Procedura:

Memorizzare le credenziali dello storage degli oggetti cloud utilizzando la procedura DBMS_CLOUD.CREATE_CREDENTIAL. Vedere Crea credenziali per ulteriori dettagli.
Caricare i dati in una raccolta utilizzando la procedura DBMS_CLOUD.COPY_DATA. Ad esempio:
```
BEGIN 
  DBMS_CLOUD.COPY_COLLECTION(
    collection_name =>'fruit',
    credential_name =>'DEF_CRED_NAME',
    file_uri_list =>'https://objectstorage.us-ashburn-1.oraclecloud.com/n/namespace-string/b/fruit_bucket/o/myCollection.json',
    format => json_object('recorddelimiter' value '''\n''')
 );
END;
/
```
Di seguito sono riportati i parametri disponibili.
- collection_name: è il nome della raccolta di destinazione.
- credential_name: è il nome della credenziale creata nel passo precedente.
- file_uri_list: è una lista delimitata da virgole dei file di origine che si desidera caricare.
  
  In questo esempio, file_uri_list è un URI Swift di Oracle Cloud Infrastructure che specifica il file myCollection.json nel bucket mybucket nell'area us-phoenix-1. Per informazioni sui formati URI supportati, vedere Formati URI di storage degli oggetti cloud.
- format: definisce le opzioni specificate per descrivere il formato del file di origine. Le opzioni di formato characterset, compression, ignoreblanklines, jsonpath, maxdocsize, recorddelimiter, rejectlimit, unpackarray sono supportate per il caricamento dei dati JSON. Eventuali altri formati specificati genereranno un errore. Per informazioni sulle opzioni di formato che è possibile specificare, vedere Parametro formato.
Per ulteriori informazioni, vedere COPY_COLLECTION Procedura.

Caricare un array di documenti JSON in una raccolta

Scopri come caricare un array di documenti JSON in una raccolta in Autonomous Database utilizzando la procedura DBMS_CLOUD.COPY_COLLECTION.

In questo esempio viene utilizzato il file JSON fruit_array.json. Di seguito viene mostrato il contenuto del file fruit_array.json:

[{"name" : "apple", "count": 20 },
 {"name" : "orange", "count": 42 },
 {"name" : "pear", "count": 10 }]

Procedura:

Memorizzare le credenziali dello storage degli oggetti cloud utilizzando la procedura DBMS_CLOUD.CREATE_CREDENTIAL. Vedere Crea credenziali per ulteriori dettagli.
Caricare i dati in una raccolta utilizzando la procedura DBMS_CLOUD.COPY_DATA. Ad esempio:
```
BEGIN 
  DBMS_CLOUD.COPY_COLLECTION(    
    collection_name => 'fruits',    
    credential_name => 'DEF_CRED_NAME',    
    file_uri_list => 'https://objectstorage.us-ashburn-1.oraclecloud.com/n/namespace-string/b/json/o/fruit_array.json',
    format => '{"recorddelimiter" : "0x''01''", "unpackarrays" : "TRUE", "maxdocsize" : "10240000"}'
  );
END;
/
```
In questo esempio viene caricato un singolo valore JSON che occupa l'intero file. Pertanto, non è necessario specificare un delimitatore di record. Per indicare che non esiste un delimitatore di record, è possibile utilizzare un carattere che non si verifica nel file di input. Ad esempio, è possibile utilizzare il valore "0x''01''" perché questo carattere non si trova direttamente nel testo JSON.

Quando il parametro unpackarrays per il valore del formato è impostato su TRUE, l'array di documenti viene caricato come singoli documenti anziché come un intero array. La decompressione degli elementi di array è tuttavia limitata a un singolo livello. Se nei documenti sono presenti array nidificati, tali array non vengono decompressi.

Di seguito sono riportati i parametri disponibili.
- collection_name: è il nome della raccolta di destinazione.
- credential_name: è il nome della credenziale creata nel passo precedente.
- file_uri_list: è una lista delimitata da virgole dei file di origine che si desidera caricare.
  
  In questo esempio, file_uri_list è un URI Swift di Oracle Cloud Infrastructure che specifica il file myCollection.json nel bucket mybucket nell'area us-phoenix-1. Per informazioni sui formati URI supportati, vedere Formati URI di storage degli oggetti cloud.
- format: definisce le opzioni specificate per descrivere il formato del file di origine. Le opzioni di formato characterset, compression, ignoreblanklines, jsonpath, maxdocsize, recorddelimiter, rejectlimit, unpackarray sono supportate per il caricamento dei dati JSON. Eventuali altri formati specificati genereranno un errore. Per informazioni sulle opzioni di formato che è possibile specificare, vedere Parametro formato.
Il caricamento di fruit_array.json con DBMS_CLOUD.COPY_COLLECTION mediante l'opzione di formato unpackarrays consente alla procedura di riconoscere i valori di array nell'origine. Pertanto, invece di caricare i dati come un singolo documento, come per impostazione predefinita, i dati vengono caricati nella raccolta fruits con ogni valore nell'array come un singolo documento.

Per ulteriori informazioni, vedere COPY_COLLECTION Procedura.

Copia dati JSON in una tabella esistente

Utilizzare DBMS_CLOUD.COPY_DATA per caricare i dati JSON nel cloud in una tabella.

Il file di origine in questo esempio è un file di dati JSON.

Memorizzare le credenziali dell'area di memorizzazione degli oggetti utilizzando la procedura DBMS_CLOUD.CREATE_CREDENTIAL. Ad esempio:
```
SET DEFINE OFF
BEGIN
  DBMS_CLOUD.CREATE_CREDENTIAL(
    credential_name => 'DEF_CRED_NAME',
    username => 'adb_user@example.com',
    password => 'password'
  );
END;
/
```
Questa operazione memorizza le credenziali nel database in formato cifrato. È possibile utilizzare qualsiasi nome per il nome della credenziale. Tenere presente che questo passo è necessario una sola volta a meno che le credenziali dell'area di memorizzazione degli oggetti non vengano modificate. Dopo aver memorizzato le credenziali, è possibile utilizzare lo stesso nome di credenziale per tutti i caricamenti dati.

Per informazioni dettagliate sui parametri, vedere CREATE_CREDENTIAL Procedura.
Caricare i dati JSON in una tabella esistente utilizzando la procedura DBMS_CLOUD.COPY_DATA.
Ad esempio:
```
CREATE TABLE WEATHER2
    (WEATHER_STATION_ID VARCHAR2(20),
     WEATHER_STATION_NAME VARCHAR2(50));
/ 

BEGIN 
  DBMS_CLOUD.COPY_DATA(
      table_name      => 'WEATHER2',
      credential_name => 'DEF_CRED_NAME',
      file_uri_list   => 'https://objectstorage.us-phoenix-1.oraclecloud.com/n/namespace-string/b/bucketname/o/jsonfiles*',
      format          =>  JSON_OBJECT('type' value 'json', 'columnpath' value '["$.WEATHER_STATION_ID",
          "$.WEATHER_STATION_NAME"]')
    );
END;
/ 
```
Di seguito sono riportati i parametri disponibili.
- table_name: è il nome della tabella di destinazione.
- credential_name: è il nome della credenziale creata nel passo precedente.
- file_uri_list: è una lista delimitata da virgole dei file di origine che si desidera caricare. È possibile utilizzare caratteri jolly nei nomi file negli URI. Il carattere "*" può essere utilizzato come carattere jolly per più caratteri, il carattere "?" può essere utilizzato come carattere jolly per un singolo carattere.
- format: per DBMS_CLOUD.COPY_DATA con dati JSON, il valore type è json. Specificare altri valori di formato per definire le opzioni per descrivere il formato del file di origine JSON. Per ulteriori informazioni, vedere DBMS_CLOUD Opzioni formato pacchetto.
In questo esempio, namespace-string è lo spazio di nomi dello storage degli oggetti Oracle Cloud Infrastructure e bucketname è il nome del bucket. Per ulteriori informazioni, vedere Informazioni sugli spazi di nomi dello storage degli oggetti.

Per informazioni dettagliate sui parametri, vedere COPY_DATA Procedura.

Monitorare e risolvere i problemi relativi al caricamento dei dati

Tutte le operazioni di caricamento dati eseguite utilizzando il package PL/SQL DBMS_CLOUD vengono registrate nelle tabelle dba_load_operations e user_load_operations:

dba_load_operations: mostra tutte le operazioni di caricamento.
user_load_operations: mostra le operazioni di caricamento nello schema.

Eseguire una query su queste tabelle per visualizzare informazioni sui caricamenti dati in corso e completati. Ad esempio, utilizzando un'istruzione SELECT con un predicato di clausola WHERE nella colonna TYPE, vengono visualizzate le operazioni di caricamento di tipo COPY.


SELECT table_name, owner_name, type, status, start_time, update_time, logfile_table, badfile_table 
   FROM user_load_operations WHERE type = 'COPY';

TABLE_NAME OWNER_NAME  TYPE   STATUS     START_TIME                            UPDATE_TIME                          LOGFILE_TABLE   BADFILE_TABLE
---------- ----------- ------- ---------- ---------------------- --------------------- --------------- ------------- ------------- -------------
CHANNELS   SH          COPY   COMPLETED  04-MAR-21 07.38.30.522711000 AM GMT    04-MAR-21 07.38.30.522711000 AM GMT  COPY$1_LOG     COPY$1_BAD

La colonna LOGFILE_TABLE mostra il nome della tabella su cui è possibile eseguire una query per esaminare il log di un'operazione di caricamento. Ad esempio, la query seguente mostra il log dell'operazione di caricamento:

select * from COPY$21_LOG;

La colonna BADFILE_TABLE mostra il nome della tabella su cui è possibile eseguire una query per esaminare le righe che hanno generato errori durante il caricamento. Ad esempio, la seguente query mostra i record rifiutati per l'operazione di caricamento:

select * from COPY$21_BAD;

A seconda degli errori visualizzati nel log e delle righe mostrate nella tabella BADFILE_TABLE specificata, è possibile correggere l'errore specificando le opzioni di formato corrette in DBMS_CLOUD.COPY_DATA.

Nota

Le tabelle LOGFILE_TABLE e BADFILE_TABLE vengono memorizzate per due giorni per ogni operazione di caricamento e quindi rimosse automaticamente.

Per informazioni sulla cancellazione della tabella user_load_operations, vedere DELETE_ALL_OPERATIONS Procedura.

Oggetti JSON testuali che rappresentano valori scalari estesi

I dati JSON binari nativi (formato OSON) estendono il linguaggio JSON aggiungendo tipi scalari, ad esempio la data, che corrispondono a tipi SQL e non fanno parte dello standard JSON. Oracle Database supporta anche l'uso di oggetti JSON testuali che rappresentano i valori scalari JSON, inclusi tali valori non standard.

Quando crei dati JSON binari nativi da dati JSON testuali che contengono tali oggetti estesi, possono essere facoltativamente sostituiti con i corrispondenti valori scalari JSON binari nativi.

Un esempio di oggetto esteso è {"$numberDecimal":31}. Rappresenta un valore scalare JSON del tipo non standard numero decimale e, se interpretato come tale, viene sostituito da un numero decimale in formato binario nativo.

Ad esempio, quando si utilizza il costruttore del tipo di dati JSON, JSON, se si utilizza la parola chiave EXTENDED, gli oggetti estesi riconosciuti nell'input testuale vengono sostituiti con i valori scalari corrispondenti nel risultato JSON binario nativo. Se non si include la parola chiave EXTENDED, la sostituzione non viene eseguita; gli oggetti JSON estesi testuali vengono semplicemente convertiti così com'è in oggetti JSON nel formato binario nativo.

Nella direzione opposta, quando si utilizza la funzione Oracle SQL json_serialize per serializzare i dati JSON binari come dati JSON testuali (VARCHAR2, CLOB o BLOB), è possibile utilizzare la parola chiave EXTENDED per sostituire i valori scalari JSON (binario nativo) con i corrispondenti oggetti JSON estesi testuali.

Nota

Se il database utilizzato è un Oracle Autonomous Database, è possibile utilizzare la procedura PL/SQL DBMS_CLOUD.copy_collection per creare una raccolta di documenti JSON da un file di dati JSON, ad esempio quello prodotto dai database NoSQL comuni, incluso Oracle NoSQL Database.

Se si utilizza ejson come valore del parametro type della procedura, gli oggetti JSON estesi riconosciuti nel file di input vengono sostituiti con i valori scalari corrispondenti nella raccolta JSON binaria nativa risultante. Nell'altra direzione, è possibile utilizzare la funzione json_serialize con la parola chiave EXTENDED per sostituire i valori scalari con oggetti JSON estesi nei dati JSON testuali risultanti.

Questi sono i due casi d'uso principali per gli oggetti estesi:

Scambio (importazione/esportazione):
- Includi dati JSON esistenti (da qualche parte) che contengono oggetti estesi.
- Serializza i dati JSON binari nativi come dati JSON testuali con oggetti estesi, per alcuni usi al di fuori del database.
Ispezione dei dati JSON binari nativi: scopri cosa hai guardando gli oggetti estesi corrispondenti.

A scopo di scambio, puoi includere dati JSON da un file prodotto da database NoSQL comuni, incluso Oracle NoSQL Database, convertendo oggetti estesi in scalari JSON binari nativi. Dall'altra parte, puoi esportare i dati JSON binari nativi come dati testuali, sostituendo i valori JSON scalari specifici di Oracle con i corrispondenti oggetti JSON estesi testuali.

Suggerimento

Come esempio di ispezione, considera un oggetto come {"dob" : "2000-01-02T00:00:00"} come risultato della serializzazione dei dati JSON nativi. "2000-01-02T00:00:00" è il risultato della serializzazione di un valore binario nativo di tipo data oppure il valore binario nativo è solo una stringa? L'utilizzo di json_serialize con la parola chiave EXTENDED consente di sapere.

Il mapping dei campi oggetto estesi ai tipi JSON scalari è, in generale, molti a uno: è possibile mappare più tipi di oggetto JSON esteso a un determinato valore scalare. Ad esempio, gli oggetti JSON estesi {"$numberDecimal":"31"} e {"$numberLong:"31"} vengono entrambi tradotti come valore 31 del numero di tipo scalare in lingua JSON e il metodo elemento type() restituisce "number" per ciascuno degli scalari JSON.

Il metodo elemento type() segnala il tipo scalare in lingua JSON del relativo valore di destinazione (come stringa JSON). Alcuni valori scalari sono distinguibili internamente, anche quando hanno lo stesso tipo scalare. In genere, la funzione json_serialize (con la parola chiave EXTENDED) consente di ricostruire l'oggetto JSON esteso originale. Tali valori scalari vengono distinti internamente utilizzando tipi SQL diversi per implementarli o etichettandoli con il tipo di oggetto JSON esteso da cui sono stati derivati.

Quando json_serialize ricostruisce l'oggetto JSON esteso originale, il risultato non è sempre testuale identico all'originale, ma è sempre equivalente semanticamente. Ad esempio, {"$numberDecimal":"31"} e {"$numberDecimal":31} sono semanticamente equivalenti, anche se i valori dei campi differiscono per tipo (stringa e numero). Vengono convertiti nello stesso valore interno e ciascuno viene contrassegnato come derivato da un oggetto esteso $numberDecimal (stessa tag). Tuttavia, se serializzato, il risultato per entrambi è {"$numberDecimal":31}. Oracle utilizza sempre il tipo più direttamente rilevante per il valore del campo, che in questo caso è il valore in lingua JSON 31, di tipo scalare.

La tabella presenta le corrispondenze tra i vari tipi utilizzati. Esegue il mapping tra (1) tipi di oggetti estesi utilizzati come input, (2) tipi segnalati dal metodo elemento type(), (3) tipi SQL utilizzati internamente, (4) tipi di linguaggio JSON standard utilizzati come output dalla funzione json_serialize e (5) tipi di oggetti estesi restituiti da json_serialize quando viene specificata la parola chiave EXTENDED.

Tabella - Relazioni tipo di oggetto JSON estese

^{Nota a piè di pagina 1}I valori stringa vengono interpretati senza distinzione tra maiuscole e minuscole. Ad esempio, "NAN" "nan" e "nAn" sono accettati e equivalenti e, analogamente, "INF", "inFinity" e "iNf". I numeri infinitamente grandi ("Infinity" o "Inf") e piccoli ("-Infinity" o "-Inf") sono accettati con la parola completa o l'abbreviazione.

^{Nota a piè di pagina 2}Nell'output vengono utilizzati solo questi valori di stringa. Non vengono utilizzate varianti di tipo Infinity o lettere maiuscole.

Vedere anche:

Standard IEEE per l'aritmetica a virgola mobile (IEEE 754)

Tipo oggetto esteso (input)	Tipo scalare JSON Oracle (segnalato per type())	Tipo scalare SQL	Tipo scalare JSON standard (output)	Tipo oggetto esteso (output)
`$numberDouble` con valore un numero JSON, una stringa che rappresenta il numero o una delle seguenti stringhe: `"Infinity"`, `"-Infinity"`, `"Inf"`, `"-Inf"`, `"Nan"`^{Foot 1}	double	`BINARY_DOUBLE`	number	`$numberDouble` con valore un numero JSON o una delle seguenti stringhe: `"Inf"`, `"-Inf"`, `"Nan"`^{Foot 2}
`$numberFloat` con valore uguale a quello di `$numberDouble`	float	`BINARY_FLOAT`	number	`$numberFloat` con valore uguale a quello di `$numberDouble`
`$numberDecimal` con valore uguale a quello di `$numberDouble`	number	`NUMBER`	number	`$numberDecimal` con valore uguale a quello di `$numberDouble`
`$numberInt` con un valore intero a 32 bit con segno o una stringa che rappresenta il numero	number	`NUMBER`	number	`$numberInt` con valore uguale a quello di `$numberDouble`
`$numberLong` con valore un numero JSON o una stringa che rappresenta il numero	number	`NUMBER`	number	`$numberLong` con valore uguale a quello di `$numberDouble`
`$binary` con uno dei seguenti valori: una stringa di base-64 caratteri Oggetto con i campi `base64` e `subType`, i cui valori sono una stringa di base-64 caratteri e il numero `0` (binario arbitrario) o `4` (UUID), rispettivamente Quando il valore è una stringa di base-64 caratteri, l'oggetto esteso può anche avere il campo `$subtype` con valore 0 o 4, espresso come numero intero di un byte (0-255) o una stringa esadecimale di 2 caratteri che rappresenta un numero intero di questo tipo.	binario	`BLOB` o `RAW`	stringa La conversione equivale all'uso della funzione SQL `rawtohex`.	Uno dei seguenti: `$binary` con un valore stringa di base-64 caratteri `$rawid` con valore stringa di 32 caratteri esadecimali, se l'input ha un valore `subType` pari a `4` (UUID)
`$oid` con valore una stringa di 24 caratteri esadecimali	binario	`RAW(12)`	stringa La conversione equivale all'uso della funzione SQL `rawtohex`.	`$rawid` con valore una stringa di 24 caratteri esadecimali
`$rawhex` con un valore stringa con un numero pari di caratteri esadecimali	binario	`RAW`	stringa La conversione equivale all'uso della funzione SQL `rawtohex`.	`$binary` con un valore di stringa di base-64 caratteri, con a destra `=` caratteri
`$rawid` con un valore di stringa di 24 o 32 caratteri esadecimali	binario	`RAW`	stringa La conversione equivale all'uso della funzione SQL `rawtohex`.	`$rawid`
`$oracleDate` con valore stringa di data ISO 8601	data	`DATE`	stringa	`$oracleDate` con valore stringa di data ISO 8601
`$oracleTimestamp` con valore stringa di indicatore orario ISO 8601	Indicatore orario	`TIMESTAMP`	stringa	`$oracleTimestamp` con valore stringa di indicatore orario ISO 8601
`$oracleTimestampTZ` con valore una stringa di indicatore orario ISO 8601 con un offset fuso orario numerico o con `Z`	indicatore orario con fuso orario	`TIMESTAMP WITH TIME ZONE`	stringa	`$oracleTimestampTZ` con valore una stringa di indicatore orario ISO 8601 con un offset fuso orario numerico o con `Z`
`$date` con uno dei valori seguenti: Conteggio intero in millisecondi dal 1° gennaio 1990 Stringa di indicatore orario ISO 8601 Oggetto con campo `numberLong` con valore un conteggio intero in millisecondi dal 1° gennaio 1990	indicatore orario con fuso orario	`TIMESTAMP WITH TIME ZONE`	stringa	`$oracleTimestampTZ` con valore una stringa di indicatore orario ISO 8601 con un offset fuso orario numerico o con `Z`
`$intervalDaySecond` con valore una stringa di intervallo ISO 8601 come specificato per la funzione SQL `to_dsinterval`	daysecondInterval	`INTERVAL DAY TO SECOND`	stringa	`$intervalDaySecond` con valore una stringa di intervallo ISO 8601 come specificato per la funzione SQL `to_dsinterval`
`$intervalYearMonth` con valore una stringa di intervallo ISO 8601 come specificato per la funzione SQL `to_yminterval`	yearmonthInterval	`INTERVAL YEAR TO MONTH`	stringa	`$intervalYearMonth` con valore una stringa di intervallo ISO 8601 come specificato per la funzione SQL `to_yminterval`
Due campi: Campo `$vector` con valore un array i cui elementi sono numeri o le stringhe `"Nan"`, `"Inf"` e `"-Inf"` (che rappresentano valori non-a-number e infiniti). Campo `$vectorElementType` con valore stringa `"float32"` o `"float64"`. Questi corrispondono rispettivamente ai numeri IEEE a 32 bit e IEEE a 64 bit.	vettore	`VECTOR`	array di numeri	Due campi: Campo `$vector` con valore un array i cui elementi sono numeri o le stringhe `"Nan"`, `"Inf"` e `"-Inf"` (che rappresentano valori non-a-number e infiniti). Campo `$vectorElementType` con valore stringa `"float32"` o `"float64"`.