Chargement des données de fichiers dans le cloud

Le package PL/SQL DBMS_CLOUD prend en charge le chargement de données à partir de fichiers dans le cloud vers des tables créées dans votre base de données Autonomous AI sur une infrastructure Exadata dédiée.

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

Fichiers texte dans le cloud, à l'aide de la procédure DBMS_CLOUD.COPY_DATA
Fichiers JSON dans le cloud, à l'aide de la procédure DBMS_CLOUD.COPY_TEXT

Avant de charger les données à partir des fichiers, effectuez les vérifications suivantes :

Le fichier source est disponible en tant que fichier local sur l'ordinateur client ou téléchargé vers une banque d'objets cloud, telle qu'Oracle Cloud Infrastructure Object Storage. Il est accessible pour l'utilisateur de base de données qui tente de charger les données.
Vos informations d'identification de stockage d'objet cloud sont stockées à l'aide de la procédure DBMS_CLOUD.CREATE_CREDENTIAL. Pour plus d'informations, reportez-vous à Création d'informations d'identification.

Le package DBMS_CLOUD prend en charge le chargement à partir de fichiers des services cloud suivants : Oracle Cloud Infrastructure Object Storage, Oracle Cloud Infrastructure Object Storage Classic, Azure Blob Storage et Amazon S3.

Création d'informations d'identification

Découvrez comment stocker vos informations d'identification de stockage d'objet cloud à l'aide de l'option DBMS_CLOUD.CREATE_CREDENTIAL.

Exécutez la procédure DBMS_CLOUD.CREATE_CREDENTIAL à l'aide de n'importe quel outil de base de données tel que SQL*Plus, SQL Developer ou Database Actions (outil SQL Developer Web). Exemple :

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

Les valeurs fournies pour username et password dépendent du service Cloud Object Storage que vous utilisez :

Oracle Cloud Infrastructure Object Storage : username est votre nom utilisateur Oracle Cloud Infrastructure et password est votre jeton d'authentification Oracle Cloud Infrastructure. Reportez-vous à Utilisation des jetons d'authentification.
Oracle Cloud Infrastructure Object Storage Classic : username est votre nom utilisateur Oracle Cloud Infrastructure Classic et password est votre mot de passe Oracle Cloud Infrastructure Classic.

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

Chargement des données de fichiers texte

Découvrez comment charger des données à partir de fichiers texte dans le cloud vers votre base de données Autonomous AI à 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 informations d'identification du stockage d'objet cloud à l'aide de la procédure DBMS_CREDENTIAL.CREATE_CREDENTIAL. Pour plus d'informations, reportez-vous à Création d'informations d'identification.</span>

Créez la table qui va contenir les données. 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. 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 informations d'identification créées à l'étape précédente.
- file_uri_list : liste des fichiers source à charger séparés par une virgule.
  
  Dans cet exemple, file_uri_list est un URI Swift Oracle Cloud Infrastructure qui indique le fichier channels.txt dans le bucket mybucket de la région us-phoenix-1. (idthydc0kinr est l'espace de noms du stockage d'objet dans lequel le bucket réside.) Pour plus d'informations sur les formats d'URI pris en charge, reportez-vous à Formats d'URI de stockage d'objet cloud.
- format : définit les options que vous indiquez pour décrire le format du fichier source. Pour plus d'informations sur les options de format que vous pouvez fournir, reportez-vous à Paramètre de format.

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

Découvrez comment charger un fichier JSON de documents délimités dans une collection dans votre base de données Autonomous AI à l'aide de la procédure DBMS_CLOUD.COPY_DATA.

Cet exemple charge les valeurs JSON à partir d'un fichier délimité par une ligne et utilise le fichier JSON myCollection.json. Chaque valeur, chaque ligne, est chargée dans une collection sur votre base de données d'IA autonome en tant que document unique.

