Charger des données à partir de fichiers en nuage

L'ensemble PL/SQL DBMS_CLOUD prend en charge le chargement de données à partir de fichiers dans le nuage vers des tables créées dans votre infrastructure Autonomous Database sur une infrastructure Exadata dédiée.

Vous pouvez charger des données à partir de différents formats de fichier à l'aide des procédures PL/SQL suivantes fournies par DBMS_CLOUD :

Fichiers texte en nuage, à l'aide de la procédure DBMS_CLOUD.COPY_DATA
Fichiers JSON en nuage, à l'aide de la procédure DBMS_CLOUD.COPY_TEXT

Avant de charger les données à partir des fichiers, assurez-vous que :

Le fichier source est disponible en local sur votre ordinateur client ou chargé dans un magasin d'objets en nuage, tel que le service de stockage d'objets pour Oracle Cloud Infrastructure. Il est accessible à l'utilisateur de base de données qui tente de charger des données.
Les données d'identification du service de stockage d'objets en nuage sont stockées à l'aide de la procédure DBMS_CLOUD.CREATE_CREDENTIAL. Pour plus d'informations, voir Créer des données d'identification.

L'ensemble DBMS_CLOUD prend en charge le chargement à partir de fichiers dans les services en nuage suivants : Stockage d'objets pour Oracle Cloud Infrastructure, Stockage d'objets pour Oracle Cloud Infrastructure version classique, Azure Blob Storage et Amazon S3.

Rubriques connexes

Créer des données d'identification

Voyez comment stocker vos données d'identification du service de stockage d'objets en nuage à l'aide de la procédure DBMS_CLOUD.CREATE_CREDENTIAL.

Exécutez la procédure DBMS_CLOUD.CREATE_CREDENTIAL à l'aide de tout outil de base de données tel que SQL*Plus, SQL Developer ou Database Actions (outil SQL Developer basé sur le Web). Par exemple :

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

Les valeurs que vous indiquez pour username et password dépendent du service de stockage d'objets en nuage que vous utilisez :

Oracle Cloud Infrastructure Object Storage : username est votre nom d'utilisateur Oracle Cloud Infrastructure et password est votre jeton d'authentification Oracle Cloud Infrastructure. Voir Utilisation de jetons d'authentification.
Oracle Cloud Infrastructure Object Storage Classic: username is your Oracle Cloud Infrastructure Classic user name and password is your Oracle Cloud Infrastructure Classic password.

Cette opération stocke les données d'identification dans la base de données dans un format chiffré. Vous pouvez utiliser n'importe quel nom pour les données d'identification. Notez que cette étape n'est requise qu'une seule fois, sauf si les données d'identification du magasin d'objets changent. Une fois que vous avez stocké les données d'identification, vous pouvez utiliser le même nom pour tous les chargements de données.

Charger des données à partir de fichiers texte

Voyez comment charger des données à partir de fichiers texte dans le nuage dans Autonomous Database à l'aide de la procédure DBMS_CLOUD.COPY_DATA.

Le fichier source de cet exemple, channels.txt, contient les données suivantes :

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

Stockez vos données d'identification du service de stockage d'objets en nuage à l'aide de la procédure DBMS_CREDENTIAL.CREATE_CREDENTIAL. Voir Créer des données d'identification pour plus de détails.

Créez la table qui contiendra les données. Par exemple :

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

Chargez les données dans la table à l'aide de la procédure DBMS_CLOUD.COPY_DATA. Par exemple :
```
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;
/
```
Les paramètres sont les suivants :
- table_name : Nom de la table cible.
- credential_name : Nom des données d'identification créées à l'étape précédente.
- file_uri_list : Liste délimitée par des virgules des fichiers sources à charger.
  
  Dans cet exemple, file_uri_list est un URI Swift d'Oracle Cloud Infrastructure qui spécifie le fichier channels.txt dans le seau mybucket de la région us-phoenix-1 (idthydc0kinr est l'espace de noms du stockage d'objets dans lequel réside le seau.) Pour plus d'informations sur les formats d'URI pris en charge, voir Formats d'URI du service de stockage d'objets en nuage.
- format : Définit les options que vous spécifiez pour décrire le format du fichier source. Pour plus d'informations sur les options de format que vous pouvez spécifier, voir Paramètre de format.
Pour plus d'informations, voir Procédure COPY_DATA.

