Functions-(Data Flow-)Referenz

Die folgenden Funktionen werden mit Operatoren in einem Datenfluss verwendet, damit Sie Ausdrücke erstellen können.


Funktion	Beschreibung	Beispiel
`COUNT(value[, value]*)`	Gibt die Anzahl der Zeilen zurück, für die mindestens ein angegebener Ausdruck nicht Null ist.	`COUNT(expr1)`
`COUNT(*)`	Gibt die Gesamtanzahl der abgerufenen Zeilen zurück, einschließlich Zeilen, die Null enthalten.	`COUNT(*)`
`MAX(value)`	Gibt den Höchstwert des Arguments zurück.	`MAX(expr)`
`MIN(value)`	Gibt den Mindestwert des Arguments zurück.	`MIN(expr)`
`SUM(numeric)`	Gibt die aus Werten einer Gruppe berechnete Summe zurück.	`SUM(expr1)`
`AVG(numeric)`	Gibt den Durchschnitt numerischer Werte in einem Ausdruck zurück.	`AVG(AGGREGATE_1.src1.attribute1)`
`LISTAGG(column[, delimiter]) WITHIN GROUP (order_by_clause)`	Verkettet Werte der Eingabespalte mit dem angegebenen Begrenzungszeichen für jede Gruppe basierend auf der Order-Klausel. column enthält die Werte, die Sie im Ergebnis verketten möchten. Das Trennzeichen trennt die column-Werte im Ergebnis. Wenn Sie kein Begrenzungszeichen angeben, wird ein leeres Zeichen verwendet. order_by_clause bestimmt die Reihenfolge, in der die verketteten Werte zurückgegeben werden. Diese Funktion kann nur als Aggregator und mit oder ohne Gruppierung verwendet werden. Bei Verwendung ohne Gruppierung ist das Ergebnis eine einzelne Zeile. Wenn Sie eine Gruppierung verwenden, gibt die Funktion eine Zeile für jede Gruppe zurück.	Sie verwenden eine Tabelle mit zwei Spalten: `id` und `name`. Die Tabelle enthält drei Zeilen. Die Werte der Spalte `id` lauten 101, 102, 102. Die Werte der Spalte `name` sind A, B, C. `+-----+--------+ \| id \| name \| +-----+--------+ \| 101 \| A \| +-----+--------+ \| 102 \| B \| +-----+--------+ \| 102 \| C \| +-----+--------+` Beispiel 1: Ohne Gruppierung `LISTAGG(id, '-') WITHIN GROUP (ORDER BY id)` gibt die Spalte `name` mit dem Wert `A-B-C` zurück. `+--------+ \| name \| +--------+ \| A-B-C \| +--------+` Beispiel 2: Gruppierung nach `id` `LISTAGG(id, '-') WITHIN GROUP (ORDER BY id)` gibt die Spalte `name` mit den Werten `A` und `B-C` in zwei Gruppen zurück. `+--------+ \| name \| +--------+ \| A \| +--------+ \| B-C \| +--------+`

Analytische Funktionen


Funktion	Beschreibung	Beispiel
`FIRST_VALUE(value) OVER ([ partition_clause ] order_by_clause [ windowFrame_clause ] )`	Gibt den Wert zurück, der in der Zeile ausgewertet wird, die der ersten Zeile des Fensterrahmens entspricht.	`FIRST_VALUE(BANK_ID) OVER (PARTITION BY BANK_ID ORDER BY BANK_NAME ROWS BETWEEN CURRENT ROW AND 1 FOLLOWING)` gibt den ersten Wert von `BANK_ID` in einem Fenster zurück, über das die Zeilen als die aktuelle Zeile und 1 Zeile nach dieser Zeile berechnet werden, unterteilt nach `BANK_ID` und in aufsteigender Reihenfolge von `BANK_NAME`.
`LAG(value[, offset[, default]]) OVER ([ partition_clause ] order_by_clause)`	Gibt den Wert zurück, der in der Zeile mit einem bestimmten Offset vor der aktuellen Zeile innerhalb der Partition ausgewertet wird. Wenn keine solche Zeile vorhanden ist, wird der Standardwert zurückgegeben. Sowohl Offset- als auch Standardwert werden in Bezug auf die aktuelle Zeile ausgewertet. Wenn keine Angabe gemacht wird, wird Offset standardmäßig auf 1 und standardmäßig auf NULL gesetzt.	`LAG(BANK_ID, 2, 'hello') OVER (PARTITION BY BANK_ID ORDER BY BANK_NAME DESC)` gibt den Wert von `BANK_ID` aus der zweiten Zeile vor der aktuellen Zeile zurück, unterteilt nach `BANK_ID` und in absteigender Reihenfolge von `BANK_NAME`. Wenn kein solcher Wert vorhanden ist, wird `hello` zurückgegeben.
`LAST_VALUE(value) OVER ([ partition_clause ] order_by_clause [ windowFrame_clause ])`	Gibt den Wert zurück, der in der Zeile ausgewertet wird, die die letzte Zeile des Fensterrahmens ist.	`LAST_VALUE(BANK_ID) OVER (PARTITION BY BANK_ID ORDER BY BANK_NAME ROWS BETWEEN CURRENT ROW AND 1 FOLLOWING)` gibt den letzten Wert von `BANK_ID` in einem Fenster zurück, über das die Zeilen als die aktuelle Zeile und 1 Zeile nach dieser Zeile berechnet werden, unterteilt nach `BANK_ID` und in aufsteigender Reihenfolge von `BANK_NAME`.
`LEAD(value[, offset[, default]]) OVER ([ partition_clause ] order_by_clause)`	Gibt den Wert zurück, der in der Zeile mit einem bestimmten Offset nach der aktuellen Zeile innerhalb der Partition ausgewertet wird. Wenn keine solche Zeile vorhanden ist, wird der Standardwert zurückgegeben. Sowohl Offset- als auch Standardwert werden in Bezug auf die aktuelle Zeile ausgewertet. Wenn keine Angabe gemacht wird, wird Offset standardmäßig auf 1 und standardmäßig auf NULL gesetzt.	`LEAD(BANK_ID, 2, 'hello') OVER (PARTITION BY BANK_ID ORDER BY BANK_NAME)` gibt den Wert von `BANK_ID` aus der zweiten Zeile nach der aktuellen Zeile zurück, unterteilt nach `BANK_ID` und in aufsteigender Reihenfolge von `BANK_NAME`. Wenn kein solcher Wert vorhanden ist, wird `hello` zurückgegeben.
`RANK() OVER([ partition_clause ] order_by_clause)`	Gibt den Rang der aktuellen Zeile mit Lücken beginnend mit 1 zurück.	`RANK() OVER (PARTITION BY BANK_ID ORDER BY BANK_NAME)` gibt den Rang der einzelnen Zeilen in der Partitionsgruppe von `BANK_ID` in aufsteigender Reihenfolge von `BANK_NAME` zurück.
`ROW_NUMBER() OVER([ partition_clause ] order_by_clause)`	Gibt die eindeutige Nummer der aktuellen Zeile innerhalb der zugehörigen Partition beginnend mit 1 zurück.	`ROW_NUMBER() OVER (PARTITION BY BANK_ID ORDER BY BANK_NAME)` gibt die eindeutige Zeilennummer der einzelnen Zeilen innerhalb der Partitionsgruppe von `BANK_ID` in aufsteigender Reihenfolge von `BANK_NAME` zurück.