Voici un exemple de fichier de ce type. 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 informations d'identification du stockage d'objet cloud à l'aide de la procédure DBMS_CLOUD.CREATE_CREDENTIAL. Pour plus d'informations, reportez-vous à Création d'informations d'identification.
Chargez les données dans une collection à l'aide de la procédure DBMS_CLOUD.COPY_DATA. 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 informations d'identification créées à l'étape précédente.
- file_uri_list : liste des fichiers source à charger séparés par une virgule.
  
  Dans cet exemple, file_uri_list est un URI Swift Oracle Cloud Infrastructure qui indique le fichier myCollection.json dans le bucket mybucket de la région us-phoenix-1. Pour plus d'informations sur les formats d'URI pris en charge, reportez-vous à Formats d'URI de stockage d'objet cloud.
- format : définit les options que vous indiquez 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é entraîne une erreur. Pour plus d'informations sur les options de format que vous pouvez fournir, reportez-vous à Paramètre de format.

Chargement d'un tableau de documents JSON dans une collection

Découvrez comment charger un tableau de documents JSON dans une collection dans votre base de données d'IA autonome à l'aide de la procédure DBMS_CLOUD.COPY_COLLECTION.

Cet exemple utilise le fichier JSON fruit_array.json. Le contenu du fichier fruit_array.json est indiqué ci-dessous :

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

Procédure

Stockez vos informations d'identification du stockage d'objet cloud à l'aide de la procédure DBMS_CLOUD.CREATE_CREDENTIAL. Pour plus d'informations, reportez-vous à Création d'informations d'identification.
Chargez les données dans une collection à l'aide de la procédure DBMS_CLOUD.COPY_DATA. 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 valeur JSON unique qui occupe l'intégralité du fichier. Il n'est donc pas nécessaire de spécifier un délimiteur d'enregistrement. Pour indiquer l'absence de délimiteur d'enregistrement, vous pouvez utiliser un caractère qui ne figure pas dans le fichier d'entrée. Par exemple, vous pouvez utiliser la valeur "0x''01''" car ce caractère ne figure pas directement dans le texte JSON.

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

Les paramètres sont les suivants :
- collection_name : nom de la collection cible.
- credential_name : nom des informations d'identification créées à l'étape précédente.
- file_uri_list : liste des fichiers source à charger séparés par une virgule.
  
  Dans cet exemple, file_uri_list est un URI Swift Oracle Cloud Infrastructure qui indique le fichier myCollection.json dans le bucket mybucket de la région us-phoenix-1. Pour plus d'informations sur les formats d'URI pris en charge, reportez-vous à Formats d'URI de stockage d'objet cloud.
- format : définit les options que vous indiquez 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é entraîne une erreur. Pour plus d'informations sur les options de format que vous pouvez fournir, reportez-vous à 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 la valeur de tableau dans la source. Par conséquent, au lieu de télécharger les données en tant que document unique, comme par défaut, les données sont chargées dans la collection fruits avec chaque valeur du tableau en tant que document unique.

Copier des données JSON dans une table existante

Utilisez DBMS_CLOUD.COPY_DATA pour charger des données JSON dans le cloud dans une table.

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

Procédure

Stockez les informations d'identification de la banque d'objets à l'aide de la procédure DBMS_CLOUD.CREATE_CREDENTIAL. 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 informations d'identification dans la base de données dans un format crypté. Vous pouvez utiliser n'importe quel nom d'informations d'identification. Cette étape est requise une seule fois, sauf si les informations d'identification de banque d'objets changent. Une fois les informations d'identification stockées, vous pouvez utiliser le même nom d'informations d'identification pour tous les chargements de données.

Pour obtenir des informations détaillées sur les paramètres, reportez-vous à la section Procédure CREATE_CREDENTIAL.
Chargez les données JSON dans une table existante en utilisant la procédure DBMS_CLOUD.COPY_DATA.

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 informations d'identification créées à l'étape précédente.
- file_uri_list : liste des fichiers source à charger séparés par une virgule. Vous pouvez utiliser des caractères génériques dans les noms de fichier de vos URI. Le caractère "*" peut être utilisé comme caractère générique pour la représentation de plusieurs caractères. Le caractère " ?" peut être utilisé comme caractère générique pour la représentation d'un seul caractère.
- format : pour DBMS_CLOUD.COPY_DATA avec des données JSON, type est json. Indiquez d'autres valeurs de format pour définir les options permettant de décrire le format du fichier source JSON. Pour plus d'informations, reportez-vous à Options de format de package DBMS_CLOUD.
Dans cet exemple, namespace-string est l'espace de noms Oracle Cloud Infrastructure Object Storage et bucketname est le nom du bucket. Pour plus d'informations, reportez-vous à Présentation des espaces de noms Object Storage.

