Daten aus Dateien in der Cloud laden

Zugangsdaten erstellen

Hier erfahren Sie, wie Sie die Zugangsdaten für den Cloud-Objektspeicher mit der Prozedur DBMS_CLOUD.CREATE_CREDENTIAL speichern.

Führen Sie die Prozedur DBMS_CLOUD.CREATE_CREDENTIAL mit einem beliebigen Datenbanktool wie SQL*Plus, SQL Developer oder Database Actions (webbasiertes SQL Developer-Tool) aus. Beispiel:

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

Die Werte, die Sie für username und password angeben, hängen vom verwendeten Cloud-Objektspeicherservice ab:

Oracle Cloud Infrastructure Object Storage: username ist Ihr Oracle Cloud Infrastructure-Benutzername, und password ist Ihr Oracle Cloud Infrastructure-Auth-Token. Siehe Mit Authentifizierungstoken arbeiten.
Oracle Cloud Infrastructure Object Storage Classic: username ist Ihr Oracle Cloud Infrastructure Classic-Name. password ist Ihr Oracle Cloud Infrastructure Classic-Kennwort.

Dieser Vorgang speichert die Zugangsdaten in einem verschlüsselten Format in der Datenbank. Sie können einen beliebigen Namen als Zugangsdatenname verwenden. Beachten Sie, dass dieser Schritt nur einmal erforderlich ist, es sei denn, Ihre Objektspeicherzugangsdaten werden geändert. Nachdem Sie die Zugangsdaten gespeichert haben, können Sie denselben Zugangsdatennamen für alle Dataloads verwenden.

Daten aus Textdateien laden

Erfahren Sie, wie Sie Daten mit der Prozedur DBMS_CLOUD.COPY_DATA aus Textdateien in die Cloud in Autonomous Database laden.

Die Quelldatei in diesem Beispiel channels.txt enthält die folgenden Daten:

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

Speichern Sie die Zugangsdaten für den Cloud-Objektspeicher mit der Prozedur DBMS_CREDENTIAL.CREATE_CREDENTIAL. Weitere Informationen finden Sie unter Zugangsdaten erstellen.

Erstellen Sie die Tabelle, die die Daten enthält. Beispiel:

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

Laden Sie Daten mit der Prozedur DBMS_CLOUD.COPY_DATA in die Tabelle. Beispiel:
```
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;
/
```
Parameter:
- table_name: Der Name der Zieltabelle.
- credential_name: Der Name der Zugangsdaten, die im vorherigen Schritt erstellt wurden.
- file_uri_list: Eine durch Komma getrennte Liste der Quelldateien, die Sie laden möchten.
  
  In diesem Beispiel ist file_uri_list eine Oracle Cloud Infrastructure-Swift-URI, die die Datei channels.txt im Bucket mybucket in der Region us-phoenix-1 angibt. (idthydc0kinr ist der Objektspeicher-Namespace, in dem sich der Bucket befindet.) Informationen zu den unterstützten URI-Formaten finden Sie unter URI-Formate für Cloud-Objektspeicher.
- format: Definiert die Optionen, die Sie zur Beschreibung des Formats der Quelldatei angeben. Informationen zu den Formatoptionen, die Sie angeben können, finden Sie unter Formatparameter.
Ausführlichere Informationen finden Sie unter COPY_DATA-Prozedur.

JSON-Datei mit Dokumenten mit Begrenzungszeichen in eine Collection laden

Erfahren Sie, wie Sie eine JSON-Datei mit getrennten Dokumenten mit der Prozedur DBMS_CLOUD.COPY_DATA in eine Collection in Autonomous Database laden.

In diesem Beispiel werden JSON-Werte aus einer zeilenbegrenzten Datei geladen und die JSON-Datei myCollection.json verwendet. Jeder Wert ( jede Zeile) wird als einzelnes Dokument in eine Collection in Autonomous Database geladen.

Nachfolgend finden Sie ein Beispiel für eine solche Datei. Es enthält drei Zeilen mit einem Objekt pro Zeile. Jedes dieser Objekte wird als separates JSON-Dokument geladen.

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