Arithmetische Funktionen


Funktion	Beschreibung	Beispiel
`ABS(numeric)`	Gibt die absolute Potenz des Wertes `numeric` zurück.	`ABS(-1)`
`CEIL(numeric)`	Gibt die kleinste Ganzzahl zurück, die nicht größer als der Wert `numeric` ist.	`CEIL(-1,2)`
`FLOOR(numeric)`	Gibt die größte Ganzzahl zurück, die nicht größer als der Wert `numeric` ist.	`FLOOR(-1,2)`
`MOD(numeric1, numeric2)`	Gibt den Rest zurück, nachdem `numeric1` durch `numeric2` geteilt wurde.	`MOD(8,2)`
`POWER(numeric1, numeric2)`	Entspricht `numeric1` hoch `numeric2`.	`POWER(2,3)`
`ROUND(numeric1, numeric2)`	Gibt `numeric1` gerundet auf `numeric2` Dezimalstellen zurück.	`ROUND(2.5,0)`
`TRUNC(numeric1, numeric2)`	Gibt `numeric1` gekürzt auf `numeric2` Dezimalstellen zurück.	`TRUNC(2.5,0)`
`TO_NUMBER(expr[, format, locale])`	Konvertiert `expr` basierend auf den Angaben für `format` und `locale` (optional) in eine Zahl. Das Standardgebietsschema ist `en-US`. Unterstützte Sprachtags. Unterstützte Formatmuster: `0`: Eine Ziffer `#`: Eine Ziffer, Null wird als nicht vorhanden angezeigt `.`: Platzhalter für Dezimaltrennzeichen `,`: Platzhalter für Gruppierungstrennzeichen `E`: Trennt Mantisse und Exponent bei exponentiellen Formaten `-`: Standardpräfix für Negativ `¤`: Währungszeichen, wird durch das Währungssymbol ersetzt. Wenn es doppelt vorhanden ist, wird es durch das internationale Währungssymbol ersetzt. Bei Verwendung in einem Muster wird das monetäre Dezimaltrennzeichen statt des Dezimaltrennzeichens verwendet.	`TO_NUMBER('5467.12')` gibt `5467.12` zurück `TO_NUMBER('-USD45,677.7', '¤¤##,###.#', 'en-US')` gibt `-45677.7` zurück

Arrayfunktionen

Nur der Ausdrucksoperator unterstützt Arrayfunktionen.


Funktion	Beschreibung	Beispiel
`ARRAY_POSITION(array(...), element)`	Gibt die Position des ersten Vorkommens des angegebenen Elements im angegebenen Array zurück. Die Position basiert nicht auf Null, sondern beginnt mit 1.	`ARRAY_POSITION(array(3, 2, 1, 4, 1), 1)` gibt `3` zurück
`REVERSE(array(...))`	Gibt das angegebene Elementarray in umgekehrter Reihenfolge zurück.	`REVERSE(array(2, 1, 4, 3))` gibt `[3,4,1,2]` zurück
`ELEMENT_AT(array(...), index)`	Gibt das Element des angegebenen Arrays an der angegebenen Indexposition zurück. Der Index basiert nicht auf Null, sondern beginnt mit 1. Wenn `index = -1`, gibt es das letzte Element zurück.	`ELEMENT_AT(array(1, 2, 3), 2)` gibt `2` zurück

Bedingungen


Funktion	Beschreibung	Beispiel
`COALESCE(value, value [, value]*)`	Gibt das erste Nicht-Null-Argument zurück, falls vorhanden. Andernfalls wird Null zurückgegeben.	`COALESCE(NULL, 1, NULL)` gibt `1` zurück
`NULLIF(value, value)`	Gibt Null zurück, wenn die beiden Werte gleich sind. Andernfalls wird der erste Wert zurückgegeben.	`NULLIF('ABC','XYZ')` gibt `ABC` zurück

Datums- und Zeitfunktionen