Pour obtenir des informations détaillées sur les paramètres, reportez-vous à la procédure COPY_DATA.

Surveillance et dépannage d'un chargement de données

Toutes les opérations de chargement de données effectuées à l'aide du package PL/SQL DBMS_CLOUD sont consigné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 dans votre schéma.

Interrogez ces tables pour obtenir des informations sur les chargements de données en cours et terminés. Par exemple, l'utilisation d'une instruction 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 indique le nom de la table que vous pouvez interroger pour consulter le journal d'une opération de chargement. Par exemple, la requête suivante affiche le journal de l'opération de chargement :

select * from COPY$21_LOG;

La colonne BADFILE_TABLE indique le nom de la table que vous pouvez interroger pour consulter les lignes qui ont rencontré des erreurs lors du chargement. Par exemple, la requête suivante affiche les enregistrements rejetés pour l'opération de chargement :

select * from COPY$21_BAD;

En fonction des erreurs contenues dans le journal et des lignes affichées dans la table BADFILE_TABLE spécifiée, vous pouvez corriger l'erreur en indiquant les options du format appropriées dans DBMS_CLOUD.COPY_DATA.

Remarque : Les tables LOGFILE_TABLE et BADFILE_TABLE sont stockées durant deux jours pour chaque opération de chargement, puis enlevées automatiquement.

dbmscloud pour objets-et-fichiers.md#GUID-CEC0CA63-B77F-4D64-B70F-1E8476AE3ED6

Reportez-vous à la procédure DELETE_ALL_OPERATIONS pour plus d'informations sur l'effacement 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 textuels qui représentent des valeurs scalaires JSON, y compris de telles valeurs non standard.

Lorsque vous créez des données JSON binaires natives à partir de données JSON textuelles contenant de tels objets étendus, elles peuvent éventuellement être remplacées avec les valeurs scalaires JSON (binaires natives) correspondantes.

{"$numberDecimal":31} est un exemple d'objet étendu. Il représente une valeur scalaire JSON de type non standard nombre décimal, et lorsqu'elle est interprétée en tant que telle, elle est remplacée 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 n'est effectué. Les objets JSON étendus textuels sont simplement convertis tels quels en objets JSON au format binaire natif.

Dans la direction opposée, lorsque vous utilisez la fonction SQL/JSON json_serialize pour sérialiser les 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 natif) par les objets JSON étendus textuels correspondants.

Remarque : si la base de données que vous utilisez est une base de données Oracle Autonomous AI Database, 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 telles que celles produites par des bases de données NoSQL communes, y compris 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 JSON binaire native résultante. 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 résultantes.

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

Exchange (import/export) :
- Assimilez les données JSON existantes (de quelque part) qui contiennent des objets étendus.
- Sérialisez les données JSON binaires natives en tant que données JSON textuelles avec des objets étendus, pour certaines utilisations en dehors de la base de données.
Inspection des données JSON binaires natives : découvrez ce que vous avez en examinant les objets étendus correspondants.

A des fins d'échange, vous pouvez ingérer des données JSON à partir d'un fichier produit par des bases de données NoSQL communes, y compris Oracle NoSQL Database, en convertissant des objets étendus en scalaires JSON binaires natifs. Dans l'autre sens, 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.

A savoir : A titre d'exemple d'inspection, considérez un objet tel que {"dob" : "2000-01-02T00:00:00"} comme le résultat de la sérialisation des 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 n'est-elle qu'une chaîne ? L'utilisation de json_serialize avec le mot-clé EXTENDED vous le permet.