Charger un fichier JSON de documents délimités dans une collection

Voyez comment charger un fichier JSON de documents délimités dans une collection dans Autonomous Database à l'aide de la procédure DBMS_CLOUD.COPY_DATA.

Cet exemple charge des valeurs JSON à partir d'un fichier délimité par des lignes et utilise le fichier JSON myCollection.json. Chaque valeur, chaque ligne, est chargée dans une collection de votre Autonomous Database en tant que document unique.

Voici un exemple de fichier. Il comporte trois lignes, avec un objet par ligne. Chacun de ces objets est chargé en tant que document JSON distinct.

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

Procédure :

Stockez vos données d'identification du service de stockage d'objets en nuage à l'aide de la procédure DBMS_CLOUD.CREATE_CREDENTIAL. Voir Créer des données d'identification pour plus de détails.
Charger des données dans une collection à l'aide de la procédure DBMS_CLOUD.COPY_DATA. Par exemple :
```
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;
/
```
Les paramètres sont les suivants :
- collection_name : Nom de la collection cible.
- credential_name : Nom des données d'identification créées à l'étape précédente.
- file_uri_list : Liste délimitée par des virgules des fichiers sources à charger.
  
  Dans cet exemple, file_uri_list est un URI Swift d'Oracle Cloud Infrastructure qui spécifie le fichier myCollection.json dans le seau mybucket de la région us-phoenix-1. Pour plus d'informations sur les formats d'URI pris en charge, voir Formats d'URI du service de stockage d'objets en nuage.
- format : Définit les options que vous spécifiez pour décrire le format du fichier source. Les options de format characterset, compression, ignoreblanklines, jsonpath, maxdocsize, recorddelimiter, rejectlimit, unpackarray sont prises en charge pour le chargement des données JSON. Tout autre format spécifié génère une erreur. Pour plus d'informations sur les options de format que vous pouvez spécifier, voir Paramètre de format.
Pour plus d'informations, voir Procédure COPY_COLLECTION.

Charger un tableau de documents JSON dans une collection

Voyez comment charger un tableau de documents JSON dans une collection de votre base de données Autonomous Database à l'aide de la procédure DBMS_CLOUD.COPY_COLLECTION.

Cet exemple utilise le fichier JSON fruit_array.json. Voici le contenu du fichier fruit_array.json :

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

Procédure :

Stockez vos données d'identification du service de stockage d'objets en nuage à l'aide de la procédure DBMS_CLOUD.CREATE_CREDENTIAL. Voir Créer des données d'identification pour plus de détails.
Charger des données dans une collection à l'aide de la procédure DBMS_CLOUD.COPY_DATA. Par exemple :
```
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;
/
```
Dans cet exemple, vous chargez une seule valeur JSON qui occupe le fichier entier. Il n'est donc pas nécessaire de spécifier un délimiteur d'enregistrement. Pour indiquer qu'il n'y a pas de délimiteur d'enregistrement, vous pouvez utiliser un caractère qui ne se trouve pas dans le fichier d'entrée. Par exemple, vous pouvez utiliser la valeur "0x''01''", car ce caractère n'apparaît pas directement dans le texte JSON.

Lorsque le paramètre unpackarrays de la valeur de format est réglé à TRUE, le tableau de documents est chargé sous la forme de documents individuels plutôt qu'en tant que tableau entier. La décompression des éléments du tableau est toutefois limitée à un seul niveau. S'il existe des tableaux imbriqués dans les documents, ils ne sont pas décompressés.

Les paramètres sont les suivants :
- collection_name : Nom de la collection cible.
- credential_name : Nom des données d'identification créées à l'étape précédente.
- file_uri_list : Liste délimitée par des virgules des fichiers sources à charger.
  
  Dans cet exemple, file_uri_list est un URI Swift d'Oracle Cloud Infrastructure qui spécifie le fichier myCollection.json dans le seau mybucket de la région us-phoenix-1. Pour plus d'informations sur les formats d'URI pris en charge, voir Formats d'URI du service de stockage d'objets en nuage.