Vorgehensweise:

Speichern Sie die Zugangsdaten für den Cloud-Objektspeicher mit der Prozedur DBMS_CLOUD.CREATE_CREDENTIAL. Weitere Informationen finden Sie unter Zugangsdaten erstellen.
Laden Sie Daten mit der Prozedur DBMS_CLOUD.COPY_DATA in eine Collection. Beispiel:
```
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;
/
```
Parameter:
- collection_name: Der Name der Ziel-Collection.
- credential_name: Der Name der Zugangsdaten, die im vorherigen Schritt erstellt wurden.
- file_uri_list: Eine durch Komma getrennte Liste der Quelldateien, die Sie laden möchten.
  
  In diesem Beispiel ist file_uri_list eine Oracle Cloud Infrastructure-Swift-URI, die die Datei myCollection.json im Bucket mybucket in der Region us-phoenix-1 angibt. Informationen zu den unterstützten URI-Formaten finden Sie unter URI-Formate für Cloud-Objektspeicher.
- format: Definiert die Optionen, die Sie zur Beschreibung des Formats der Quelldatei angeben. Die Formatoptionen characterset, compression, ignoreblanklines, jsonpath, maxdocsize, recorddelimiter, rejectlimit, unpackarray werden zum Laden von JSON-Daten unterstützt. Alle anderen angegebenen Formate führen zu einem Fehler. Informationen zu den Formatoptionen, die Sie angeben können, finden Sie unter Formatparameter.
Ausführlichere Informationen finden Sie unter COPY_COLLECTION-Prozedur.

Array von JSON-Dokumenten in eine Collection laden

Erfahren Sie, wie Sie ein Array von JSON-Dokumenten mit der Prozedur DBMS_CLOUD.COPY_COLLECTION in eine Collection in Autonomous Database laden.

In diesem Beispiel wird die JSON-Datei fruit_array.json verwendet. Im Folgenden wird der Inhalt der Datei fruit_array.json angezeigt:

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

Vorgehensweise:

Speichern Sie die Zugangsdaten für den Cloud-Objektspeicher mit der Prozedur DBMS_CLOUD.CREATE_CREDENTIAL. Weitere Informationen finden Sie unter Zugangsdaten erstellen.
Laden Sie Daten mit der Prozedur DBMS_CLOUD.COPY_DATA in eine Collection. Beispiel:
```
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 diesem Beispiel laden Sie einen einzelnen JSON-Wert, der die gesamte Datei belegt. Daher muss kein Datensatzbegrenzungszeichen angegeben werden. Um anzugeben, dass es kein Datensatzbegrenzungszeichen gibt, können Sie ein Zeichen verwenden, das nicht in der Eingabedatei vorkommt. Beispiel: Sie können den Wert "0x''01''" verwenden, da dieses Zeichen nicht direkt im JSON-Text vorkommt.

Wenn der Parameter unpackarrays für den Formatwert auf TRUE gesetzt ist, wird das Array von Dokumenten als einzelne Dokumente und nicht als ganzes Array geladen. Das Auspacken von Arrayelementen ist jedoch auf eine einzelne Ebene beschränkt. Wenn verschachtelte Arrays in den Dokumenten vorhanden sind, werden diese Arrays nicht entpackt.

Parameter:
- collection_name: Der Name der Ziel-Collection.
- credential_name: Der Name der Zugangsdaten, die im vorherigen Schritt erstellt wurden.
- file_uri_list: Eine durch Komma getrennte Liste der Quelldateien, die Sie laden möchten.
  
  In diesem Beispiel ist file_uri_list eine Oracle Cloud Infrastructure-Swift-URI, die die Datei myCollection.json im Bucket mybucket in der Region us-phoenix-1 angibt. Informationen zu den unterstützten URI-Formaten finden Sie unter URI-Formate für Cloud-Objektspeicher.
- format: Definiert die Optionen, die Sie zur Beschreibung des Formats der Quelldatei angeben. Die Formatoptionen characterset, compression, ignoreblanklines, jsonpath, maxdocsize, recorddelimiter, rejectlimit, unpackarray werden zum Laden von JSON-Daten unterstützt. Alle anderen angegebenen Formate führen zu einem Fehler. Informationen zu den Formatoptionen, die Sie angeben können, finden Sie unter Formatparameter.
Wenn Sie fruit_array.json mit DBMS_CLOUD.COPY_COLLECTION und der Formatoption unpackarrays laden, werden Arraywerte in der Quelle von der Prozedur erkannt. Anstatt die Daten standardmäßig als einzelnes Dokument zu laden, werden die Daten daher in die Collection fruits mit jedem Wert im Array als einzelnes Dokument geladen.

Ausführlichere Informationen finden Sie unter COPY_COLLECTION-Prozedur.

JSON-Daten in eine vorhandene Tabelle kopieren

Verwenden Sie DBMS_CLOUD.COPY_DATA, um JSON-Daten in der Cloud in eine Tabelle zu laden.

Die Quelldatei in diesem Beispiel ist eine JSON-Datendatei.

Speichern Sie Ihre Objektspeicherzugangsdaten mit der Prozedur DBMS_CLOUD.CREATE_CREDENTIAL. Beispiel:
```
SET DEFINE OFF
BEGIN
  DBMS_CLOUD.CREATE_CREDENTIAL(
    credential_name => 'DEF_CRED_NAME',
    username => 'adb_user@example.com',
    password => 'password'
  );