Funktion	Beschreibung	Beispiel
`CURRENT_DATE`	Gibt das aktuelle Datum zurück.	`CURRENT_DATE` gibt das aktuelle Datum zurück, z.B. `2023-05-26`
`CURRENT_TIMESTAMP`	Gibt das aktuelle Datum und die Zeit für die Session-Zeitzone zurück.	`CURRENT_TIMESTAMP` gibt das aktuelle Datum und die aktuelle Uhrzeit zurück, wie `2023-05-26 12:34:56`
`DATE_ADD(date, number_of_days)`	Gibt das Datum zurück, das `number` von Tagen nach dem angegebenen Datum `date` liegt.	`DATE_ADD('2017-07-30', 1)` gibt `2017-07-31` zurück
`DATE_FORMAT(expr, format[, locale])`	Formatiert `expr` vom Typ "Datum" basierend auf den Angaben für `format` und `locale` (optional). Das Standardgebietsschema ist `en-US`. Unterstützte Sprachtags. Unterstützte Datumsformatmuster: yy: Zweistelliges Jahr yyyy: Vierstelliges Jahr M: Numerischer Monat, z.B. 1 für Januar MM: Numerischer Monat, z.B. 01 für Januar MMM: Abgekürzter Monat, z.B. Jan MMMM: Vollständiger Monat, z.B. Januar d: Numerischer Tag des Monats, z.B. 1 für den 1. Juni dd: Numerischer Tag des Monats, Beispiel: 01 für den 1. Juni DDD: Numerischer Tag des Jahres von 001 bis 366, z.B. 002 für den 2. Januar F: Numerischer Wochentag in einem Monat, z.B. 3 für den 3. Montag im Juni. EEE oder E: Abgekürzter benannter Tag der Woche, z.B. Sun für Sonntag EEEE: Benannter Tag der Woche, z.B. Sonntag HH: 24-Stunden-Format von 00 bis 23 H: 24-Stunden-Format von 0 bis 23 hh: das 12-Stunden-Format von 01 bis 12 h: 12-Stunden-Format von 1 bis 12 mm: Minuten von 00 bis 59 ss: Sekunden von 00 bis 59 SSS: Millisekunden von 000 bis 999 a: AM oder PM z: Zeitzone wie PDT	`DATE_FORMAT(Date '2020-10-11', 'yyyy-MM-dd')` gibt `'2020-10-11'` zurück. Das erste Argument ist ein Date-Objekt, das den 11. Oktober 2020 darstellt. `DATE_FORMAT(Date '2018-junio-17', 'yyyy/MMMM/dd', 'es-ES')` gibt `'2018/junio/17'` zurück
`DAYOFMONTH(date)`	Gibt den Tag des Monats für das Datum zurück.	`DAYOFMONTH('2020-12-25')` gibt `25` zurück
`DAYOFWEEK(date)`	Gibt den Tag der Woche für das Datum zurück.	`DAYOFWEEK('2020-12-25')` gibt `6` für Freitag zurück. In den USA gilt der Sonntag als 1, der Montag als 2 usw.
`DAYOFYEAR(date)`	Gibt den Tag des Jahres für das Datum zurück.	`DAYOFYEAR('2020-12-25')` gibt `360` zurück
`WEEKOFYEAR(date)`	Gibt die Woche des Jahres für das Datum zurück.	`WEEKOFYEAR('2022-07-28')` gibt `30` zurück `WEEKOFYEAR('2022-07-28 13:24:30')` gibt `30` zurück
`HOUR(datetime)`	Gibt den Stundenwert für das Datum/die Uhrzeit zurück.	`HOUR('2020-12-25 15:10:30')` gibt `15` zurück
`LAST_DAY(date)`	Gibt den letzten Tag des Monats für das Datum zurück.	`LAST_DAY('2020-12-25')` gibt `31` zurück
`MINUTE(datetime)`	Gibt den Minutenwert für das Datum/die Uhrzeit zurück.	`HOUR('2020-12-25 15:10:30')` gibt `10` zurück
`MONTH(date)`	Gibt den Monatswert für das Datum zurück.	`MONTH('2020-06-25')` gibt `6` zurück
`QUARTER(date)`	Gibt das Quartal des Jahres zurück, in dem das Datum liegt.	`QUARTER('2020-12-25')` gibt `4` zurück
`SECOND(datetime)`	Gibt den Sekundenwert für das Datum/die Uhrzeit zurück.	`SECOND('2020-12-25 15:10:30')` gibt `30` zurück
`TO_DATE(string, format_string[, localeStr])`	Parst den Zeichenfolgenausdruck mit dem Ausdruck `format_string` in ein Datum. Das Gebietsschema ist optional. Der Standardwert ist `en-US`. Unterstützte Sprachtags. In Pipelineausdrücken muss `format_string` die strftime-Formatcodes verwenden. Andernfalls werden folgende Formatzeichenfolgen (unter Beachtung der Groß-/Kleinschreibung) unterstützt: yy: Zweistelliges Jahr yyyy: Vierstelliges Jahr M: Numerischer Monat, z.B. 1 für Januar MM: Numerischer Monat, z.B. 01 für Januar MMM: Abgekürzter Monat, z.B. Jan MMMM: Vollständiger Monat, z.B. Januar d: Numerischer Tag des Monats, z.B. 1 für den 1. Juni dd: Numerischer Tag des Monats, Beispiel: 01 für den 1. Juni DDD: Numerischer Tag des Jahres von 001 bis 366, z.B. 002 für den 2. Januar F: Numerischer Wochentag in einem Monat, z.B. 3 für den 3. Montag im Juni. EEE oder E: Abgekürzter benannter Tag der Woche, z.B. Sun für Sonntag EEEE: Benannter Tag der Woche, z.B. Sonntag HH: 24-Stunden-Format von 00 bis 23 H: 24-Stunden-Format von 0 bis 23 hh: das 12-Stunden-Format von 01 bis 12 h: 12-Stunden-Format von 1 bis 12 mm: Minuten von 00 bis 59 ss: Sekunden von 00 bis 59 SSS: Millisekunden von 000 bis 999 a: AM oder PM z: Zeitzone wie PDT	`TO_DATE('31 December 2016', 'dd MMMM yyyy')` gibt einen Datumswert von `2016-12-31` zurück `TO_DATE('2018/junio/17', 'yyyy/MMMM/dd', 'es-ES')` gibt einen Datumswert von `2018-06-17` zurück
`TO_TIMESTAMP(expr, format_string[, localeStr])`	Konvertiert `expr` vom Typ "VARCHAR" basierend auf den Angaben für `format_string` und `localeStr` (optional) in einen TIMESTAMP-Wert. In Pipelineausdrücken muss `format_string` die strftime-Formatcodes verwenden. Andernfalls werden folgende Formatmuster unterstützt: yy: Zweistelliges Jahr yyyy: Vierstelliges Jahr M: Numerischer Monat, z.B. 1 für Januar MM: Numerischer Monat, z.B. 01 für Januar MMM: Abgekürzter Monat, z.B. Jan MMMM: Vollständiger Monat, z.B. Januar d: Numerischer Tag des Monats, z.B. 1 für den 1. Juni dd: Numerischer Tag des Monats, Beispiel: 01 für den 1. Juni DDD: Numerischer Tag des Jahres von 001 bis 366, z.B. 002 für den 2. Januar F: Numerischer Wochentag in einem Monat, z.B. 3 für den 3. Montag im Juni. EEE oder E: Abgekürzter benannter Tag der Woche, z.B. Sun für Sonntag EEEE: Benannter Tag der Woche, z.B. Sonntag HH: 24-Stunden-Format von 00 bis 23 H: 24-Stunden-Format von 0 bis 23 hh: das 12-Stunden-Format von 01 bis 12 h: 12-Stunden-Format von 1 bis 12 mm: Minuten von 00 bis 59 ss: Sekunden von 00 bis 59 SSS: Millisekunden von 000 bis 999 a: AM oder PM z: Zeitzone wie PDT	`TO_TIMESTAMP('2020-10-11 11:10:10', 'yyyy-MM-dd HH:mm:ss')` gibt ein TIMESTAMP-Objekt zurück, das `11am 10:10 Oct 11th, 2020` darstellt
`WEEK(date)`	Gibt den Wochenwert für das Datum zurück.	`WEEK('2020-06-25')` gibt `4` zurück
`YEAR(date)`	Gibt den Jahreswert für das Datum zurück.	`YEAR('2020-06-25')` gibt `2020` zurück
`ADD_MONTHS(date_expr, number_months)`	Gibt das Datum nach dem Hinzufügen der angegebenen Anzahl von Monaten zum angegebenen Datum, zum Zeitstempel oder zur Zeichenfolge mit einem Format wie `yyyy-MM-dd` oder `yyyy-MM-dd HH:mm:ss.SSS` zurück.	`ADD_MONTHS('2017-07-30', 1)` gibt `2017-08-30` zurück `ADD_MONTHS('2017-07-30 09:07:21', 1)` gibt `2017-08-30` zurück
`MONTHS_BETWEEN(start_date_expr, end_date_expr)`	Gibt die Anzahl der Monate zwischen `start_date_expr` und `end_date_expr` zurück. `start_date_expr` und `end_date_expr` können Datumsangaben, Zeitstempel oder Zeichenfolgen mit einem Format wie `yyyy-MM-dd` oder `yyyy-MM-dd HH:mm:ss.SSS` sein. Eine Ganzzahl wird zurückgegeben, wenn beide Datumsangaben denselben Tag im Monat oder den letzten Tag im jeweiligen Monat angeben. Andernfalls wird die Differenz auf Basis von 31 Tagen pro Monat berechnet.	`MONTHS_BETWEEN('2022-01-01', '2022-01-31')` gibt 1 zurück `MONTHS_BETWEEN('2022-07-28', '2020-07-25')` gibt 24 zurück `MONTHS_BETWEEN('2022-07-28 13:24:30', '2020-07-25 13:24:30')` gibt 24 zurück
`FROM_UTC_TIMESTAMP(time_stamp, time_zone)`	Interpretiert ein Datum, einen Zeitstempel oder eine Zeichenfolge als UTC-Zeit und konvertiert diese Zeit in einen Zeitstempel in der angegebenen Zeitzone. Verwenden Sie für eine Zeichenfolge ein Format wie `yyyy-MM-dd` oder `yyyy-MM-dd HH:mm:ss.SSS`. Das Zeitzonenformat ist entweder eine regionsbasierte Zonen-ID (z.B. "Region/Ort", wie "Asia/Seoul") oder ein Zeitzonenversatz (z.B. UTC+02).	`FROM_UTC_TIMESTAMP('2017-07-14 02:40:00.0', 'GMT+1')` gibt `2017-07-14 03:40:00.0` zurück
`TO_UTC_TIMESTAMP(time_stamp, time_zone)`	Konvertiert ein Datum, einen Zeitstempel oder eine Zeichenfolge in der angegebenen Zeitzone in einen UTC-Zeitstempel. Verwenden Sie für eine Zeichenfolge ein Format wie `yyyy-MM-dd` oder `yyyy-MM-dd HH:mm:ss.SSS`. Das Zeitzonenformat ist entweder eine regionsbasierte Zonen-ID (z.B. "Region/Ort", wie "Asia/Seoul") oder ein Zeitzonenversatz (z.B. UTC+02).	`TO_UTC_TIMESTAMP('2017-07-14 02:40:00.0', 'GMT+1')` gibt `2017-07-14 01:40:00.0` zurück
`FROM_UNIXTIME(unix_time[, fmt])`	Konvertiert die angegebene Unix-Zeit oder -Epoche in eine Zeichenfolge, die den Zeitstempel dieses Zeitpunkts in der aktuellen Systemzeitzone und im angegebenen Format darstellt. Hinweis: Die Unix-Zeit ist die Anzahl der Sekunden, die seit dem 1. Januar 1970 00:00:00 UTC verstrichen sind. Wenn `fmt` ausgelassen wird, lautet das Standardformat `yyyy-MM-dd HH:mm:ss`.	`FROM_UNIXTIME(1255033470)` gibt `'2009-10-08 13:24:30'` zurück `FROM_UNIXTIME(1637258854)` gibt `'2021-11-18 10:07:34'` zurück. Die Standardzeitzone in den Beispielen ist PST.
`UNIX_TIMESTAMP([time_expr[, fmt]])`	Konvertiert die aktuelle oder angegebene Zeit in einen Unix-Zeitstempel in Sekunden. `time_expr` ist ein Datum, ein Zeitstempel oder eine Zeichenfolge mit einem Format wie `yyyy-MM-dd` oder `yyyy-MM-dd HH:mm:ss.SSS`. Wenn `time_expr` nicht angegeben wird, wird die aktuelle Uhrzeit konvertiert. Wenn `time_expr` eine Zeichenfolge ist und `fmt` ausgelassen wird, lautet der Standardwert `yyyy-MM-dd HH:mm:ss`.	`UNIX_TIMESTAMP('1970-01-01 00:00:00', 'yyyy-MM-dd HH:mm:ss')` gibt `28800` zurück Die Standardzeitzone in diesem Beispiel ist PST.
`INTERVAL 'year' YEAR[(year_precision)]`	Gibt einen Zeitraum in Jahren zurück. year_precision ist die Anzahl der Stellen im Feld year. Der Wert muss zwischen 0 und 9 liegen. Wenn year_precision ausgelassen wird, lautet der Standardwert 2 (muss weniger als 100 Jahre betragen).	`INTERVAL '1' YEAR` gibt ein Intervall von 1 Jahr zurück `INTERVAL '200' YEAR(3)` gibt ein Intervall von 200 Jahren zurück
`INTERVAL 'year month' YEAR[(year_precision)] TO MONTH`	Gibt einen Zeitraum in Jahren und Monaten zurück. Verwenden Sie diese Option, um einen Zeitraum mit den Feldern year und month zu speichern. year_precision ist die Anzahl der Stellen im Feld year. Der Wert muss zwischen 0 und 9 liegen. Wenn year_precision ausgelassen wird, lautet der Standardwert 2 (muss weniger als 100 Jahre betragen).	`INTERVAL '100-5' YEAR(3) TO MONTH` gibt ein Intervall von 100 Jahren und 5 Monaten zurück. Sie müssen 3 als führende Gesamtstellenanzahl für das Jahr angeben.
`INTERVAL 'month' MONTH[(month_precision)]`	Gibt einen Zeitraum in Monaten zurück. month_precision ist die Anzahl der Stellen im Feld Monat. Der Wert muss 0 bis 9 sein. Wenn month_precision ausgelassen wird, lautet der Standardwert 2 (muss weniger als 100 Jahre betragen).	`INTERVAL '200' MONTH(3)` gibt ein Intervall von 200 Monaten zurück. Sie müssen 3 als Gesamtstellenanzahl für den Monat angeben.
`INTERVAL 'day time' DAY[(day_precision)] TO SECOND[(fractional_seconds_precision)]`	Gibt einen Zeitraum in Tagen, Stunden, Minuten und Sekunden zurück. day_precision ist die Anzahl der Stellen im Feld day. Der Wert muss zwischen 0 und 9 liegen. Der Standard ist 2. fractional_seconds_precision ist die Anzahl der Ziffern im Bruchteil des zweiten Wertes im Feld time. Der Wert muss zwischen 0 und 9 liegen.	`INTERVAL '11 10:09:08.555' DAY TO SECOND(3)` gibt ein Intervall von 11 Tagen, 10 Stunden, 09 Minuten, 08 Sekunden und 555 Tausendstelsekunden zurück
`INTERVAL 'day time' DAY[(day_precision)] TO MINUTE[(minute_precision)]`	Gibt einen Zeitraum in Tagen, Stunden und Minuten zurück. day_precision ist die Anzahl der Stellen im Feld day. Der Wert muss zwischen 0 und 9 liegen. Der Standard ist 2. minute_precision ist die Anzahl der Stellen im Feld Minute. Der Wert muss zwischen 0 und 2 liegen. Der Standard ist 2.	`INTERVAL '11 10:09' DAY TO MINUTE` gibt ein Intervall von 11 Tagen, 10 Stunden und 09 Minuten zurück
`INTERVAL 'day time' DAY[(day_precision)] TO HOUR[(hour_precision)]`	Gibt einen Zeitraum in Tagen und Stunden zurück. day_precision ist die Anzahl der Stellen im Feld day. Der Wert muss zwischen 0 und 9 liegen. Der Standard ist 2. hour_precision ist die Anzahl der Stellen im Feld Stunde. Der Wert muss 0 bis 2 sein. Der Standard ist 2.	`INTERVAL '100 10' DAY(3) TO HOUR` gibt ein Intervall von 100 Tagen und 10 Stunden zurück
`INTERVAL 'day' DAY[(day_precision)]`	Gibt einen Zeitraum in Tagen zurück. day_precision ist die Anzahl der Stellen im Feld day. Der Wert muss zwischen 0 und 9 liegen. Der Standard ist 2.	`INTERVAL '999' DAY(3)` gibt ein Intervall von 999 Tagen zurück
`INTERVAL 'time' HOUR[(hour_precision)] TO SECOND[(fractional_seconds_precision)]`	Gibt einen Zeitraum in Stunden, Minuten und Sekunden zurück. hour_precision ist die Anzahl der Stellen im Feld Stunde. Der Wert muss 0 bis 2 sein. Der Standard ist 2. fractional_seconds_precision ist die Anzahl der Ziffern im Bruchteil des zweiten Wertes im Feld time. Der Wert muss zwischen 0 und 9 liegen.	`INTERVAL '09:08:07.6666666' HOUR TO SECOND(7)` gibt ein Intervall von 9 Stunden, 08 Minuten und 7,6666666 Sekunden zurück
`INTERVAL 'time' HOUR[(hour_precision)] TO MINUTE[(minute_precision)]`	Gibt einen Zeitraum in Stunden und Minuten zurück. hour_precision ist die Anzahl der Stellen im Feld Stunde. Der Wert muss 0 bis 2 sein. Der Standard ist 2. minute_precision ist die Anzahl der Stellen im Feld Minute. Der Wert muss zwischen 0 und 2 liegen. Der Standard ist 2.	`INTERVAL '09:30' HOUR TO MINUTE` gibt ein Intervall von 9 Stunden und 30 Minuten zurück
`INTERVAL 'hour' HOUR[(hour_precision)]`	Gibt einen Zeitraum in Stunden zurück. hour_precision ist die Anzahl der Stellen im Feld Stunde. Der Wert muss 0 bis 2 sein. Der Standard ist 2.	`INTERVAL '40' HOUR` gibt ein Intervall von 40 Stunden zurück
`INTERVAL 'minute' MINUTE[(minute_precision)]`	Gibt einen Zeitraum in Minuten zurück. minute_precision ist die Anzahl der Stellen im Feld Minute. Der Wert muss zwischen 0 und 2 liegen. Der Standard ist 2.	`INTERVAL '15' MINUTE` gibt ein Intervall von 15 Minuten zurück
`INTERVAL 'time' MINUTE[(minute_precision)] TO SECOND[(fractional_seconds_precision)]`	Gibt einen Zeitraum in Minuten und Sekunden zurück. minute_precision ist die Anzahl der Stellen im Feld Minute. Der Wert muss zwischen 0 und 2 liegen. Der Standard ist 2. fractional_seconds_precision ist die Anzahl der Ziffern im Bruchteil des zweiten Wertes im Feld time. Der Wert muss zwischen 0 und 9 liegen.	`INTERVAL '15:30' MINUTE TO SECOND` gibt ein Intervall von 15 Minuten und 30 Sekunden zurück
`INTERVAL 'second' SECOND[(fractional_seconds_precision)]`	Gibt einen Zeitraum in Sekunden zurück. fractional_seconds_precision ist die Anzahl der Ziffern im Bruchteil des Feldes zweite. Er muss zwischen 0 und 9 liegen. Der Standard ist 3.	`INTERVAL '15.678' SECOND` gibt ein Intervall von 15,678 Sekunden zurück