- format : Définit les options que vous spécifiez pour décrire le format du fichier source. Les options de format characterset, compression, ignoreblanklines, jsonpath, maxdocsize, recorddelimiter, rejectlimit, unpackarray sont prises en charge pour le chargement des données JSON. Tout autre format spécifié génère une erreur. Pour plus d'informations sur les options de format que vous pouvez spécifier, voir Paramètre de format.
Le chargement de fruit_array.json avec DBMS_CLOUD.COPY_COLLECTION à l'aide de l'option de format unpackarrays permet à la procédure de reconnaître les valeurs de tableau dans la source. Par conséquent, au lieu d'être chargées en tant que document unique, comme c'est le cas par défaut, les données sont chargées dans la collection fruits avec chaque valeur du tableau sous forme de document unique.

Pour plus d'informations, voir Procédure COPY_COLLECTION.

Copier des données JSON dans une table existante

Utilisez DBMS_CLOUD.COPY_DATA pour charger des données JSON du nuage dans une table.

Le fichier source de cet exemple est un fichier de données JSON.

Stockez vos données d'identification du magasin d'objets à l'aide de la procédure DBMS_CLOUD.CREATE_CREDENTIAL. Par exemple :
```
SET DEFINE OFF
BEGIN
  DBMS_CLOUD.CREATE_CREDENTIAL(
    credential_name => 'DEF_CRED_NAME',
    username => 'adb_user@example.com',
    password => 'password'
  );
END;
/
```
Cette opération stocke les données d'identification dans la base de données dans un format chiffré. Vous pouvez utiliser n'importe quel nom pour les données d'identification. Notez que cette étape n'est requise qu'une seule fois, sauf si les données d'identification du magasin d'objets changent. Une fois que vous avez stocké les données d'identification, vous pouvez utiliser le même nom pour tous les chargements de données.

Pour des informations détaillées sur les paramètres, consultez CREATE_CREDENTIAL Procédure.
Chargez des données JSON dans une table existante à l'aide de la procédure DBMS_CLOUD.COPY_DATA.
Par exemple :
```
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;
/ 
```
Les paramètres sont les suivants :
- table_name : Nom de la table cible.
- credential_name : Nom des données d'identification créées à l'étape précédente.
- file_uri_list : Liste délimitée par des virgules des fichiers sources à charger. Vous pouvez utiliser des caractères génériques dans les noms de fichier des URI. Le caractère "*" peut être utilisé comme caractère générique pour plusieurs caractères, "?" peut être utilisé pour un seul caractère.
- format : Pour DBMS_CLOUD.COPY_DATA avec des données JSON, type est json. Spécifiez d'autres valeurs de format pour définir les options décrivant le format du fichier source JSON. Pour plus d'informations, voir Options de format de l'ensemble DBMS_CLOUD.
Dans cet exemple, namespace-string est l'espace de noms du stockage d'objets pour Oracle Cloud Infrastructure et bucketname est le nom du seau. Pour plus d'informations, voir Présentation des espaces de noms du stockage d'objets.

Pour des informations détaillées sur les paramètres, voir Procédure COPY_DATA.

Surveiller et dépanner le chargement de données

Toutes les opérations de chargement de données effectuées à l'aide de l'ensemble PL/SQL DBMS_CLOUD sont enregistrées dans les tables dba_load_operations et user_load_operations :

dba_load_operations : Affiche toutes les opérations de chargement.
user_load_operations : Affiche les opérations de chargement de votre schéma.

Interrogez ces tables pour voir des informations sur les chargements de données en cours et terminés. Par exemple, l'utilisation d'un énoncé SELECT avec un prédicat de clause WHERE sur la colonne TYPE affiche les opérations de chargement de type 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 colonne LOGFILE_TABLE affiche le nom de la table que vous pouvez interroger pour consulter le journal d'une opération de chargement. Par exemple, l'interrogation suivante affiche le journal de l'opération de chargement :

select * from COPY$21_LOG;

La colonne BADFILE_TABLE affiche le nom de la table que vous pouvez interroger pour voir les rangées sur lesquelles des erreurs se sont produites lors du chargement. Par exemple, l'interrogation suivante affiche les enregistrements rejetés pour l'opération de chargement :

select * from COPY$21_BAD;

Selon les erreurs présentées dans le journal et les rangées affichées dans la table BADFILE_TABLE spécifiée, vous pouvez corriger l'erreur en spécifiant les options de format correctes dans DBMS_CLOUD.COPY_DATA.

Note :

Les tables LOGFILE_TABLE et BADFILE_TABLE sont stockées pendant deux jours pour chaque opération de chargement, puis supprimées automatiquement.