END;
/
```
Dieser Vorgang speichert die Zugangsdaten in einem verschlüsselten Format in der Datenbank. Sie können einen beliebigen Namen als Zugangsdatenname verwenden. Beachten Sie, dass dieser Schritt nur einmal erforderlich ist, es sei denn, Ihre Objektspeicherzugangsdaten werden geändert. Nachdem Sie die Zugangsdaten gespeichert haben, können Sie denselben Zugangsdatennamen für alle Dataloads verwenden.

Weitere Informationen zu den Parametern finden Sie unter Prozedur CREATE_CREDENTIAL.
JSON-Daten mit der Prozedur DBMS_CLOUD.COPY_DATA in eine vorhandene Tabelle laden.
Beispiel:
```
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;
/ 
```
Parameter:
- table_name: Der Name der Zieltabelle.
- credential_name: Der Name der Zugangsdaten, die im vorherigen Schritt erstellt wurden.
- file_uri_list: Eine durch Komma getrennte Liste der Quelldateien, die Sie laden möchten. Sie können Platzhalter in den Dateinamen in den URIs verwenden. Das Zeichen "*" kann als Platzhalter für mehrere Zeichen, das Zeichen "?" als Platzhalter für ein einzelnes Zeichen verwendet werden.
- format: Bei DBMS_CLOUD.COPY_DATA mit JSON-Daten hat type den Wert JSON. Geben Sie weitere Formatwerte an, um die Optionen zur Beschreibung des Formats der JSON-Quelldatei zu definieren. Weitere Informationen finden Sie unter DBMS_CLOUD-Package - Formatoptionen.
In diesem Beispiel ist namespace-string der Oracle Cloud Infrastructure-Objektspeicher-Namespace und bucketname der Bucket-Name. Weitere Informationen finden Sie unter Object Storage-Namespaces.

Weitere Informationen zu den Parametern finden Sie unter Prozedur COPY_DATA.

Dataloads überwachen und Fehler beheben

Alle mit dem PL/SQL-Package DBMS_CLOUD ausgeführten Dataload-Vorgänge werden in den Tabellen dba_load_operations und user_load_operations protokolliert:

dba_load_operations: Zeigt alle Ladevorgänge an.
user_load_operations: Zeigt die Ladevorgänge in Ihrem Schema an.

Fragen Sie diese Tabellen ab, um Informationen zu laufenden und abgeschlossenen Dataloads anzuzeigen. Beispiel: Wenn Sie eine SELECT-Anweisung mit einem WHERE-Klauselprädikat für die Spalte TYPE verwenden, werden Ladevorgänge mit dem Typ COPY angezeigt:


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

In der Spalte LOGFILE_TABLE wird der Name der Tabelle angezeigt, die Sie abfragen können, um das Log eines Ladevorgangs anzuzeigen. Beispiel: Die folgende Abfrage zeigt das Log des Ladevorgangs an:

select * from COPY$21_LOG;

In der Spalte BADFILE_TABLE wird der Name der Tabelle angezeigt, die Sie abfragen können, um die Zeilen anzuzeigen, die beim Laden fehlerhaft waren. Beispiel: Die folgende Abfrage zeigt die abgelehnten Datensätze für den Ladevorgang an:

select * from COPY$21_BAD;

Je nach den im Log angezeigten Fehlern und den in der angegebenen BADFILE_TABLE-Tabelle angezeigten Zeilen können Sie den Fehler korrigieren, indem Sie die richtigen Formatoptionen in DBMS_CLOUD.COPY_DATA angeben.

Hinweis:

Die Tabellen LOGFILE_TABLE und BADFILE_TABLE werden für jeden Ladevorgang zwei Tage lang gespeichert und dann automatisch entfernt.

Informationen zum Löschen der Tabelle user_load_operations finden Sie unter DELETE_ALL_OPERATIONS-Prozedur.

JSON-Textobjekte, die erweiterte skalare Werte darstellen

Native binäre JSON-Daten (OSON-Format) erweitern die JSON-Sprache durch Hinzufügen skalarer Typen, wie Datumsangaben, die SQL-Typen entsprechen und nicht zum JSON-Standard gehören. Oracle Database unterstützt auch die Verwendung von JSON-Textobjekten, die skalare JSON-Werte darstellen, einschließlich solcher benutzerdefinierten Werte.

Wenn Sie native binäre JSON-Daten aus JSON-Textdaten erstellen, die solche erweiterten Objekte enthalten, können sie optional durch entsprechende skalare JSON-Werte (native Binärdaten) ersetzt werden.

Ein Beispiel für ein erweitertes Objekt ist {"$numberDecimal":31}. Es stellt einen skalaren JSON-Wert des Nicht-Standardtyps Dezimalzahl dar und wird bei der Interpretation als solcher durch eine Dezimalzahl im nativen Binärformat ersetzt.

Beispiel: Wenn Sie den JSON-Datentypkonstruktor JSON und das Schlüsselwort EXTENDED verwenden, werden erkannte erweiterte Objekte in der Texteingabe durch entsprechende skalare Werte im nativen binären JSON-Ergebnis ersetzt. Wenn Sie das Schlüsselwort EXTENDED nicht aufnehmen, findet keine derartige Ersetzung statt. Die erweiterten JSON-Textobjekte werden einfach unverändert in JSON-Objekte im nativen Binärformat konvertiert.

Wenn Sie umgekehrt mit der Oracle SQL-Funktion json_serialize binäre JSON-Daten als JSON-Textdaten serialisieren (VARCHAR2, CLOB oder BLOB), können Sie das Schlüsselwort EXTENDED verwenden, um (native binäre) skalare JSON-Werte durch entsprechende erweiterte JSON-Textobjekte zu ersetzen.

Hinweis:

Wenn die verwendete Datenbank eine Oracle Autonomous Database-Instanz ist, können Sie mit der PL/SQL-Prozedur DBMS_CLOUD.copy_collection eine JSON-Dokument-Collection aus einer Datei mit JSON-Daten erstellen, wie die von häufig verwendeten NoSQL-Datenbanken (einschließlich Oracle NoSQL Database) erstellten Daten.

Wenn Sie ejson als Wert des Parameters type der Prozedur verwenden, werden erkannte erweiterte JSON-Objekte in der Eingabedatei durch entsprechende skalare Werte in der resultierenden nativen binären JSON-JSON-Collection ersetzt. Umgekehrt können Sie die Funktion json_serialize mit dem Schlüsselwort EXTENDED verwenden, um skalare Werte durch erweiterte JSON-Objekte in den resultierenden JSON-Textdaten zu ersetzen.

Im Folgenden sind die beiden wichtigsten Anwendungsfälle für erweiterte Objekte aufgeführt:

Austausch (Import/Export):
- Aufnahme vorhandener JSON-Daten (egal von wo), die erweiterte Objekte enthalten.
- Serialisierung nativer binärer JSON-Daten als JSON-Textdaten mit erweiterten Objekten zur Verwendung außerhalb der Datenbank.
Prüfung nativer binärer JSON-Daten: Prüfen Sie den Datenbestand, indem Sie die entsprechenden erweiterten Objekte anzeigen.

Zu Austauschzwecken können Sie JSON-Daten aus einer Datei aufnehmen, die von häufig verwendeten NoSQL-Datenbanken erzeugt wird, einschließlich Oracle NoSQL Database. Dabei werden erweiterte Objekte in native binäre JSON-Skalare konvertiert. Umgekehrt können Sie native binäre JSON-Daten als Textdaten exportieren und dabei Oracle-spezifische skalare JSON-Werte durch entsprechende erweiterte JSON-Textobjekte ersetzen.

Tipp:

Beispiel für eine Prüfung: Betrachten wir ein Objekt wie {"dob" : "2000-01-02T00:00:00"} als Ergebnis der Serialisierung nativer JSON-Daten. Ist "2000-01-02T00:00:00" das Ergebnis der Serialisierung eines nativen Binärwerts vom Typ "date", oder ist der native Binärwert nur eine Zeichenfolge? Dies können Sie durch Verwendung von json_serialize mit dem Schlüsselwort EXTENDED herausfinden.

Die Zuordnung von erweiterten Objektfeldern zu skalaren JSON-Typen erfolgt im Allgemeinen von vielen zu eins: Mehrere Arten von erweiterten JSON-Objekten können einem bestimmten skalaren Wert zugeordnet werden. Beispiel: Die erweiterten JSON-Objekte {"$numberDecimal":"31"} und {"$numberLong:"31"} werden beide als Wert 31 des skalaren Typs "Nummer" in JSON-Sprache übersetzt, und die Elementmethode type() gibt "number" für jedes dieser JSON-Skalare zurück.

Die Elementmethode type() meldet den skalaren Typ der JSON-Sprache für den Zielwert (als JSON-Zeichenfolge). Einige skalare Werte sind intern unterscheidbar, selbst wenn sie denselben skalaren Typ aufweisen. Dadurch kann die Funktion json_serialize (mit dem Schlüsselwort EXTENDED) das ursprüngliche erweiterte JSON-Objekt in der Regel rekonstruieren. Solche skalaren Werte werden intern entweder durch Verwendung von verschiedenen SQL-Typen bei ihrer Implementierung oder durch Tagging mit dem Typ des erweiterten JSON-Objekts unterschieden, von dem sie abgeleitet wurden.

Wenn json_serialize das ursprüngliche erweiterte JSON-Objekt neu erstellt, ist das Ergebnis nicht immer textuell mit dem Original identisch, jedoch immer semantisch äquivalent. Beispiel: {"$numberDecimal":"31"} und {"$numberDecimal":31} sind semantisch gleichwertig, auch wenn sich der Typ der Feldwerte (Zeichenfolge und Zahl) unterscheidet. Sie werden in denselben internen Wert übersetzt, wobei jeder Wert als von einem erweiterten $numberDecimal-Objekt abgeleitet getaggt wird (gleiches Tag). Wenn sie jedoch serialisiert werden, lautet das Ergebnis für beide {"$numberDecimal":31}. Oracle verwendet immer den unmittelbar relevanten Typ für den Feldwert (in diesem Fall den JSON-Sprachwert 31) des skalaren Typs "number".

Tabelle - Zeigt Entsprechungen zwischen den verschiedenen verwendeten Typen an. Die Zuordnung erfolgt über (1) erweiterte Objekttypen, die als Eingabe verwendet werden, (2) von der Elementmethode type() gemeldete Typen, (3) intern verwendete SQL-Typen, (4) standardmäßige JSON-Sprachtypen, die als Ausgabe der Funktion json_serialize verwendet werden, und (5) erweiterte Objekttypen, die von json_serialize bei Angabe des Schlüsselwortes EXTENDED ausgegeben werden.

Tabelle - Beziehungen zwischen erweiterten JSON-Objekttypen

^{Fußnote 1}Die Zeichenfolgewerte werden ohne Berücksichtigung der Groß-/Kleinschreibung interpretiert. Beispiel: "NAN" "nan" und "nAn" werden akzeptiert und sind äquivalent, genau wie die Werte "INF", "inFinity" und "iNf". Unendlich große Zahlen ("Infinity" oder "Inf") und kleine Zahlen ("-Infinity" oder "-Inf") werden mit dem vollständigen Wort oder der Abkürzung akzeptiert.

^{Fußnote 2} Bei der Ausgabe werden nur diese Zeichenfolgenwerte verwendet - vollständige Wörter (Infinity) oder Varianten in Groß- und Kleinschreibung sind nicht zulässig.

Siehe auch:

IEEE-Standard für Schwebepunkt-Arithmetik (IEEE 754)

Erweiterter Objekttyp (Eingabe)	Skalarer Oracle JSON-Typ (gemeldet von type())	Skalarer SQL-Typ	Skalarer JSON-Standardtyp (Ausgabe)	Erweiterter Objekttyp (Ausgabe)
`$numberDouble` mit einer JSON-Zahl, einer Zeichenfolge für die Zahl oder einer der folgenden Zeichenfolgen als Wert: `"Infinity"`, `"-Infinity"`, `"Inf"`, `"-Inf"`, `"Nan"`^{Foot 1}	double (Double-Datentyp)	`BINARY_DOUBLE`	Zahl	`$numberDouble` mit einer JSON-Nummer oder einer der folgenden Zeichenfolgen als Wert: `"Inf"`, `"-Inf"`, `"Nan"`^{Fußnote 2}
`$numberFloat` mit demselben Wert wie für `$numberDouble`	Fließkomma	`BINARY_FLOAT`	Zahl	`$numberFloat` mit demselben Wert wie für `$numberDouble`
`$numberDecimal` mit demselben Wert wie für `$numberDouble`	Zahl	`NUMBER`	Zahl	`$numberDecimal` mit demselben Wert wie für `$numberDouble`
`$numberInt` mit einer signierten 32-Bit-Ganzzahl oder einer Zeichenfolge, die für die Zahl steht, als Wert	Zahl	`NUMBER`	Zahl	`$numberInt` mit demselben Wert wie für `$numberDouble`
`$numberLong` mit einem Wert einer JSON-Nummer oder einer Zeichenfolge, die für die Zahl steht	Zahl	`NUMBER`	Zahl	`$numberLong` mit demselben Wert wie für `$numberDouble`
`$binary` mit einem der folgenden Werte: Eine Zeichenfolge mit base64-Zeichen Ein Objekt mit den Feldern `base64` und `subType`, deren Werte eine Zeichenfolge mit base64-Zeichen und der Zahl `0` (arbiträre Binärdatei) bzw. `4` (UUID) sind Wenn der Wert eine Zeichenfolge mit base64-Zeichen ist, kann das erweiterte Objekt auch das Feld `$subtype` mit dem Wert 0 oder 4 enthalten, das als eine Ganzzahl mit einem Byte (0-255) oder eine Hexadezimalzeichenfolge mit 2 Zeichen, die eine Ganzzahl darstellt, ausgedrückt wird	binär	`BLOB` oder `RAW`	string (Zeichenfolgendatentyp) Die Konvertierung entspricht der Verwendung der SQL-Funktion `rawtohex`.	Eine der folgenden Optionen: `$binary` mit einem Wert einer Zeichenfolge aus base-64 Zeichen `$rawid` mit einer Zeichenfolge aus 32 Hexadezimalzeichen als Wert, wenn die Eingabe den `subType`-Wert `4` (UUID) aufwies
`$oid` mit einer Zeichenfolge aus 24 Dezimalzeichen als Wert	binär	`RAW(12)`	string (Zeichenfolgendatentyp) Die Konvertierung entspricht der Verwendung der SQL-Funktion `rawtohex`.	`$rawid` mit einer Zeichenfolge aus 24 Dezimalzeichen als Wert
`$rawhex` mit einer Zeichenfolge mit einer geraden Anzahl von Hexadezimalzeichen als Wert	binär	`RAW`	string (Zeichenfolgendatentyp) Die Konvertierung entspricht der Verwendung der SQL-Funktion `rawtohex`.	`$binary` mit einer Zeichenfolge aus base64-Zeichen als Wert, die rechts mit `=`-Zeichen aufgefüllt ist
`$rawid` mit einer Zeichenfolge aus 24 oder 32 Hexadezimalzeichen als Wert	binär	`RAW`	string (Zeichenfolgendatentyp) Die Konvertierung entspricht der Verwendung der SQL-Funktion `rawtohex`.	`$rawid`
`$oracleDate` mit Wert einer ISO 8601-Datumszeichenfolge	Datum	`DATE`	string (Zeichenfolgendatentyp)	`$oracleDate` mit Wert einer ISO 8601-Datumszeichenfolge
`$oracleTimestamp` mit Wert einer ISO 8601-Zeitstempelzeichenfolge	Zeitstempel	`TIMESTAMP`	string (Zeichenfolgendatentyp)	`$oracleTimestamp` mit Wert einer ISO 8601-Zeitstempelzeichenfolge
`$oracleTimestampTZ` mit einer ISO 8601-Zeitstempelzeichenfolge mit einem numerischen Zeitzonen-Offset oder mit `Z` als Wert	Zeitstempel mit Zeitzone	`TIMESTAMP WITH TIME ZONE`	string (Zeichenfolgendatentyp)	`$oracleTimestampTZ` mit einer ISO 8601-Zeitstempelzeichenfolge mit einem numerischen Zeitzonen-Offset oder mit `Z` als Wert
`$date` mit einem der folgenden Werte: Eine Ganzzahl in Millisekunden seit dem 1. Januar 1990 Eine ISO 8601-Zeitstempelzeichenfolge Ein Objekt mit Feld `numberLong` mit einer Ganzzahl in Millisekunden seit dem 1. Januar 1990 als Wert	Zeitstempel mit Zeitzone	`TIMESTAMP WITH TIME ZONE`	string (Zeichenfolgendatentyp)	`$oracleTimestampTZ` mit einer ISO 8601-Zeitstempelzeichenfolge mit einem numerischen Zeitzonen-Offset oder mit `Z` als Wert
`$intervalDaySecond` mit einer ISO 8601-Intervallzeichenfolge, wie für die SQL-Funktion `to_dsinterval` angegeben, als Wert	daysecondInterval	`INTERVAL DAY TO SECOND`	string (Zeichenfolgendatentyp)	`$intervalDaySecond` mit einer ISO 8601-Intervallzeichenfolge, wie für die SQL-Funktion `to_dsinterval` angegeben, als Wert
`$intervalYearMonth` mit einer ISO 8601-Intervallzeichenfolge, wie für die SQL-Funktion `to_yminterval` angegeben, als Wert	yearmonthInterval	`INTERVAL YEAR TO MONTH`	string (Zeichenfolgendatentyp)	`$intervalYearMonth` mit einer ISO 8601-Intervallzeichenfolge, wie für die SQL-Funktion `to_yminterval` angegeben, als Wert
Zwei Felder: Feld `$vector` mit einem Wert für ein Array, dessen Elemente Zahlen oder die Zeichenfolgen `"Nan"`, `"Inf"` und `"-Inf"` sind (die Nicht-Zahlen- und unendliche Werte darstellen). Feld `$vectorElementType` mit Zeichenfolgenwert `"float32"` oder `"float64"`. Diese entsprechen den IEEE 32-Bit- und IEEE 64-Bit-Zahlen.	Vektor	`VECTOR`	Zahlenarray	Zwei Felder: Feld `$vector` mit einem Wert für ein Array, dessen Elemente Zahlen oder die Zeichenfolgen `"Nan"`, `"Inf"` und `"-Inf"` sind (die Nicht-Zahlen- und unendliche Werte darstellen). Feld `$vectorElementType` mit Zeichenfolgenwert `"float32"` oder `"float64"`.