Hashfunktionen


Funktion	Beschreibung	Beispiel
`MD5(all data types)`	Berechnet eine `MD5`-Prüfsumme des Datentyps und gibt einen Zeichenfolgenwert zurück.	`MD5(column_name)`
`SHA1(all data types)`	Berechnet einen `SHA-1`-Hashwert des Datentyps und gibt einen Zeichenfolgenwert zurück.	`SHA1(column_name)`
`SHA2(all data types, bitLength)`	Berechnet einen `SHA-2`-Hashwert des Datentyps und gibt einen Zeichenfolgenwert zurück. `bitLength` ist eine Ganzzahl.	`SHA2 (column_name, bitLength can be set to 0 (equivalent to 256), 256, 384, or 512)`.
`ORA_HASH(expr, [max_bucket], [seed_value])`	Berechnet einen Hashwert für `expr` und gibt einen NUMBER-Wert zurück. `expr` kann ein Ausdruck, eine Spalte oder ein Literal sein. `max_bucket` ist der zurückgegebene maximale Bucket-Wert zwischen 0 und 4294967295 (Standard). `seed_value` ist ein Wert zwischen 0 (Standard) und 4294967295. Oracle wendet die Hash-Funktion auf die Kombination aus `expr` und `seed_value` an, um viele verschiedene Ergebnisse für dasselbe Datenset zu erzeugen.	`ORA_HASH('1')` `ORA_HASH('b', 2)` `ORA_HASH(100, 10, 10)` `ORA_HASH(EXPRESSION_1.CUSTOMERS.SSN, 2)`