Voir Procédure DELETE_ALL_OPERATIONS pour plus d'informations sur la suppression de la table user_load_operations.

Objets JSON textuels représentant des valeurs scalaires étendues

Les données JSON binaires natives (format OSON) étendent le langage JSON en ajoutant des types scalaires, tels que la date, qui correspondent aux types SQL et ne font pas partie de la norme JSON. Oracle Database prend également en charge l'utilisation d'objets JSON texte qui représentent des valeurs scalaires JSON, y compris des valeurs non standard.

Lorsque vous créez des données JSON binaires natives à partir de données JSON textuelles qui contiennent de tels objets étendus, ils peuvent éventuellement être remplis par les valeurs scalaires JSON (binaires natives) correspondantes.

Voici un exemple d'objet étendu : {"$numberDecimal":31}. Il représente une valeur scalaire JSON du type non standard decimal number et, lorsqu'il est interprété en tant que tel, il est remplacé par un nombre décimal au format binaire natif.

Par exemple, lorsque vous utilisez le constructeur de type de données JSON, JSON, si vous utilisez le mot clé EXTENDED, les objets étendus reconnus dans l'entrée textuelle sont remplacés par les valeurs scalaires correspondantes dans le résultat JSON binaire natif. Si vous n'incluez pas le mot clé EXTENDED, aucun remplacement de ce type ne se produit; les objets JSON étendus textuels sont simplement convertis tels quels en objets JSON au format binaire natif.

Inversement, lorsque vous utilisez la fonction Oracle SQL json_serialize pour sérialiser des données JSON binaires en tant que données JSON textuelles (VARCHAR2, CLOB ou BLOB), vous pouvez utiliser le mot clé EXTENDED pour remplacer les valeurs scalaires JSON (binaire natives) par les objets JSON étendus textuels correspondants.

Note :

Si vous utilisez une base de données autonome Oracle, vous pouvez utiliser la procédure PL/SQL DBMS_CLOUD.copy_collection pour créer une collection de documents JSON à partir d'un fichier de données JSON tel que celui produit par les bases de données NoSQL communes, notamment Oracle NoSQL Database.

Si vous utilisez ejson comme valeur du paramètre type de la procédure, les objets JSON étendus reconnus dans le fichier d'entrée sont remplacés par les valeurs scalaires correspondantes dans la collection binaire JSON binaire native produite. Dans l'autre sens, vous pouvez utiliser la fonction json_serialize avec le mot clé EXTENDED pour remplacer les valeurs scalaires par des objets JSON étendus dans les données JSON textuelles obtenues.

Voici les deux principaux cas d'utilisation des objets étendus :

Échange (importation/exportation) :
- Ingérez des données JSON existantes qui contiennent des objets étendus.
- Sérialisez des données JSON binaires natives en tant que données JSON textuelles avec des objets étendus, pour une utilisation externe à la base de données.
Inspection de données JSON binaires natives : Pour voir ce que vous avez, consultez les objets étendus correspondants.

À des fins d'échange, vous pouvez ingérer des données JSON à partir d'un fichier produit par les bases de données NoSQL communes, y compris Oracle NoSQL Database, en convertissant les objets étendus en valeurs scalaires JSON binaires natives. Inversement, vous pouvez exporter des données JSON binaires natives en tant que données textuelles, en remplaçant les valeurs JSON scalaires propres à Oracle par les objets JSON étendus textuels correspondants.

Conseil :

À titre d'exemple d'inspection, considérez un objet tel que {"dob" : "2000-01-02T00:00:00"} comme résultant de la sérialisation de données JSON natives. "2000-01-02T00:00:00" est-il le résultat de la sérialisation d'une valeur binaire native de type date, ou la valeur binaire native est-elle une chaîne? L'utilisation de json_serialize avec le mot clé EXTENDED vous permet de le savoir.