La mise en correspondance des champs d'objet étendu avec les types JSON scalaires est, en général, de plusieurs à un : plus d'un type d'objet JSON étendu peut être mis en correspondance avec une valeur scalaire donnée. Par exemple, les objets JSON étendus {"$numberDecimal":"31"} et {"$numberLong:"31"} sont traduits en tant que valeur 31 du nombre de type scalaire en langue JSON, et la méthode d'élément type() renvoie "number" pour chacun de ces scalaires JSON.

La méthode d'élément type() indique le type scalaire en langue JSON de sa valeur cible (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 d'origine. Ces valeurs scalaires sont distinguées en interne soit en utilisant des différents types SQL pour les implémenter, soit en les marquant avec le type d'objet JSON étendu à partir duquel elles ont été dérivées.

Lorsque json_serialize reconstruit l'objet JSON étendu d'origine, le résultat n'est pas toujours textuellement identique à l'objet d'origine, 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). Ils sont convertis en la même valeur interne, et chacun est marqué comme étant dérivé d'un objet étendu $numberDecimal (même balise). Mais lorsqu'il est sérialisé, le résultat pour les 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 en langue JSON 31, de type scalaire.

Le tableau suivant présente les correspondances entre les différents types utilisés. Il est mis en correspondance entre (1) les types d'objet étendu utilisés en tant qu'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 de langage JSON standard utilisés en tant que 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é.