Hierarchische Funktionen


Funktion	Beschreibung	Beispiel
`SCHEMA_OF_JSON(string)`	Parst eine JSON-Zeichenfolge und leitet das Schema im DDL-Format ab.	`SCHEMA_OF_JSON('[{\"Zipcode\":704,\"ZipCodeType\":\"STANDARD\",\"City\":\"ORACLECITY\",\"State\":\"OC\"}]')` gibt `'ARRAY<STRUCT<City:string,State:string,ZipCodeType:string,Zipcode:bigint>>'` zurück `SCHEMA_OF_JSON('[{\"col\":0}]')` gibt `'ARRAY<STRUCT<col: BIGINT>>'` zurück
`FROM_JSON(column, string)`	Parst eine Spalte mit einer JSON-Zeichenfolge in einen der folgenden Typen mit dem angegebenen Schema. Map, mit Zeichenfolge als Schlüsseltyp Struct Array	`FROM_JSON('{\"Zipcode\":704,\"City\":\"ORACLE CITY\"}', 'STRUCT<Zipcode: BIGINT, City: STRING>')` gibt eine Spalte vom Typ "Struct" mit dem angegebenen Schema zurück: `{704, ORACLE CITY}` `FROM_JSON('{\"a\":1, \"b\":0.8}', 'STRUCT<a: BIGINT, b: DOUBLE>')` gibt eine Spalte vom Typ "Struct" mit dem angegebenen Schema zurück: `{1, 0.8}`
`TO_JSON(column)`	Konvertiert eine Spalte vom Typ "Struct" oder "Struct-Array" oder vom Typ "Map" oder "Map-Array" in eine JSON-Zeichenfolge.	`TO_JSON(TO_STRUCT('s1', TO_ARRAY(1,2,3), 's2', TO_MAP('key', 'value')))` gibt eine JSON-Zeichenfolge `{"s1":[1,2,3],"s2":{"key":"value"}}` zurück
`TO_MAP(string,column[,string,column]*)`	Erstellt eine neue Spalte vom Typ "Map". Die Eingabespalten müssen als Schlüssel/Wert-Paare gruppiert werden. Die Eingabeschlüsselspalten dürfen nicht Null sein und müssen alle denselben Datentyp aufweisen. Die Eingabewertspalten müssen alle denselben Datentyp aufweisen.	`TO_MAP('Ename',Expression_1.attribute1)` gibt eine Spalte vom Typ "Map" zurück: `{"ENAME" -> 100}` `TO_MAP('block', EXPRESSION_1.MYSOURCE.address.block, 'unit', EXPRESSION_1.MYSOURCE.address.unit)` gibt eine Spalte vom Typ "Map" zurück: `{"block" -> 1,"unit" -> 1}`
`TO_STRUCT(string,column[,string,column]*)`	Erstellt eine neue Spalte vom Typ "Struct". Die Eingabespalten müssen als Schlüssel/Wert-Paare gruppiert werden.	`TO_STRUCT('Ename',Expression_1.attribute1)` gibt `{100}` zurück `TO_STRUCT('Id',Expression_1.attribute1, 'Name', Expression_1.attribute2)` gibt `{100, "John"}` zurück
`TO_ARRAY(column[,column]*)`	Erstellt eine neue Spalte vom Typ "Array". Die Eingabespalten müssen alle denselben Datentyp aufweisen.	`TO_Array(Expression_1.attribute1)` gibt `[100]` zurück `TO_ARRAY(EXPRESSION_1.attribute2,EXPRESSION_1.attribute3)` gibt `["John","Friend"]` zurück