Le mappage de champs d'objet étendu à des types JSON scalaires est, en général, de type "plusieurs à un" : plusieurs types d'objet JSON étendu peuvent être mappés à une valeur scalaire donnée. Par exemple, les objets JSON étendus {"$numberDecimal":"31"} et {"$numberLong:"31"} sont tous deux traduits en tant que valeur 31 avec le type scalaire numéro JSON, et la méthode d'élément type() retourne "number" pour chacune de ces valeurs scalaires JSON.

La méthode d'élément type() indique le type scalaire JSON de la valeur ciblée (en tant que chaîne JSON). Certaines valeurs scalaires peuvent être distinguées en interne, même si elles ont le même type scalaire. Cela permet généralement à la fonction json_serialize (avec le mot clé EXTENDED) de reconstruire l'objet JSON étendu initial. Ces valeurs scalaires sont distinguées en interne soit en utilisant des différents types SQL pour les mettre en oeuvre, soit en marquant celles-ci à l'aide du type d'objet JSON étendu dont elles sont dérivées.

Lorsque json_serialize reconstruit l'objet JSON étendu initial, le résultat n'est pas toujours textuellement identique à l'objet initial, mais il est toujours sémantiquement équivalent. Par exemple, {"$numberDecimal":"31"} et {"$numberDecimal":31} sont sémantiquement équivalents, même si les valeurs de champ diffèrent par leur type (chaîne et nombre). Les valeurs sont traduites dans la même valeur interne et chacune est marquée comme étant dérivée d'un objet étendu $numberDecimal (même marqueur). Toutefois, lors de la série, le résultat des deux est {"$numberDecimal":31}. Oracle utilise toujours le type le plus directement pertinent pour la valeur de champ, qui dans ce cas est la valeur JSON 31, de type scalaire "nombre".

Le Table présente les correspondances entre les différents types utilisés. Il mappe (1) les types d'objet étendu utilisés comme entrée, (2) les types signalés par la méthode d'élément type(), (3) les types SQL utilisés en interne, (4) les types JSON standard utilisés comme sortie par la fonction json_serialize et (5) les types d'objet étendu générés par json_serialize lorsque le mot clé EXTENDED est spécifié.

Table - Relations entre types d'objet étendu JSON

^{Footnote 1}Les valeurs de chaîne sont interprétées sans sensibilité à la casse. Par exemple, "NAN" "nan" et "nAn" sont acceptés et équivalents, de même que "INF", "inFinity" et "iNf". Les nombres infiniment grands ("Infinity" ou "Inf") et petits ("-Infinity" ou "-Inf") sont acceptés avec le mot complet ou l'abréviation.

^{Note de bas de page 2}Dans la sortie, seules ces valeurs de chaîne sont utilisées, sans variantes d'infinité ni de casse.

Voir aussi :

Norme IEEE pour l'arithmétique en virgule flottante (IEEE 754)

Titre et Copyright

Oracle et/ou ses sociétés affiliées.

Type d'objet étendu (entrée)	Type scalaire Oracle JSON (signalé par type())	Type scalaire SQL	Type scalaire JSON standard (sortie)	Type d'objet étendu (sortie)
`$numberDouble` avec pour valeur un nombre JSON, une chaîne représentant le nombre ou l'une des chaînes suivantes : `"Infinity"`, `"-Infinity"`, `"Inf"`, `"-Inf"`, `"Nan"`^{Foot 1}	double	`BINARY_DOUBLE`	nombre	`$numberDouble` avec pour valeur un nombre JSON ou l'une des chaînes suivantes : `"Inf"`, `"-Inf"`, `"Nan"`^{Foot 2}
`$numberFloat` avec la même valeur que `$numberDouble`	float	`BINARY_FLOAT`	nombre	`$numberFloat` avec la même valeur que `$numberDouble`
`$numberDecimal` avec la même valeur que `$numberDouble`	nombre	`NUMBER`	nombre	`$numberDecimal` avec la même valeur que `$numberDouble`
`$numberInt` avec pour valeur un entier signé sur 32 bits ou une chaîne représentant le nombre	nombre	`NUMBER`	nombre	`$numberInt` avec la même valeur que `$numberDouble`
`$numberLong` avec pour valeur un nombre JSON ou une chaîne représentant le nombre	nombre	`NUMBER`	nombre	`$numberLong` avec la même valeur que `$numberDouble`
`$binary` avec l'une des valeurs suivantes : Une chaîne de caractères en base 64 Un objet avec les champs `base64` et `subType`, dont les valeurs sont une chaîne de caractères en base 64 et le nombre `0` (binaire arbitraire) ou `4` (UUID), respectivement Lorsque la valeur est une chaîne de caractères en base 64, l'objet étendu peut également comporter le champ `$subtype` avec la valeur 0 ou 4, exprimée sous la forme d'un entier d'un octet (de 0 à 255) ou d'une chaîne hexadécimale à 2 caractères représentant un tel nombre entier	binary	`BLOB` ou `RAW`	chaîne La conversion équivaut à l'utilisation de la fonction SQL `rawtohex`.	Un des éléments suivants : `$binary` avec pour valeur une chaîne de caractères en base 64 `$rawid` avec pour valeur une chaîne de 32 caractères hexadécimaux, si l'entrée avait la valeur de `subType` `4` (UUID)
`$oid` avec pour valeur une chaîne de 24 caractères hexadécimaux	binary	`RAW(12)`	chaîne La conversion équivaut à l'utilisation de la fonction SQL `rawtohex`.	`$rawid` avec pour valeur une chaîne de 24 caractères hexadécimaux
`$rawhex` avec pour valeur une chaîne comprenant un nombre pair de caractères hexadécimaux	binary	`RAW`	chaîne La conversion équivaut à l'utilisation de la fonction SQL `rawtohex`.	`$binary` avec pour valeur une chaîne de caractères en base 64, remplie à droite avec les caractères `=`
`$rawid` avec pour valeur une chaîne de 24 ou 32 caractères hexadécimaux	binary	`RAW`	chaîne La conversion équivaut à l'utilisation de la fonction SQL `rawtohex`.	`$rawid`
`$oracleDate` avec pour valeur une chaîne de date ISO 8601	date	`DATE`	chaîne	`$oracleDate` avec pour valeur une chaîne de date ISO 8601
`$oracleTimestamp` avec pour valeur de chaîne d'horodatage ISO 8601	timestamp	`TIMESTAMP`	chaîne	`$oracleTimestamp` avec pour valeur de chaîne d'horodatage ISO 8601
`$oracleTimestampTZ` avec pour valeur une chaîne d'horodatage ISO 8601 avec un décalage de fuseau horaire numérique ou `Z`	horodatage avec fuseau horaire	`TIMESTAMP WITH TIME ZONE`	chaîne	`$oracleTimestampTZ` avec pour valeur une chaîne d'horodatage ISO 8601 avec un décalage de fuseau horaire numérique ou `Z`
`$date` avec l'une des valeurs suivantes : Nombre entier de millisecondes depuis le 1er janvier 1990 Chaîne d'horodatage ISO 8601 Objet avec le champ `numberLong` avec pour valeur un nombre entier de millisecondes depuis le 1er janvier 1990	horodatage avec fuseau horaire	`TIMESTAMP WITH TIME ZONE`	chaîne	`$oracleTimestampTZ` avec pour valeur une chaîne d'horodatage ISO 8601 avec un décalage de fuseau horaire numérique ou `Z`
`$intervalDaySecond` avec pour valeur une chaîne d'intervalle ISO 8601 telle que spécifiée pour la fonction SQL `to_dsinterval`	daysecondInterval	`INTERVAL DAY TO SECOND`	chaîne	`$intervalDaySecond` avec pour valeur une chaîne d'intervalle ISO 8601 telle que spécifiée pour la fonction SQL `to_dsinterval`
`$intervalYearMonth` avec pour valeur une chaîne d'intervalle ISO 8601 telle que spécifiée pour la fonction SQL `to_yminterval`	yearmonthInterval	`INTERVAL YEAR TO MONTH`	chaîne	`$intervalYearMonth` avec pour valeur une chaîne d'intervalle ISO 8601 telle que spécifiée pour la fonction SQL `to_yminterval`
Deux champs : Champ `$vector` avec une valeur d'un tableau dont les éléments sont des nombres ou les chaînes `"Nan"`, `"Inf"` et `"-Inf"` (représentant des valeurs non numériques et infinies). Champ `$vectorElementType` avec la valeur de chaîne `"float32"` ou `"float64"`. Ceux-ci correspondent respectivement aux numéros IEEE 32 bits et IEEE 64 bits.	vecteur	`VECTOR`	tableau de nombres	Deux champs : Champ `$vector` avec une valeur d'un tableau dont les éléments sont des nombres ou les chaînes `"Nan"`, `"Inf"` et `"-Inf"` (représentant des valeurs non numériques et infinies). Champ `$vectorElementType` avec la valeur de chaîne `"float32"` ou `"float64"`.