Note de bas de page 1 Les valeurs de chaîne sont interprétées sans tenir compte de la casse. Par exemple, "NAN" "nan" et "nAn" sont acceptés et équivalents, et de même "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 Sur la sortie, seules ces valeurs de chaîne sont utilisées. Aucune variante de mot complet Infinity ou de lettre.

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 une valeur numérique JSON, une chaîne représentant le nombre ou l'une des chaînes suivantes : `"Infinity"`, `"-Infinity"`, `"Inf"`, `"-Inf"`, `"Nan"`(Voir note de bas de page 1)	double	`BINARY_DOUBLE`	nombre	`$numberDouble` avec une valeur numérique JSON ou l'une des chaînes suivantes : `"Inf"`, `"-Inf"`, `"Nan"`(Voir la note de bas de page 2)
`$numberFloat` avec la même valeur que pour `$numberDouble`	float	`BINARY_FLOAT`	nombre	`$numberFloat` avec la même valeur que pour `$numberDouble`
`$numberDecimal` avec la même valeur que pour `$numberDouble`	nombre	`NUMBER`	nombre	`$numberDecimal` avec la même valeur que pour `$numberDouble`
`$numberInt` avec une valeur un entier signé de 32 bits ou une chaîne représentant le nombre	nombre	`NUMBER`	nombre	`$numberInt` avec la même valeur que pour `$numberDouble`
`$numberLong` avec une valeur numérique JSON ou une chaîne représentant le nombre	nombre	`NUMBER`	nombre	`$numberLong` avec la même valeur que pour `$numberDouble`
`$binary` avec l'une des valeurs suivantes : une chaîne de caractères de base-64 Objet avec les champs `base64` et `subType`, dont les valeurs sont une chaîne de caractères de base-64 et le nombre `0` (binaire arbitraire) ou `4` (UUID), respectivement. Lorsque la valeur est une chaîne de caractères de base-64, l'objet étendu peut également avoir le champ `$subtype` avec la valeur 0 ou 4, exprimé sous la forme d'un entier d'un octet (0-255) ou d'une chaîne hexadécimale de 2 caractères. représentant un tel entier	binaire	`BLOB` ou `RAW`	chaîne Conversion équivaut à l'utilisation de la fonction SQL `rawtohex`.	Valeurs possibles : `$binary` avec une valeur de chaîne de 64 caractères de base `$rawid` avec une valeur de chaîne de 32 caractères hexadécimaux, si l'entrée avait une valeur `subType` de `4` (UUID)
`$oid` avec une valeur de chaîne de 24 caractères hexadécimaux	binaire	`RAW(12)`	chaîne Conversion équivaut à l'utilisation de la fonction SQL `rawtohex`.	`$rawid` avec une valeur de chaîne de 24 caractères hexadécimaux
`$rawhex` avec une valeur une chaîne avec un nombre pair de caractères hexadécimaux	binaire	`RAW`	chaîne Conversion équivaut à l'utilisation de la fonction SQL `rawtohex`.	`$binary` avec la valeur une chaîne de caractères de base-64, complétée à droite par des caractères `=`
`$rawid` avec une valeur de chaîne de 24 ou 32 caractères hexadécimaux	binaire	`RAW`	chaîne Conversion équivaut à l'utilisation de la fonction SQL `rawtohex`.	`$rawid`
`$oracleDate` avec une valeur de chaîne de date ISO 8601	Date	`DATE`	chaîne	`$oracleDate` avec une valeur de chaîne de date ISO 8601
`$oracleTimestamp` avec une valeur de chaîne d'horodatage ISO 8601	timestamp	`TIMESTAMP`	chaîne	`$oracleTimestamp` avec une valeur de chaîne d'horodatage ISO 8601
`$oracleTimestampTZ` avec une valeur de chaîne d'horodatage ISO 8601 avec un décalage de fuseau horaire numérique ou avec `Z`	horodatage avec fuseau horaire	`TIMESTAMP WITH TIME ZONE`	chaîne	`$oracleTimestampTZ` avec une valeur de chaîne d'horodatage ISO 8601 avec un décalage de fuseau horaire numérique ou avec `Z`
`$date` avec la valeur suivante : Nombre entier de millisecondes depuis le 1er janvier 1990 Chaîne d'horodatage ISO 8601 Objet avec le champ `numberLong` dont la valeur est un nombre entier de millisecondes depuis le 1er janvier 1990	horodatage avec fuseau horaire	`TIMESTAMP WITH TIME ZONE`	chaîne	`$oracleTimestampTZ` avec une valeur de chaîne d'horodatage ISO 8601 avec un décalage de fuseau horaire numérique ou avec `Z`
`$intervalDaySecond` avec une valeur correspondant à une chaîne d'intervalle ISO 8601, comme indiqué pour la fonction SQL `to_dsinterval`	Intervalle de joursecond	`INTERVAL DAY TO SECOND`	chaîne	`$intervalDaySecond` avec une valeur correspondant à une chaîne d'intervalle ISO 8601, comme indiqué pour la fonction SQL `to_dsinterval`
`$intervalYearMonth` avec une valeur correspondant à une chaîne d'intervalle ISO 8601, comme indiqué pour la fonction SQL `to_yminterval`	IntervalleMoisAnnée	`INTERVAL YEAR TO MONTH`	chaîne	`$intervalYearMonth` avec une valeur correspondant à une chaîne d'intervalle ISO 8601, comme indiqué pour la fonction SQL `to_yminterval`
Deux champs : Champ `$vector` avec valeur : tableau dont les éléments sont des nombres ou des chaînes `"Nan"`, `"Inf"` et `"-Inf"` (représentant des valeurs non-a-number et infinies). Champ `$vectorElementType` avec la valeur de chaîne `"float32"` ou `"float64"`. Ceux-ci correspondent respectivement à des nombres IEEE 32 bits et IEEE 64 bits.	vecteur	`VECTOR`	tableau de nombres	Deux champs : Champ `$vector` avec valeur : tableau dont les éléments sont des nombres ou des chaînes `"Nan"`, `"Inf"` et `"-Inf"` (représentant des valeurs non-a-number et infinies). Champ `$vectorElementType` avec la valeur de chaîne `"float32"` ou `"float64"`.

Chargement des données de fichiers dans le cloud

Création d'informations d'identification

Chargement des données de fichiers texte

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

Procédure

Chargement d'un tableau de documents JSON dans une collection

Procédure

Copier des données JSON dans une table existante

Procédure

Surveillance et dépannage d'un chargement de données

Objets JSON textuels représentant des valeurs scalaires étendues

Contenu connexe