Funktionen höherer Ordnung

Datenflussoperatoren, die das Erstellen von Ausdrücken und hierarchischen Datentypen unterstützen, können Funktionen höherer Ordnung verwenden.

Die folgenden Operatoren werden unterstützt:

Aggregieren
Ausdruck
Filter
Join
Referenz
Teilen
Drehen


Funktion	Beschreibung	Beispiel
`TRANSFORM(column, lambda_function)`	Nimmt ein Array und eine anonyme Funktion an. Richten Sie ein neues Array ein, indem Sie die Funktion auf jedes Element anwenden und das Ergebnis dem Ausgabearray zuweisen.	Für ein Eingabearray mit Ganzzahlen `[1, 2, 3]` gibt `TRANSFORM(array, x -> x + 1)` ein neues Array von `[2, 3, 4]` zurück.
`TRANSFORM_KEYS(column, lambda_function)`	Nimmt eine Karte und eine Funktion mit 2 Argumenten (Schlüssel und Wert) und gibt eine Karte zurück, in der die Schlüssel den Typ des Ergebnisses der Lambda-Funktion haben und die Werte den Typ der Spaltenzuordnungswerte haben.	Bei einer Eingabezuordnung mit Ganzzahlschlüsseln und Zeichenfolgenwerten von `{1 -> 'value1', 2 -> 'value2', 3 -> 'value3'}` gibt `TRANSFORM_KEYS(map, (k, v) -> k * 2 + 1)` eine neue Zuordnung von `{3 -> 'value1', 5 -> 'value2', 7 -> 'value3'}` zurück.
`TRANSFORM_VALUES(column, lambda_function)`	Nimmt eine Karte und eine Funktion mit 2 Argumenten (Schlüssel und Wert) und gibt eine Karte zurück, in der die Werte den Typ des Ergebnisses der Lambda-Funktionen haben und die Schlüssel den Typ der Spaltenzuordnungsschlüssel haben.	Bei einer Eingabezuordnung mit Zeichenfolgenschlüsseln und Zeichenfolgenwerten von `{'a' -> 'value1', 'b' -> 'value2', 'c' -> 'value3'}` gibt `TRANSFORM_VALUES(map, (k, v) -> k \|\| __ '' \|\| v)` eine neue Zuordnung von `{'a' -> 'a_value1', 'b' -> 'b_value2', 'c' -> 'c_value3'}` zurück.
`ARRAY_SORT(array(...), lambda_function)`	Nur der Ausdrucksoperator unterstützt `ARRAY_SORT`. Nimmt ein Array an und sortiert nach der angegebenen Funktion, die 2 Argumente annimmt. Die Funktion muss -1, 0 oder 1 zurückgeben, je nachdem, ob das erste Element kleiner, gleich oder größer als das zweite Element ist. Wenn die Funktion ausgelassen wird, wird das Array in aufsteigender Reihenfolge sortiert.	`array_sort(to_array(5, 6, 1), (left, right) -> CASE WHEN left < right THEN -1 WHEN left > right THEN 1 ELSE 0 END)` Das zurückgegebene Array ist: `[1,5,6]`

(Vergleichs-)Operatorfunktionen


Funktion	Beschreibung	Beispiel
`CASE WHEN condition1 THEN result1 ELSE result2 END`	Gibt den Wert zurück, für den eine Bedingung erfüllt wird.	`CASE WHEN 1 > 0 THEN 'ABC' ELSE 'XYZ' END` gibt `ABC` zurück, wenn `1> 0`. Andernfalls wird `XYZ` zurückgegeben
`AND`	Der logische AND-Operator. Gibt "true" zurück, wenn beide Operanden wahr sind. Andernfalls wird "false" zurückgegeben.	(x = 10 AND y = 20) gibt "true" zurück, wenn x gleich 10 und y gleich 20 ist. Wenn einer der Operanden nicht wahr ist, wird "false" zurückgegeben
`OR`	Der logische OR-Operator. Gibt "true" zurück, wenn einer der Operanden wahr ist oder beide wahr sind. Andernfalls wird "false" zurückgegeben.	(x = 10 OR y = 20) gibt "false" zurück, wenn x nicht gleich 10 und y nicht gleich 20 ist. Wenn einer der Operanden wahr ist, wird "true" zurückgegeben
`NOT`	Der logische NOT-Operator.
`LIKE`	Ermittelt durch Mustervergleich, ob die Zeichenfolge string1 mit dem Muster in string2 übereinstimmt.
`=`	Führt einen Gleichheitstest aus. Gibt "true" zurück, wenn expr1 gleich expr2 ist. Andernfalls wird "false" zurückgegeben.	x = 10 gibt "true" zurück, wenn der Wert von x gleich 10 ist. Andernfalls wird "false" zurückgegeben
`!=`	Führt einen Ungleichheitstest aus. Gibt "true" zurück, wenn expr1 nicht gleich expr2 ist. Andernfalls wird "false" zurückgegeben.	x != 10 gibt "false" zurück, wenn der Wert von x gleich 10 ist. Andernfalls wird "true" zurückgegeben
`>`	Testet, ob ein Ausdruck "größer als" ist. Gibt "true" zurück, wenn expr1 größer als expr2 ist.	x > 10 gibt "true" zurück, wenn der Wert von x größer als 10 ist. Andernfalls wird "false" zurückgegeben
`>=`	Testet, ob ein Ausdruck "größer/gleich" ist. Gibt "true" zurück, wenn expr1 größer als oder gleich expr2 ist.	x >= 10 gibt "true" zurück, wenn der Wert von x größer als oder gleich 10 ist. Andernfalls wird "false" zurückgegeben
`<`	Testet, ob ein Ausdruck "kleiner als" ist. Gibt "true" zurück, wenn expr1 kleiner als expr2 ist.	x < 10 gibt "true" zurück, wenn der Wert von x kleiner als 10 ist. Andernfalls wird "false" zurückgegeben
`<=`	Testet, ob ein Ausdruck "kleiner/gleich" ist. Gibt "true" zurück, wenn expr1 kleiner oder gleich expr2 ist.	x <= 10 gibt "true" zurück, wenn der Wert von x kleiner als 10 ist. Andernfalls wird "false" zurückgegeben
`\|\|`	Verkettet zwei Zeichenfolgen.	`'XYZ' \|\| 'hello'` gibt `'XYZhello'` zurück
`BETWEEN`	Bewertet einen Bereich.	`FILTER_1.BANK.BANK_ID BETWEEN 1003 AND 1007`
`IN`	Testet, ob ein Ausdruck mit einer Werteliste übereinstimmt.	`FILTER_2.ORDERS.ORDER_ID IN (1003, 1007)`

Zeichenfolgenfunktionen


Funktionen	Beschreibung	Beispiel
`CAST(value AS type)`	Gibt den angegebenen Wert im angegebenen Typ zurück.	`CAST("10" AS INT)` gibt `10` zurück
`CONCAT(string, string)`	Gibt die kombinierten Werte von Zeichenfolgen oder Spalten zurück.	`CONCAT('Oracle','SQL')` gibt `OracleSQL` zurück
`CONCAT_WS(separator, expression1, expression2, expression3,...)`	Gibt die kombinierten Werte von Zeichenfolgen oder Spalten mit dem angegebenen Trennzeichen zwischen den Zeichenfolgen oder Spalten zurück. Ein Trennzeichen ist erforderlich und muss eine Zeichenfolge sein. Nach dem Trennzeichen muss mindestens ein Ausdruck angegeben werden. Beispiel: `CONCAT_WS(',' col1)`	`CONCAT_WS('-', 'Hello', 'Oracle')` gibt `Hello-Oracle` zurück `CONCAT_WS(' ', address, city, postal_code)` gibt `123 MyCity 987654` zurück Wenn ein untergeordnetes Element der Funktion ein Array ist, wird das Array vereinfacht: `CONCAT_WS(',', 1,2,3, to_array(4,5,6), to_array(7,8), 9)` gibt `1,2,3,4,5,6,7,8,9` zurück
`INITCAP(string)`	Gibt die Zeichenfolge so zurück, dass jedes Wort mit einem Großbuchstaben beginnt, die anderen Buchstaben Kleinbuchstaben sind und die einzelnen Wörter durch ein Leerzeichen getrennt werden.	`INITCAP('oRACLE sql')` gibt `Oracle Sql` zurück
`INSTR(string, substring[start_position])`	Gibt den (1-basierten) Index des ersten Vorkommens von `substring` in `string` zurück.	`INSTR('OracleSQL', 'SQL')` gibt `7` zurück
`LOWER(string)`	Gibt die Zeichenfolge zurück, wobei alle Buchstaben in Kleinbuchstaben umgewandelt werden.	`LOWER('ORACLE')` gibt `oracle` zurück
`LENGTH(string)`	Gibt die Länge der Zeichenfolge in Zeichen oder die Anzahl der Byte von Binärdaten zurück. Nachgestellte Leerzeichen werden mitgezählt.	`LENGTH('Oracle')` gibt `6` zurück
`LTRIM(string)`	Gibt die Zeichenfolge zurück, wobei vorangestellte Leerzeichen von links entfernt werden.	`LTRIM(' Oracle')`
`NVL(expr1, epxr2)`	Gibt das Argument zurück, das nicht Null ist.	`NVL(EXPRESSION_3.CUSTOMERS_JSON.CONTINENT_ID, ROWID())`
`REGEXP_SUBSTR(string, regexp[, RegexGroupIdx])`	Sucht und extrahiert die Zeichenfolge, die einem regulären Ausdrucksmuster aus der Eingabezeichenfolge entspricht. Wenn der optionale Erfassungsgruppenindex angegeben ist, extrahiert die Funktion die spezifische Gruppe.	`REGEXP_SUBSTR('https://www.oracle.com/products', 'https://([[:alnum:]]+\.?){3,4}/?')` gibt `https://www.oracle.com` zurück `REGEXP_SUBSTR('22;33;44', '([0-9.]);([0-9.]);([0-9.]*)', 1)` gibt `22` zurück
`REPLACE(string, search, replacement)`	Ersetzt alle Vorkommen von `search` durch `replacement`. Wird `search` nicht in der Zeichenfolge gefunden, wird die Zeichenfolge unverändert zurückgegeben. Wenn `replacement` nicht angegeben oder eine leere Zeichenfolge ist, wird `search` durch nichts ersetzt und aus `string` entfernt.	`REPLACE('ABCabc', 'abc', 'DEF')` gibt `ABCDEF` zurück
`RTRIM(string)`	Gibt die Zeichenfolge zurück, wobei vorangestellte Leerzeichen von rechts entfernt werden.	`RTRIM('Oracle ')`
`SUBSTRING(string, position[, substring_length])`	Gibt die erste Teilzeichenfolge ab der Position zurück.	`SUBSTRING('Oracle SQL' FROM 2 FOR 3)` gibt `rac` zurück
Für Zahlen, `TO_CHAR(expr)` und für Datumsangaben `TO_CHAR(expr, format[, locale])`	Konvertiert Zahlen und Datumsangaben in Zeichenfolgen. Für Zahlen ist kein Format erforderlich. Verwenden Sie für Datumsangaben dasselbe Format wie `DATE_FORMAT`, das unter Datums- und Zeitfunktionen beschrieben wird. Das Standardgebietsschema ist `en-US`. Siehe unterstützte Sprachtags. In Pipelineausdrücken muss `format_string` die strftime-Formatcodes verwenden. Andernfalls werden folgende Datumsformatmuster unterstützt: yy: Zweistelliges Jahr yyyy: Vierstelliges Jahr M: Numerischer Monat, z.B. 1 für Januar MM: Numerischer Monat, z.B. 01 für Januar MMM: Abgekürzter Monat, z.B. Jan MMMM: Vollständiger Monat, z.B. Januar d: Numerischer Tag des Monats, z.B. 1 für den 1. Juni dd: Numerischer Tag des Monats, Beispiel: 01 für den 1. Juni DDD: Numerischer Tag des Jahres von 001 bis 366, z.B. 002 für den 2. Januar F: Numerischer Wochentag in einem Monat, z.B. 3 für den 3. Montag im Juni. EEE oder E: Abgekürzter benannter Tag der Woche, z.B. Sun für Sonntag EEEE: Benannter Tag der Woche, z.B. Sonntag HH: 24-Stunden-Format von 00 bis 23 H: 24-Stunden-Format von 0 bis 23 hh: das 12-Stunden-Format von 01 bis 12 h: 12-Stunden-Format von 1 bis 12 mm: Minuten von 00 bis 59 ss: Sekunden von 00 bis 59 SSS: Millisekunden von 000 bis 999 a: AM oder PM z: Zeitzone wie PDT	Zahlenbeispiel: `TO_CHAR(123)` gibt `123` zurück Datumsbeispiel: `TO_CHAR(Date '2020-10-30', 'yyyy.MM.dd', 'en-US')` gibt die Zeichenfolge `2020.10.30` zurück. Das erste Argument ist ein Datumsobjekt, das für den 30. Oktober 2020 steht.
`UPPER(string)`	Gibt eine Zeichenfolge zurück, wobei alle Buchstaben in Großbuchstaben geändert werden.	`UPPER('oracle')` gibt `ORACLE` zurück
`LPAD(str, len[, pad])`	Gibt eine Zeichenfolge zurück, die links mit angegebenen Zeichen auf eine bestimmte Länge aufgefüllt wird. Wenn Sie das pad-Zeichen auslassen, wird standardmäßig ein Speicherplatz verwendet.	`LPAD('ABC', 5, '')` gibt `'*ABC'` zurück
`RPAD(str, len[, pad])`	Gibt eine Zeichenfolge zurück, die rechts mit angegebenen Zeichen auf eine bestimmte Länge aufgefüllt wird. Wenn Sie das pad-Zeichen auslassen, wird standardmäßig ein Speicherplatz verwendet.	`RPAD('XYZ', 6, '+' ) returns 'XYZ+++'`

Eindeutige-ID-Funktionen


Funktion	Beschreibung	Beispiel
`NUMERIC_ID()`	Generiert eine universell eindeutige ID, die eine 64-Bit-Zahl für jede Zeile darstellt.	`NUMERIC_ID()` gibt beispielsweise `3458761969522180096` und `3458762008176885761` zurück
`ROWID()`	Generiert monoton aufsteigende 64-Bit-Zahlen.	`ROWID()` gibt beispielsweise `0`, `1`, `2` usw. zurück
`UUID()`	Generiert eine universell eindeutige ID, die in einer 128-Bit-Zeichenfolge für jede Zeile besteht.	`UUID()` gibt zum Beispiel `20d45c2f-0d56-4356-8910-162f4f40fb6d` zurück
`MONOTONICALLY_INCREASING_ID()`	Generiert eindeutige, monoton aufsteigende 64-Bit-Ganzzahlen, die keine aufeinanderfolgenden Zahlen sind.	`MONOTONICALLY_INCREASING_ID()` gibt beispielsweise `8589934592` und `25769803776` zurück

Oracle Cloud Infrastructure-Dokumentation

Functions-(Data Flow-)Referenz