Reguläre Funktionen
Gilt für: WatchGuard Advanced EPDR
Reguläre Funktionen wirken in jeder Zeile einer SQL-Abfrage separat. Bei regulären Funktionen hängt das Ergebnis der Funktion für eine Zeile nicht von den anderen Zeilen ab.
Im Tool Erweiterte SQL-Abfrage haben reguläre Funktionen die folgenden Eigenschaften:
- Starke Typisierung — Im Gegensatz zu Standard-SQL führt WatchGuard Endpoint Security keine impliziten Umwandlungen zwischen Typen durch. Jede Funktion ist für eine spezifische Reihe von Typen geeignet. Dies bedeutet, dass Sie manchmal Typumwandlungsfunktionen nutzen müssen.
- Eliminierung gemeinsamer Unterausdrücke — Alle Ausdrücke in einer Abfrage mit derselben AST (derselbe Datensatz oder dasselbe Ergebnis des syntaktischen Parsens) werden so angesehen, als hätten sie denselben Wert. Diese Ausdrücke werden konkateniert und einmal ausgeführt. Identische Unterabfragen werden auf dieselbe Weise eliminiert.
- Ergebnistypen — Alle Funktionen geben einen einzigen Wert als Ergebnis aus (nicht mehrere Werte und nicht Null-Werte). Der Typ des Ergebnisses ist normalerweise nur von den Typen der Argumente, nicht von den Werten definiert.
- Konstanten — Zur Vereinfachung funktionieren manche Funktionen nur mit Konstanten für einige Argumente. Beispielsweise muss das rechte Argument des Operators LIKE eine Konstante sein. Fast alle Funktionen geben für Konstantenargumente eine Konstante aus. Die Ausnahme sind Funktionen, die zufällige Zahlen generieren. Die Funktion now gibt unterschiedliche Werte für Abfragen aus, die zu verschiedenen Zeiten ausgeführt wurden. Das Ergebnis gilt als Konstante, da Einheitlichkeit nur innerhalb einer einzigen Abfrage wichtig ist. Ein Konstantenausdruck gilt ebenfalls als Konstante (beispielsweise kann die rechte Hälfte des Operators LIKE aus mehreren Konstanten gebildet werden).
- NULL-Bearbeitung — Wenn mindestens eines der Argumente der Funktion NULL ist, dann ist das Funktionsergebnis ebenfalls NULL, außer bei Funktionen, bei denen dies anders angegeben ist.
- Konstanz — Funktionen können die Werte ihrer Argumente nicht ändern. Alle Änderungen werden als Ergebnis ausgegeben. Deshalb hängt das Ergebnis der Berechnung separater Funktionen nicht von der Reihenfolge ab, in der die Funktionen in der Abfrage geschrieben sind.
- Fehlerhandhabung — Manche Funktionen können eine Ausnahme generieren, wenn die Daten ungültig sind. In diesem Fall wird die Abfrage abgebrochen und es wird eine Fehlermeldung an den Client zurückgegeben.
- Argumentbewertung — In fast allen Programmiersprachen werden einige Argumente mit bestimmten Operatoren nicht bewertet, beispielsweise &&, || und ?:. Im Tool Erweiterte SQL-Abfrage werden die Argumente von Funktionen (Operatoren) immer bewertet. Dies liegt daran, dass ganze Teile der Spalten gleichzeitig bewertet werden, anstatt jede Zeile einzeln zu berechnen.
Dies sind die wichtigsten Funktionen:
- Arithmetische Funktionen
- Vergleichsfunktionen
- Logische Funktionen
- Typumwandlungsfunktionen
- Funktionen für die Arbeit mit Zeichenfolgen
- Funktionen für die Suche nach Zeichenfolgen
- Funktionen für das Ersetzen von Zeichenfolgen
- Mathematische Funktionen
- Rundungsfunktionen
- Zufallszahlengeneratorfunktionen
- Codierungsfunktionen
- Funktionen zur Arbeit mit URLs
- Funktionen zur Arbeit mit IP-Adressen
- Funktionen zur Arbeit mit Nullable-Argumenten
Arithmetische Funktionen
Für alle arithmetischen Funktionen wird der Ergebnistyp als der kleinste Zahlentyp berechnet, in den das Ergebnis passt, wenn es einen solchen Typ gibt. Das Minimum wird gleichzeitig auf Basis der Anzahl der Bits, ob mit oder ohne Vorzeichen und ob es sich um eine Gleitkommazahl handelt ermittelt. Wenn es nicht genügend Bits gibt, dann wird der höchste Bittyp gewählt.
Arithmetische Funktionen funktionieren für jedes Paar von Typen aus UInt8, UInt16, UInt32, UInt64, Int8, Int16, Int32, Int64, Float32 oder Float64.
| Funktion | Beschreibung |
|---|---|
|
plus(a, b) a + b operator |
Berechnet die Summe von zwei Zahlen. Sie können auch Integer mit einem Datum (Date) oder Datum und Zeit (DateTime) addieren. Im Falle eines Datums korrespondiert die Addition eines Integers mit der Anzahl der hinzugefügten Tage. Bei einem Datum mit Uhrzeit korrespondiert die Addition eines Integers mit der Anzahl der hinzugefügten Sekunden. |
|
minus(a, b) a - b operator |
Berechnet den Unterschied zwischen zwei Zahlen. Das Ergebnis hat immer ein Vorzeichen. Sie können auch Integer von einem Datum (Date) oder von Datum und Zeit (DateTime) abziehen. |
|
divide (a, b) a / b operator |
Berechnet den Quotienten der Zahlen. Der Ergebnistyp ist stets vom Typ Gleitkomma. Es ist keine Integerdivision. Verwenden Sie für die Integerdivision die Funktion intDiv. Wenn Sie durch Null teilen, erhalten Sie inf, -inf oder nan. |
|
intDiv (a, b) |
Berechnet den Quotienten der Zahlen. Dividiert in Integer und rundet ab (nach dem absoluten Wert). Es kommt zu einer Ausnahme, wenn durch Null dividiert wird oder wenn eine minimale negative Zahl durch minus Eins dividiert wird. |
|
intDivOrZero (a, b) |
Unterscheidet sich von intDiv, weil Null ausgegeben wird, wenn durch Null dividiert oder wenn eine minimale negative Zahl durch minus Eins dividiert wird. |
|
module (a, b) a % b operator |
Berechnet den Rest nach der Division. Wenn es sich bei Argumenten um Gleitkommazahlen handelt, werden diese zuvor zu Integer umgewandelt. Der Rest wird im selben Sinn wie C++ ermittelt. Eine Ganzzahldivision wird für negative Zahlen verwendet. Es kommt zu einer Ausnahme, wenn durch Null dividiert wird oder wenn eine minimale negative Zahl durch minus Eins dividiert wird. |
|
negate(a) -a operator |
Berechnet eine Zahl mit dem umgekehrten Vorzeichen. Das Ergebnis hat immer ein Vorzeichen. |
|
abs (a) |
Berechnet den Absolutwert der Zahl (a). Das heißt, wenn a < 0, wird -a ausgegeben. Bei Typen ohne Vorzeichen passiert überhaupt nichts. Bei Integer-Typen mit Vorzeichen wird eine Zahl ohne Vorzeichen ausgegeben. |
|
gcd (a, b) |
Gibt den größten gemeinsamen Teiler der Zahlen aus. Es kommt zu einer Ausnahme, wenn durch Null dividiert wird oder wenn eine minimale negative Zahl durch minus Eins dividiert wird. |
|
lcm(a, b) |
Gibt das kleinste gemeinsame Vielfache der Zahlen aus. Es kommt zu einer Ausnahme, wenn durch Null dividiert wird oder wenn eine minimale negative Zahl durch minus Eins dividiert wird. |
Vergleichsfunktionen
Vergleichsfunktionen geben immer 0 oder 1 aus (Uint8). Die folgenden Typen können verglichen werden:
- Zahlen
- Zeichenketten (String) und Zeichenfolgen fester Länge (FixedString(N))
- Datum (Date)
- Datum mit Uhrzeit (DateTime)
Beispielsweise können Sie ein Datum nicht mit einer Zeichenfolge vergleichen. Sie müssen eine Funktion nutzen, um die Zeichenfolge in ein Datum umzuwandeln oder umgekehrt.
Zeichenfolgen werden nach Bytes verglichen. Eine kürzere Zeichenfolge ist kleiner als alle Zeichenfolgen, die damit beginnen und mindestens ein zusätzliches Zeichen enthalten.
Die Vergleichsoperatoren sind:
- Equals — a = b und a == b
- NotEquals — a != b und a <> b
- Less — a < b
- Greater — a > b
- LessOrEquals — a <= b
- GreaterOrEquals — a >= b
Logische Funktionen
Logische Funktionen akzeptieren alle Zahlentypen, aber geben eine UInt8-Zahl aus, die 0 oder 1 entspricht.
Null als Argument gilt als „false“, während alle Nicht-Null-Werte als „true“ gelten.
-
AND — AND
-
OR — OR
-
Not — NOT
-
Xor — XOR
Typumwandlungsfunktionen
Die grundlegenden unterstützten Umwandlungen sind:
-
Umwandlung zu Datentypen ohne Vorzeichen — toUInt8, toUInt16, toUInt32, toUInt64
-
Umwandlung zu Datentypen mit Vorzeichen — toInt8, toInt16, toInt32, toInt64, toFloat32, toFloat64, toDate, toDateTime
-
Umwandlung zu Null falls Fehler — toUInt8OrZero, toUInt16OrZero, toUInt32OrZero, toUInt64OrZero, toInt8OrZero, toInt16OrZero, toInt32OrZero, toInt64OrZero, toFloat32OrZero, toFloat64OrZero, toDateOrZero, toDateTimeOrZero
-
Umwandlung zu Null falls Fehler — toUInt8OrNull, toUInt16OrNull, toUInt32OrNull, toUInt64OrNull, toInt8OrNull, toInt16OrNull, toInt32OrNull, toInt64OrNull, toFloat32OrNull, toFloat64OrNull, toDateOrNull, toDateTimeOrNull
Die folgenden sind komplexere Datentypumwandlungen:
| Funktion | Beschreibung |
|---|---|
|
toDecimal32(value, S), toDecimal64(value, S), toDecimal128(value, S) |
Diese Funktion wandelt value zu einer Dezimalzahl mit der Genauigkeit S um. Der Wert kann eine Zahl oder eine Zeichenfolge sein. Der Parameter S legt die Anzahl der Dezimalstellen fest. |
|
toString |
Diese Funktion wandelt Zahlen, Zeichenfolgen (aber keine festen Zeichenfolgen), Daum (Dates) und Datum mit Zeit (DateTime) um. Alle diese Funktionen akzeptieren ein Argument. Wenn die Funktion in oder von einer Zeichenfolge umgewandelt wird, dann wird der Wert mit denselben Richtlinien formatiert oder bearbeitet, die für das durch Tab getrennte Format (TSV) gelten. Wenn die Zeichenfolge nicht geparst werden kann, dann wird eine Ausnahme ausgegeben und die Anfrage abgebrochen. Wenn die Funktion Datumsangaben zu Zahlen oder umgekehrt umwandelt, dann entspricht das Datum der Anzahl Tage seit Beginn der Unix-Zeit (1.1.1970). Dies sind die Datums- und Datum-mit-Zeit-Formate für die Funktionen toDate/toDateTime: JJJJ-MM-TT JJJJ-MM-TT hh: mm: ss Ausnahme: Wenn die Funktion von den Zahlentypen UInt32, Int32, UInt64 oder Int64 zu Datum umwandelt und die Zahl größer gleich 65536 ist, dann wird die Zahl als Unix-Zeitstempel interpretiert (und nicht als die Anzahl der Tage). Dies unterstützt das Schreiben von toDate (unix_timestamp), welches andernfalls einen Fehler verursachen und das Schreiben als toDate (toDateTime (unix_timestamp)) erfordern würde. Die Umwandlung zwischen einem Datum (Date) und einem Datum mit Zeit (DateTime) wird auf natürliche Weise durchgeführt (das heißt durch Hinzufügen einer Null-Zeit oder Löschen der Zeit). Die Umwandlung zwischen numerischen Typen verwendet dieselben Richtlinien wie Zuweisungen zwischen verschiedenen numerischen Typen in C++. Außerdem kann die Funktion toString des Arguments DateTime ein zweites Zeichenfolgenargument nehmen, das den Namen der Zeitzone beinhaltet. |
|
toFixedString(s, N) |
Diese Funktion wandelt ein Argument des Typs String zu einem Typ FixedString(N) (eine Zeichenfolge mit fester Länge N) um. N muss eine Konstante sein. Wenn die Zeichenfolge weniger Bytes als N hat, wird sie mit Null Bytes rechts abgewickelt. Wenn die Zeichenfolge mehr Bytes als N hat, wird eine Ausnahme ausgegeben. |
|
toStringCutToZero(s) |
Diese Funktion akzeptiert als Argument String oder FixedString. Sie gibt die Zeichenfolge mit dem Inhalt am ersten gefundenen Null-Byte abgeschnitten aus. |
|
reinterpretAsUInt8, reinterpretAsUInt16, reinterpretAsUInt32, reinterpretAsUInt64 reinterpretAsInt8, reinterpretAsInt16, reinterpretAsInt32, reinterpretAsInt64 reinterpretAsFloat32, reinterpretAsFloat64 reinterpretAsDate, reinterpretAsDateTime |
Diese Funktionen akzeptieren eine Zeichenfolge und interpretieren die Bytes am Anfang der Zeichenfolge als Zahl (Little-Endian). Wenn die Zeichenfolge zu kurz ist, gehen die Funktionen so vor, als ob die Zeichenfolge mit der notwendigen Zahl Null-Bytes ausgestattet wäre. Falls die Zeichenfolge länger als nötig ist, werden die zusätzlichen Bytes ignoriert. Ein Datum (Date) wird als die Anzahl der Tage seit Beginn der Unix-Zeit (1.1.1970) und ein Datum mit Zeit (DateTime) als die Anzahl Sekunden seit Beginn der Unix-Zeit interpretiert. |
|
reinterpretAsString |
Diese Funktion akzeptiert eine Zahl oder ein Datum (Date) oder ein Datum mit Zeit (DateTime) und gibt eine Zeichenfolge mit Bytes aus, die den entsprechenden Wert im Format Little-Endian darstellen. Null-Bytes am Ende werden weggelassen. Beispielsweise ist ein UInt32 Typwert von 255 eine Zeichenfolge, die einen Byte lang ist. |
|
reinterpretAsFixedString |
Diese Funktion akzeptiert eine Zahl, ein Datum (Date) oder ein Datum mit Zeit (DateTime) und gibt einen FixedString mit Bytes aus, die einen entsprechenden Wert im Format Little-Endian darstellen. Null-Bytes am Ende werden weggelassen. Beispielsweise ist ein UInt32 Typwert von 255 ein FixedString, der einen Byte lang ist. |
|
CAST(x, t) |
Diese Funktion wandelt x zum Datentyp t um. |
|
toIntervalYear, toIntervalQuarter, toIntervalMonth, toIntervalWeek, toIntervalDay, toIntervalHour, toIntervalMinute, toIntervalSecond |
Diese Funktion wandelt ein Argument des Zahlentyps zu einem Intervalltyp (Dauer) um. Der Intervalltyp ist sehr nützlich, weil Sie diese Art Daten nutzen können, um arithmetische Operationen mit Date oder DateTime direkt durchzuführen. |
|
parseDateTimeBestEffort |
Diese Funktion parst ein Argument des Zahlentyps zum Typ Date oder DateTime. Im Gegensatz zu toDate und toDateTime kann parseDateTimeBestEffort ein komplexeres Datumsformat ausgeben. |
|
parseDateTimeBestEffortOrNull |
Diese Funktion parst ein Argument des Zahlentyps zum Typ Date oder DateTime. Im Gegensatz zu toDate und toDateTime kann parseDateTimeBestEffort ein komplexeres Datumsformat ausgeben. Sie gibt auch Null aus, wenn sie auf ein Datumsformat trifft, das nicht bearbeitet werden kann. |
|
parseDateTimeBestEffortOrZero |
Diese Funktion parst ein Argument des Zahlentyps zum Typ Date oder DateTime. Im Gegensatz zu toDate und toDateTime kann parseDateTimeBestEffort ein komplexeres Datumsformat ausgeben. Sie gibt auch Null Date oder Null Date Time aus, wenn sie auf ein Datumsformat trifft, das nicht bearbeitet werden kann. |
Funktionen zum Umgang mit Datums- und Zeitangaben
Alle Funktionen, die Datum und Zeit nutzen und eine logische Verwendung für die Zeitzone haben, können ein zweites optionales Argument Zeitzone nutzen. Es werden nur Zeitzonen unterstützt, die sich um eine ganze Stundenzahl von UTC unterscheiden.
| Funktion | Beschreibung |
|---|---|
|
toTimeZone |
Wandelt Zeit (Date) oder Datum und Zeit (DateTime) zur angegebenen Zeitzone um. |
|
toYear |
Wandelt ein Datum (Date) oder ein Datum mit Zeit (DateTime) zu einer UInt16 Zahl mit der Jahreszahl um. |
|
toQuarter |
Wandelt ein Datum (Date) oder ein Datum mit Zeit (DateTime) zu einer UInt8 Zahl mit der Quartalszahl um. |
|
toMonth |
Wandelt ein Datum (Date) oder ein Datum mit Zeit (DateTime) zu einer UInt8 Zahl mit der Monatsnummer (1-12) um. |
|
toDayOfYear |
Wandelt ein Datum (Date) oder ein Datum mit Zeit (DateTime) zu einer UInt8 Zahl mit der Anzahl des Jahrestages (1-366) um. |
|
toDayOfMonth |
Wandelt ein Datum (Date) oder ein Datum mit Zeit (DateTime) zu einer UInt8 Zahl mit der Zahl des Monatstages (1-31) um. |
|
toDayOfWeek |
Wandelt ein Datum (Date) oder ein Datum mit Zeit (DateTime) zu einer UInt8 Zahl mit der Zahl des Wochentages (Montag ist 1 und Sonntag ist 7) um. |
|
toHour |
Wandelt ein Datum (Date) oder ein Datum mit Zeit (DateTime) zu einer UInt8 Zahl mit der Zahl der Stunde im 24-Stunden-Format (0-23) um. Diese Funktion geht davon aus, dass die Uhr bei Sommerzeit um 2 Uhr früh um eine Stunde vor gestellt wird. Bei Ende der Sommerzeit wird sie um 3 Uhr früh um eine Stunde zurückgestellt. |
|
toMinute |
Wandelt ein Datum (Date) oder ein Datum mit Zeit (DateTime) zu einer UInt8 Zahl mit der Zahl der Minute der Stunde (0-59) um. |
|
toSecond |
Wandelt ein Datum (Date) oder ein Datum mit Zeit (DateTime) zu einer UInt8 Zahl mit der Zahl der Sekunde in der Minute (0-59) um. Schaltsekunden werden nicht berücksichtigt. |
|
toUnixTimestamp |
Wandelt ein Datum (Date) oder ein Datum mit Zeit (DateTime) zu einem Unix-Zeitstempel um. |
|
toStartOfYear |
Rundet ein Datum (Date) oder ein Datum mit Zeit (DateTime) auf den ersten Tag des Jahres ab. Sie gibt das Datum (Date) aus. |
|
toStartOfISOYear |
Rundet ein Datum (Date) oder ein Datum mit Zeit (DateTime) auf den ersten Tag des ISO-Jahres ab. Sie gibt das Datum (Date) aus. |
|
toStartOfQuarter |
Rundet ein Datum (Date) oder ein Datum mit Zeit (DateTime) auf den ersten Tag des Quartals ab (1. Januar, 1. April, 1. Juli oder 1. Oktober). Sie gibt das Datum (Date) aus. |
|
toStartOfMonth |
Rundet ein Datum (Date) oder ein Datum mit Zeit (DateTime) auf den ersten Tag des Monats ab. Sie gibt das Datum (Date) aus. |
|
toMonday |
Rundet ein Datum (Date) oder ein Datum mit Zeit (DateTime) auf den nächstgelegenen Montag ab. Sie gibt das Datum (Date) aus. |
|
toStartOfDay |
Rundet ein Datum (Date) oder ein Datum mit Zeit (DateTime) auf den Anfang des Tages ab. |
|
toStartOfHour |
Rundet ein Datum (Date) oder ein Datum mit Zeit (DateTime) auf den Anfang der Stunde ab. |
|
toStartOfMinute |
Rundet ein Datum (Date) oder ein Datum mit Zeit (DateTime) auf den Anfang der Minute ab. |
|
toStartOfFiveMinute |
Rundet ein Datum (Date) oder ein Datum mit Zeit (DateTime) auf den Anfang des Fünf-Minuten-Intervalls ab. |
|
toStartOfTenMinutes |
Rundet ein Datum (Date) oder ein Datum mit Zeit (DateTime) auf den Anfang des Zehn-Minuten-Intervalls ab. |
|
toStartOfFifteenMinutes |
Rundet ein Datum (Date) oder ein Datum mit Zeit (DateTime) auf den Anfang des 15-Minuten-Intervalls ab. |
|
toTime |
Wandelt ein Datum (Date) oder ein Datum mit Zeit (DateTime) zu einem bestimmten festen Datum um und behält die Zeit bei. |
|
toRelativeYearNum |
Wandelt ein Datum (Date) oder ein Datum mit Zeit (DateTime) zu der Zahl des Jahres ab einem bestimmten festen Zeitpunkt in der Vergangenheit um. |
|
toRelativeQuarterNum |
Wandelt ein Datum (Date) oder ein Datum mit Zeit (DateTime) zu der Zahl des Quartals ab einem bestimmten festen Zeitpunkt in der Vergangenheit um. |
|
toRelativeMonthNum |
Wandelt ein Datum (Date) oder ein Datum mit Zeit (DateTime) zu der Zahl des Monats ab einem bestimmten festen Zeitpunkt in der Vergangenheit um. |
|
toRelativeWeekNum |
Wandelt ein Datum (Date) oder ein Datum mit Zeit (DateTime) zu der Zahl der Woche ab einem bestimmten festen Zeitpunkt in der Vergangenheit um. |
|
toRelativeDayNum |
Wandelt ein Datum (Date) oder ein Datum mit Zeit (DateTime) zu der Zahl des Tages ab einem bestimmten festen Zeitpunkt in der Vergangenheit um. |
|
toRelativeHourNum |
Wandelt ein Datum (Date) oder ein Datum mit Zeit (DateTime) zu der Zahl der Stunde ab einem bestimmten festen Zeitpunkt in der Vergangenheit um. |
|
toRelativeMinuteNum |
Wandelt ein Datum (Date) oder ein Datum mit Zeit (DateTime) zu der Zahl der Minute ab einem bestimmten festen Zeitpunkt in der Vergangenheit um. |
|
toRelativeSecondNum |
Wandelt ein Datum (Date) oder ein Datum mit Zeit (DateTime) zu der Zahl der Sekunde ab einem bestimmten festen Zeitpunkt in der Vergangenheit um. |
|
toISOYear |
Wandelt ein Datum (Date) oder ein Datum mit Zeit (DateTime) zu einer UInt16-Zahl mit der ISO-Jahreszahl um. |
|
toISOWeek |
Wandelt ein Datum (Date) oder ein Datum mit Zeit (DateTime) zu einer UInt8-Zahl mit der ISO-Wochenzahl um. |
|
now |
Akzeptiert Null-Argumente. Sie gibt die aktuelle Zeit zur Zeit der Funktionsausführung aus. Diese Funktion gibt eine Konstante aus. |
|
today |
Akzeptiert Null-Argumente. Sie gibt das aktuelle Datum zur Zeit der Funktionsausführung aus. Identisch mit toDate (now ()). |
|
yesterday |
Akzeptiert Null-Argumente. Sie gibt das Vortagesdatum zur Zeit der Funktionsausführung aus. Identisch mit today () - 1. |
|
timeSlot |
Rundet die Zeit zur halben Stunde. |
|
toYYYYMM |
Wandelt ein Datum (Date) oder ein Datum mit Zeit (DateTime) in eine UInt32-Zahl mit der Jahres- und Monatszahl um (JJJJ * 100 + MM). |
|
toYYYYMMDD |
Wandelt ein Datum (Date) oder ein Datum mit Zeit (DateTime) in eine UInt32-Zahl mit der Jahres- und Monatszahl um (JJJJ * 10000 + MM * 100 + TT). |
|
toYYYYMMDDhhmmss |
Wandelt ein Datum (Date) oder ein Datum mit Zeit (DateTime) in eine UInt64-Zahl mit der Jahres- und Monatszahl um (JJJJ * 10000000000 + MM * 100000000 + TT * 1000000 + hh * 10000 + mm * 100 + ss). |
|
addYears, addMonths, addWeeks, addDays, addHours, addMinutes, addSeconds, addQuarters |
Diese Funktion fügt ein Intervall Date/DateTime zu einer Variablen Date/DateTime hinzu und gibt dann Date/DateTime aus. |
|
subtractYears, subtractMonths, subtractWeeks, subtractDays, subtractHours, subtractMinutes, subtractSeconds, subtractQuarters |
Diese Funktion zieht ein Intervall Date/DateTime von einer Variablen Date/DateTime ab und gibt dann Date/DateTime aus. |
|
dateDiff('unit', t1, t2, [timezone]) |
Gibt den Unterschied zwischen zwei Zeiten ausgedrückt in unit aus, beispielsweise hours. t1 und t2 können Date oder DateTime sein. Wenn timezone angegeben ist, gilt sie für beide Argumente. Falls nicht, werden Zeitzonen von Datentypen t1 und t2 verwendet. Wenn die Zeitzonen nicht gleich sind, ist das Ergebnis unbestimmt. Unterstützte Einheitswerte: Sekunde, Minute, Stunde, Tag, Woche, Monat, Quartal, Jahr. |
|
formatDateTime(Time, Format[, Timezone]) |
Diese Funktion formatiert Time gemäß dem in der Zeichenfolge Format angegebenen Formats. Weitere Informationen zu Format-Parametern finden Sie unter %%. |
Format-Codes für die Funktion formatDateTime
Diese Tabelle beschreibt die Format-Codes für die Funktion formatDateTime mit Beispielen:
| Code | Beschreibung | Beispiel |
|---|---|---|
|
%C |
Jahr geteilt durch 100 und gekürzt zu Integer (00-99). |
20 |
|
%d |
Tag des Monats, Zero-Padding (01-31). |
02 |
|
%D |
Kurzes MM/TT/JJ Datum, äquivalent zu %m/%d/%y. |
2023-01-07 |
|
%e |
Tag des Monats, Space-Padding ( 1-31) |
2 |
|
%F |
Kurzes JJJJ-MM-TT Datum, äquivalent zu %Y-%m-%d. |
2023-01-07 |
|
%H |
Stunde im 24-Stunden-Format (00-23). |
22 |
|
%I |
Stunde im 12-Stunden-Format (01-12). |
10 |
|
%j |
Tag des Jahres (001-366). |
007 |
|
%m |
Monat als Dezimalzahl (01-12). |
01 |
|
%M |
Minute (00-59). |
33 |
|
%n |
Neue-Zeile-Zeichen. '\n'. |
|
|
%p |
AM oder PM. |
PM |
|
%R |
24-Stunden-Zeit HH:MM, äquivalent zu %H:%M. |
22:33 |
|
%S |
Sekunde (00-59). |
44 |
|
%t |
Horizontales-Tab-Zeichen (‘\t'). |
|
|
%T |
ISO 8601 Zeitformat (HH:MM:SS), äquivalent mit %H:%M:%S. |
22:33:44 |
|
%u |
ISO 8601 Wochentag als Zahl mit Montag als 1 (1-7). |
2 |
|
%V |
ISO 8601 Wochenzahl (01-53). |
01 |
|
%w |
Wochentag als Dezimalzahl mit Sonntag als 0 (0-6). |
2 |
|
%y |
Jahr, letzte zwei Stellen (00-99). |
23 |
|
%Y |
Jahr |
2023 |
|
Ein % Zeichen. |
|
Funktionen für die Arbeit mit Zeichenfolgen
Diese Tabelle beschreibt die String-Funktionen:
| Funktion | Beschreibung |
|---|---|
|
empty |
Gibt 1 für einen leeren String oder 0 für einen nicht-leeren String aus. Der Ergebnistyp ist UInt8. Eine Zeichenfolge gilt als nicht-leer, wenn sie mindestens ein Byte beinhaltet, selbst wenn dies ein Leerzeichen oder ein Null-Byte ist. |
|
notEmpty |
Gibt 0 für einen leeren String oder 1 für einen nicht-leeren String aus. Der Ergebnistyp ist UInt8. Die Funktion funktioniert auch für Arrays. |
|
length |
Gibt die Länge einer Zeichenfolge in Byte aus (nicht in Zeichen und nicht in Code-Punkten). Der Ergebnistyp ist UInt64. |
|
lengthUTF8 |
Gibt die Länge einer Zeichenfolge in Unicode-Code-Punkten (nicht in Zeichen) aus, wenn die Zeichenfolge eine Reihe von Bytes beinhaltet, die einen UTF-8-codierten Text darstellt. Wenn die Zeichenfolge die UTF-8-Anforderung nicht erfüllt, wird keine Ausnahme generiert. Der Ergebnistyp ist UInt64. |
|
char_length, CHAR_LENGTH |
Gibt die Länge einer Zeichenfolge in Unicode-Code-Punkten (nicht in Zeichen) aus, vorausgesetzt die Zeichenfolge beinhaltet eine Reihe von Bytes, die einen UTF-8-codierten Text darstellt. Wenn diese Annahme nicht erfüllt ist, wird keine Ausnahme generiert. Der Ergebnistyp ist UInt64. |
|
character_length, CHARACTER_LENGTH |
Gibt die Länge einer Zeichenfolge in Unicode-Code-Punkten (nicht in Zeichen) aus, vorausgesetzt die Zeichenfolge beinhaltet eine Reihe von Bytes, die einen UTF-8-codierten Text darstellt. Wenn diese Annahme nicht erfüllt ist, wird keine Ausnahme generiert. Der Ergebnistyp ist UInt64. |
|
lower, lcase |
Wandelt lateinische ASCII-Symbole in eine Zeichenfolge aus Kleinbuchstaben um. |
|
upper, ucase |
Wandelt lateinische ASCII-Symbole in eine Zeichenfolge aus Großbuchstaben um. |
|
lowerUTF8 |
Wandelt eine Zeichenfolge in Kleinbuchstaben um, vorausgesetzt die Zeichenfolge beinhaltet eine Reihe von Bytes, die einen UTF-8-codierten Text darstellt. Sie erkennt nicht die Sprache. Wenn sich die Länge der UTF-8-Byte-Sequenz für Groß- und Kleinbuchstaben eines Code-Punkts unterscheidet, könnte das Ergebnis falsch sein. Falls die Zeichenfolge eine Reihe von Bytes beinhaltet, die nicht UTF-8 sind, dann ist das Verhalten undefiniert. |
|
upperUTF8 |
Wandelt eine Zeichenfolge in Großbuchstaben um, vorausgesetzt die Zeichenfolge beinhaltet eine Reihe von Bytes, die einen UTF-8-codierten Text darstellt. Sie erkennt nicht die Sprache. Wenn sich die Länge der UTF-8-Byte-Sequenz für Groß- und Kleinbuchstaben eines Code-Punkts unterscheidet, könnte das Ergebnis falsch sein. Falls die Zeichenfolge eine Reihe von Bytes beinhaltet, die nicht UTF-8 sind, dann ist das Verhalten undefiniert. |
|
isValidUTF8 |
Gibt 1 aus, wenn die Byte-Reihe einen gültigen UTF-8-codierten Text darstellt, andernfalls wird 0 ausgegeben. |
|
reverse |
Dreht die Zeichenfolge um (als Reihenfolge von Bytes). |
|
reverseUTF8 |
Dreht eine Reihenfolge von Unicode-Code-Punkten um, vorausgesetzt die Zeichenkette beinhaltet eine Reihe von Bytes, die einen UTF-8-Text darstellt. Andernfalls wird keine Ausnahme ausgegeben. |
|
concat(s1, s2, ...) |
Konkateniert die in den Argumenten aufgeführten Zeichenfolgen ohne Trennzeichen. |
|
concatAssumeInjective(s1, s2, ...) |
Identisch mit concat. Der Unterschied ist, dass Sie sicherstellen müssen, dass concat (s1, s2, s3) -> s4 injektiv ist. Dies wird verwendet, um die Klausel GROUP BY zu optimieren. |
|
substring(s, offset, length), mid(s, offset, length), substr(s, offset, length) |
Gibt eine Teilzeichenfolge aus, die mit dem Byte aus dem offset-Index beginnt, der length Bytes lang ist. Die Indexierung der Zeichen beginnt bei eins (wie in Standard-SQL). Die Argumente offset und length müssen Konstanten sein. |
|
substringUTF8(s, offset, length) |
Identisch mit substring, aber für Unicode-Code-Punkte. Sie funktioniert unter der Annahme, dass die Zeichenfolge eine Reihe von Bytes beinhaltet, die einen UTF-8-codierten Text darstellt. Wenn diese Annahme nicht erfüllt ist, wird keine Ausnahme generiert. |
|
appendTrailingCharIfAbsent(s, c) |
Wenn die Zeichenfolge s Zeichen beinhaltet, aber nicht das Zeichen c am Ende, dann fügt sie das Zeichen c am Ende an. |
|
convertCharset(s, from, to) |
Gibt die Zeichenfolge s aus, die von der Codierung in from zur Codierung in to umgewandelt wurde. |
|
base64Encode(s) |
Codiert die Zeichenfolge s in base64. |
|
base64Decode(s) |
Decodiert die base64-codierte Zeichenfolge s in ihre ursprüngliche Zeichenfolge. Im Falle eines Misserfolgs wird eine Ausnahme generiert. |
|
tryBase64Decode(s) |
Decodiert die base64-codierte Zeichenfolge s in ihre ursprüngliche Zeichenfolge. Im Falle eines Misserfolgs wird eine leere Zeichenfolge ausgegeben. |
|
endsWith(s, suffix) |
Gibt 1 aus, falls die Zeichenfolge mit dem angegebenen Suffix endet, andernfalls wird 0 ausgegeben. |
|
startsWith(s, prefix) |
Gibt 1 aus, falls die Zeichenfolge mit dem angegebenen Präfix beginnt, andernfalls wird 0 ausgegeben. |
|
trimLeft(s) |
Gibt eine Zeichenfolge aus, die die Leerzeichen auf der linken Seite entfernt. |
|
trimRight(s) |
Gibt eine Zeichenfolge aus, die die Leerzeichen auf der rechten Seite entfernt. |
|
trimBoth(s) |
Gibt eine Zeichenfolge aus, die die Leerzeichen auf beiden Seite entfernt. |
Funktionen für die Suche nach Zeichenfolgen
Die Suche unterscheidet bei all diesen Funktionen standardmäßig zwischen Groß- und Kleinschreibung. Es gibt separate Varianten für eine Suche ohne Berücksichtigung der Groß- und Kleinschreibung. Diese Tabelle beschreibt die Suchfunktionen:
| Funktion | Beschreibung |
|---|---|
|
position(haystack, needle), locate(haystack, needle) |
Sucht nach der Teilzeichenfolge needle in der Zeichenfolge haystack. Gibt die Position (in Bytes) der gefundenen Teilzeichenfolge aus, angefangen von 1, oder gibt 0 aus, falls die Teilzeichenfolge nicht gefunden wurde. Verwenden Sie für eine Suche ohne Berücksichtigung der Groß- und Kleinschreibung die Funktion positionCaseInsensitive. |
|
positionUTF8(haystack, needle) |
Identisch mit position, aber die Position wird in Unicode-Code-Punkten ausgegeben, wenn die Zeichenfolge eine Reihe von Bytes beinhaltet, die einen UTF-8-codierten Text darstellt. Wenn diese Anforderung nicht erfüllt ist, wird keine Ausnahme generiert. Verwenden Sie für eine Suche ohne Berücksichtigung der Groß- und Kleinschreibung die Funktion positionCaseInsensitiveUTF8. |
|
multiSearchFirstPosition(haystack, [needle1, needle2, ..., needlen]) |
Identisch mit position, aber liefert den Offset der Zeichenfolge haystack ganz links, die einem Teil der needle entspricht. Verwenden Sie für eine Suche ohne Berücksichtigung der Groß-und Kleinschreibung und für eine Suche im Format UTF-8 die folgenden Funktionen: multiSearchFirstPositionCaseInsensitive multiSearchFirstPositionUTF8 multiSearchFirstPositionCaseInsensitiveUTF8 |
|
multiSearchFirstIndex(haystack, [needle1, needle2, ..., needlen]) |
Gibt den Index i (beginnend mit 1) des am weitesten links befindlichen gefundenen needle in der Zeichenfolge haystack oder andernfalls 0 aus. Verwenden Sie für eine Suche ohne Berücksichtigung der Groß-und Kleinschreibung und für eine Suche im Format UTF-8 die folgenden Funktionen: multiSearchFirstIndexCaseInsensitive multiSearchFirstIndexUTF8 multiSearchFirstIndexCaseInsensitiveUTF8 |
|
multiSearchAny(haystack, [needle1, needle2, ..., needlen]) |
Gibt 1 aus, wenn mindestens eine Zeichenfolge needle der Zeichenfolge haystack entspricht, und andernfalls 0. Verwenden Sie für eine Suche ohne Berücksichtigung der Groß-und Kleinschreibung und/oder für eine Suche im Format UTF-8 die folgenden Funktionen: multiSearchAnyCaseInsensitive, multiSearchAnyUTF8, multiSearchAnyCaseInsensitiveUTF8. Bei allen Funktionen multiSearch * muss die Anzahl der needle-Parameter kleiner 28 sein. |
|
match(haystack, pattern) |
Prüft, ob die Zeichenfolge dem regulären Musterausdruck entspricht. Die Syntax der regulären Ausdrücke re2 ist eingeschränkter als die Syntax der regulären Perl-Ausdrücke. Gibt 0 aus, wenn keine Entsprechung vorliegt, und gibt 1 aus, wenn eine Entsprechung vorliegt. Das Symbol umgekehrter Schrägstrich (\) wird verwendet, um den regulären Ausdruck zu escapen. Dasselbe Symbol wird verwendet, um String-Literals zu escapen. Um das Symbol in einem regulären Ausdruck zu escapen, müssen Sie zwei umgekehrte Schrägstriche (\\) in einem String-Literal schreiben. Der reguläre Ausdruck arbeitet mit der Zeichenfolge als wäre sie eine Reihe Bytes. Der reguläre Ausdruck kann keine Null-Bytes enthalten. Für Muster zur Suche nach Teilzeichenfolgen in einer Zeichenfolge ist es besser, LIKE oder position zu verwenden, weil dies schneller abläuft. |
|
multiMatchAny(haystack, [pattern1, pattern2, ..., patternn]) |
Prüft, ob die Zeichenfolge dem regulären Musterausdruck entspricht. Es wird 0 ausgegeben, wenn keine der regulären Ausdrücke übereinstimmen, und 1 wenn es bei den Mustern Übereinstimmungen gibt. Für Muster zur Suche nach Teilzeichenfolgen in einer Zeichenfolge ist es besser, multiSearchAny zu verwenden, weil dies schneller abläuft. Die Länge aller haystack-Zeichenfolgen darf jeweils nur 232 Bytes umfassen, sonst wird eine Ausnahme generiert. |
|
multiMatchAnyIndex(haystack, [pattern1, pattern2, ..., patternn]) |
Prüft, ob die Zeichenfolge dem regulären Musterausdruck entspricht. Es wird 0 ausgegeben, wenn keine der regulären Ausdrücke übereinstimmen, und 1 wenn es bei den Mustern Übereinstimmungen gibt. Sie gibt jeden Index aus, der dem haystack entspricht. |
|
multiFuzzyMatchAny(haystack, distance, [pattern1, pattern2, ..., patternn]) |
Identisch mit multiMatchAny, aber gibt 1 aus, wenn ein Muster innerhalb einer konstanten Bearbeitungsdistanz haystack entspricht. Diese Funktion befindet sich im experimentellen Modus und kann sehr langsam sein. |
|
multiFuzzyMatchAnyIndex(haystack, distance, [pattern1, pattern2, ..., patternn]) |
Identisch mit multiFuzzyMatchAny, aber liefert jeden Index, der innerhalb einer konstanten Bearbeitungsdistanz haystack entspricht. multiFuzzyMatch *-Funktionen unterstützen keine regulären UTF-8-Ausdrücke. Sie werden als Bytes behandelt. |
|
extract(haystack, pattern) |
Extrahiert ein Fragment einer Zeichenfolge mittels eines regulären Ausdrucks. Wenn haystack dem pattern-regex nicht entspricht, wird eine leere Zeichenfolge ausgegeben. Wenn der regex keine Untermuster beinhaltet, nimmt sie das Fragment, das dem gesamten regex entspricht. Andernfalls nimmt sie das Fragment, das dem ersten Untermuster entspricht. |
|
like(haystack, pattern), haystack LIKE pattern operator |
Prüft, ob eine Zeichenfolge einem einfachen regulären Ausdruck entspricht. Der reguläre Ausdruck kann die folgenden Symbole enthalten:
Verwenden Sie den umgekehrten Schrägstrich (\), um Metasymbole zu escapen. Das Symbol umgekehrter Schrägstrich (\) wird verwendet, um den regulären Ausdruck zu escapen. Dasselbe Symbol wird verwendet, um String-Literals zu escapen. Um das Symbol in einem regulären Ausdruck zu escapen, müssen Sie zwei umgekehrte Schrägstriche (\\) in einem String-Literal schreiben. Für reguläre Ausdrücke, wie %needle%, ist der Code optimaler und funktioniert genauso schnell wie die Funktion position. Für andere reguläre Ausdrücke ist der Code derselbe wie für die Funktion match. |
|
notLike(haystack, pattern), haystack NOT LIKE pattern operator |
Filtert Datensätze, die keinem vorgegebenen Muster entsprechen. Der reguläre Ausdruck kann die folgenden Symbole enthalten:
Verwenden Sie den umgekehrten Schrägstrich (\), um Metasymbole zu escapen. |
Funktionen für das Ersetzen von Zeichenfolgen
Diese Tabelle beschreibt die Funktionen zum Ersetzen von Zeichenfolgen:
| Funktion | Beschreibung |
|---|---|
|
replaceOne(haystack, pattern, replacement) |
Ersetzt, soweit vorhanden, das erste Auftreten der Teilzeichenfolge pattern in haystack mit der Teilzeichenfolge replacement. pattern und replacement müssen Konstanten sein. |
|
replaceAll(haystack, pattern, replacement), replace(haystack, pattern, replacement) |
Ersetzt alle Vorkommnisse der Teilzeichenfolge pattern in haystack mit der Teilzeichenfolge replacement. |
|
replaceRegexpOne(haystack, pattern, replacement) |
Ersetzung mittels des regulären Ausdrucks pattern . Ein regulärer Ausdruck re2. Ersetzt nur das erste Vorkommnis, falls vorhanden. Ein Muster kann als replacement angegeben werden. Dieses Muster kann Substitutionen \0 - \9 beinhalten. Die Substitution \0 beinhaltet den gesamten regulären Ausdruck. Substitutionen \1 - \9 entsprechen den Untermuster-Nummern. Um das Zeichen \ in einer Vorlage zu verwenden, verwenden Sie einen weiteren \, um dieses zu escapen. Denken Sie daran, dass ein String-Literal ein zusätzliches Escape erfordert. Beispielsweise kopiert die folgende Funktion eine Zeichenfolge zehn Mal: SELECT replaceRegexpOne ('Hello, World!', '. *', '\\ 0 \\ 0 \\ 0 \\ 0 \\ 0 \\ 0 \\ 0 \\ 0 \\ 0 \\ 0 \\ 0) AS res Ergebnis: Hello, World! Hello, World! Hello, World! Hello, World! Hello, World! Hello, World! Hello, World! Hello, World! Hello, World! Hello, World! ¦ |
|
replaceRegexpAll(haystack, pattern, replacement) |
Ersetzung mittels des regulären Ausdrucks pattern . Sie ersetzt alle Vorkommnisse. Beispiel: SELECT replaceRegexpAll('Hello, World!', '.', '\\0\\0') AS res HHeelllloo,, WWoorrlldd!! Wenn ein regulärer Ausdruck eine leere Teilzeichenfolge bearbeitet hat, dann wird die Ersetzung nicht mehrmals durchgeführt. Beispiel: SELECT replaceRegexpAll('Hello, World!', '^', 'here: ') AS res here: Hello, World! |
|
regexpQuoteMeta(s) |
Die Funktion fügt einen umgekehrten Schrägstrich vor vordefinierten Zeichen in der Zeichenfolge ein. Vordefinierte Zeichen: '0', '\', '|', '(', ')', '^', '$', '.', '[', ']', '?', '*' , '+', '{', ':', '-'. Diese Implementierung unterscheidet sich von re2. Das Escape von null Bytes erfolgt als \0 anstatt als \x00 und das Escape betrifft nur Pflichtzeichen. |
Mathematische Funktionen
Alle diese Funktionen liefern eine Float64-Zahl. Die Genauigkeit des Ergebnisses nähert sich der maximal möglichen Genauigkeit, aber entspricht eventuell nicht der maschinell darstellbaren Zahl, die der entsprechenden realen Zahl am nächsten ist.
| Funktion | Beschreibung |
|---|---|
|
e() |
Gibt eine Float64-Zahl aus, die der Zahl e nahe ist. |
|
pi() |
Gibt eine Float64-Zahl aus, die der Zahl π nahe ist. |
|
exp(x) |
Akzeptiert ein numerisches Argument und gibt eine Float64-Zahl aus, die dem Exponenten des Arguments nahe ist. |
|
log(x), ln(x) |
Akzeptiert ein numerisches Argument und gibt eine Float64-Zahl aus, die dem natürlichen Logarithmus des Arguments nahe ist. |
|
exp2(x) |
Akzeptiert ein numerisches Argument und gibt eine Float64-Zahl aus, die 2 hoch x nahe ist. |
|
log2(x) |
Akzeptiert ein numerisches Argument und gibt eine Float64-Zahl aus, die dem binären Logarithmus des Arguments nahe ist. |
|
exp10(x) |
Akzeptiert ein numerisches Argument und gibt eine Float64-Zahl aus, die 10 hoch x nahe ist. |
|
log10(x) |
Akzeptiert ein numerisches Argument und gibt eine Float64-Zahl aus, die dem dezimalen Logarithmus des Arguments nahe ist. |
|
sqrt(x) |
Akzeptiert ein numerisches Argument und gibt eine Float64-Zahl aus, die der Quadratwurzel des Arguments nahe ist. |
|
cbrt(x) |
Akzeptiert ein numerisches Argument und gibt eine Float64-Zahl aus, die der Kubikwurzel des Arguments nahe ist. |
|
erf(x) |
Wenn x nicht-negativ ist, dann ist erf die Wahrscheinlichkeit, dass eine zufällige Variable mit normaler Verteilung und Standardabweichung s den Wert annimmt, der vom erwarteten Wert um mehr als x abweicht. |
|
erfc(x) |
Akzeptiert ein numerisches Argument und gibt eine Float64-Zahl aus, die 1 - erf (x) nahe ist. Ohne Genauigkeitsverlust bei hohen x-Werten. |
|
lgamma(x) |
Der Logarithmus der Gamma-Funktion. |
|
tgamma(x) |
Gamma-Funktion. |
|
sin(x) |
Sinus. |
|
cos(x) |
Cosinus. |
|
tan(x) |
Tangens. |
|
asin(x) |
Arkussinus. |
|
acos(x) |
Arkuscosinus. |
|
atan(x) |
Arkustangens. |
|
pow(x, y), power(x, y) |
Nimmt zwei numerische Argumente x und y und gibt eine Float64-Zahl aus, die x hoch y nahe ist. |
|
intExp2 |
Akzeptiert ein numerisches Argument und gibt eine UInt64-Zahl aus, die 2 hoch x nahe ist. |
|
intExp10 |
Akzeptiert ein numerisches Argument und gibt eine UInt64-Zahl aus, die 10 hoch x nahe ist. |
Rundungsfunktionen
| Funktion | Beschreibung |
|---|---|
|
floor(x[, N]) |
Gibt die größte runde Zahl aus, die kleiner gleich x ist. Eine runde Zahl ist ein Vielfaches von 1/10N, oder die nächstgelegene Zahl des entsprechenden Datentyps, wenn 1 / 10N nicht genau ist. N ist eine Integer-Konstante, optionaler Parameter. Standardmäßig ist sie null. Dies rundet die Zahl zu einem Integer. N kann negativ sein. Beispiele: floor (123.45, 1) = 123.4 floor (123.45, -1) = 120. x ist ein numerischer Typ. Das Ergebnis ist eine Zahl desselben Typs. Für Integer-Argumente macht es Sinn, mit einem negativen N-Wert zu runden. Für ein nicht-negatives N bewirkt die Funktion nichts. |
|
ceil(x[, N]), ceiling(x[, N]) |
Gibt die kleinste runde Zahl aus, die größer gleich x ist. In allen anderen Aspekten ist sie mit der Funktion floor identisch. |
|
round(x[, N]) |
Rundet x zu einer angegebenen Zahl Dezimalstellen (N). Sie rundet zum nächstgelegenen geraden Integer. Wenn die gegebene Zahl zu den umgebenden Zahlen die gleiche Distanz hat, dann gibt die Funktion die Zahl aus, die die nächstgelegene gerade Ziffer hat. Parameter:
Der ausgegebene Wert ist die gerundete Zahl desselben Typs wie die Eingabezahl. |
|
roundToExp2(num) |
Akzeptiert eine Zahl. Wenn die Zahl kleiner eins ist, dann wird 0 ausgegeben. Andernfalls rundet sie die Zahl auf den nächstgelegenen (ganzen nicht-negativen) Grad zweiter Ordnung ab. |
Zufallszahlengeneratorfunktionen
Es werden nicht-kryptografische Generatoren von pseudozufälligen Zahlen verwendet. Alle Funktionen akzeptieren null Argumente oder ein Argument. Wenn ein Argument abgefertigt wird, kann es einen beliebigen Typ haben und sein Wert wird nicht verwendet. Der Zweck dieses Arguments ist es, eine Eliminierung gemeinsamer Unterausdrücke zu verhindern, so dass zwei unterschiedliche Instanzen derselben Funktion verschiedene Spalten mit unterschiedlichen Zufallszahlen ausgeben.
| Funktion | Beschreibung |
|---|---|
|
rand |
Gibt eine pseudozufällige UInt32-Zahl aus, die unter allen Zahlen des Typs UInt32 gleichmäßig verteilt ist. Sie verwendet einen linearen Kongruenzgenerator. |
|
rand64 |
Gibt eine pseudozufällige UInt64-Zahl aus, die unter allen Zahlen des Typs UInt64 gleichmäßig verteilt ist. Sie verwendet einen linearen Kongruenzgenerator. |
|
randConstant |
Gibt eine pseudozufällige UInt64-Zahl aus, die unter allen Zahlen des Typs UInt64 gleichmäßig verteilt ist. |
Codierungsfunktionen
Diese Tabelle beschreibt Codierungsfunktionen:
| Funktion | Beschreibung |
|---|---|
|
hex |
Akzeptiert Argumente der folgenden Typen: String, UInt, Date oder DateTime. Sie gibt eine Zeichenfolge aus, die die hexadezimale Darstellung des Arguments beinhaltet. Sie verwendet die Großbuchstaben A-F. Sie verwendet keine 0x-Präfixe oder h-Suffixe. Bei Zeichenketten werden alle Bytes einfach als zwei hexadezimale Zahlen codiert. Zahlen werden ins Format Big Endian umgewandelt. Date wird als die Anzahl der Tage seit Beginn der Unix-Zeit codiert. DateTime wird als die Anzahl der Sekunden seit Beginn der Unix-Zeit codiert. |
|
unhex(str) |
Akzeptiert eine Zeichenfolge mit einer Reihe hexadezimaler Stellen und gibt eine Zeichenfolge aus, die die entsprechenden Bytes enthält. Sie unterstützt sowohl Groß- als auch Kleinbuchstaben von A-F. Die Zahl der hexadezimalen Ziffern muss nicht gerade sein. Wenn sie ungerade ist, wird die letzte Stelle als die jüngere Hälfte des 00-0F-Byte interpretiert. Wenn die Argument-Zeichenfolge etwas außer hexadezimale Ziffern beinhaltet, wird keine Ausnahme generiert. Wenn Sie das Ergebnis in eine Zahl umwandeln wollen, dann können Sie die Funktionen reverse und reinterpretAsType verwenden. |
|
bitmaskToList(num) |
Akzeptiert einen Integer. Sie gibt eine Zeichenfolge aus, die die Liste der Zweierpotenzen enthält, die bei Aufsummierung der Quellzahl entsprechen. Sie werden im Textformat durch Kommas unterteilt ohne Leerzeichen in aufsteigender Reihenfolge angegeben. |
Funktionen zur Arbeit mit URLs
Diese Tabelle beschreibt Funktionen zur Arbeit mit URLs:
| Funktion | Beschreibung |
|---|---|
|
protocol |
Gibt das Protokoll aus (beispielsweise http, ftp, mailto, imap). |
|
domain |
Gibt die Domäne aus. |
|
domainWithoutWWW |
Gibt die Domäne aus und entfernt bis zu ein 'www.' von dessen Anfang, falls vorhanden. |
|
topLevelDomain |
Gibt die Top-Level-Domain aus. Beispielsweise .com. |
|
firstSignificantSubdomain |
Gibt die erste signifikante Subdomäne aus.
|
|
cutToFirstSignificantSubdomain |
Gibt den Teil der Domäne aus, der die Subdomänen der obersten Ebene bis zur ersten signifikanten Subdomäne beinhaltet. |
|
path |
Gibt den Pfad aus. Der Pfad beinhaltet die Abfragezeichenfolge nicht. |
|
pathFull |
Gibt den Pfad aus, der Abfragezeichenfolge und Fragment beinhaltet. Beispiel: /top/news.html?page=2#comments |
|
queryString |
Gibt die Abfragezeichenfolge aus. Die Abfragezeichenfolge beinhaltet Folgendes nicht:
|
|
fragmenttext |
Gibt die Fragmentkennung aus. Beinhaltet das anfängliche Hash-Symbol # nicht. |
|
queryStringAndFragment |
Gibt die Abfragezeichenfolge und Fragmentkennung aus. |
|
extractURLParameter(URL, name) |
Gibt den Wert des Parameters name in der URL aus, falls vorhanden. Andernfalls eine leere Zeichenfolge. Wenn es mehrere Parameter mit diesem Namen gibt, wird das erste Vorkommnis ausgegeben. Diese Funktion geht davon aus, dass der Parametername in der URL genauso codiert ist wie im bearbeiteten Argument. |
|
extractURLParameters(URL) |
Gibt ein Array von name=value-Zeichenfolgen aus, das den URL-Parametern entspricht. Die Werte werden überhaupt nicht decodiert. |
|
extractURLParameterNames(URL) |
Gibt ein Array von Namenzeichenfolgen aus, das den Namen der URL-Parameter entspricht. Die Werte werden überhaupt nicht decodiert. |
|
URLHierarchy(URL) |
Gibt ein Array aus, das die URL beinhaltet, gekürzt am Ende bei den Symbolen /,? im Pfad und Abfragezeichenfolge. Aufeinanderfolgende Trennzeichen werden als eines gezählt. Die Kürzung erfolgt an der Stelle nach allen aufeinanderfolgenden Trennzeichen. Beispiel: URLPathHierarchy('https://example.com/browse/CONV-6788') =[ '/browse/', '/browse/CONV-6788' ] |
|
URLPathHierarchy(URL) |
Gibt dasselbe Ergebnis wie URLHierarchy(URL) aus, aber ohne Protokoll und Host im Ergebnis. Das Element /’ (Root) ist nicht enthalten. |
|
decodeURLComponent(URL) |
Gibt die decodierte URL aus. |
|
cutWWW |
Entfernt bis zu ein 'www.' am Anfang der URL-Domäne, falls vorhanden. |
|
cutQueryString |
Entfernt die Abfragezeichenfolge. Das Fragezeichen wird ebenfalls entfernt. |
|
cutFragment |
Entfernt die Fragmentkennung. Das Zahlensymbol wird ebenfalls entfernt. |
|
cutQueryStringAndFragment |
Abfragezeichenfolge und Fragmentkennung werden entfernt. Fragezeichen und Zahlenzeichen werden ebenfalls entfernt. |
|
cutURLParameter(URL, name) |
Entfernt den URL-Parameter 'name', falls vorhanden. Diese Funktion geht davon aus, dass der Parametername in der URL genauso codiert ist wie im bearbeiteten Argument. |
Funktionen zur Arbeit mit IP-Adressen
Diese Tabelle beschreibt Funktionen zur Arbeit mit IP-Adressen:
| Funktion | Beschreibung |
|---|---|
|
IPv4NumToString (num) |
Nimmt eine UInt32-Zahl und interpretiert sie als IPv4-Adresse in Big Endian. Sie gibt eine Zeichenfolge aus, die die entsprechende IPv4-Adresse im Format A.B.C.D (durch Punkt getrennte Zahlen in Dezimalform) ausgibt. |
|
IPv4StringToNum(s) |
Die Umkehrfunktion von IPv4NumToString. Falls die IPv4-Adresse ein ungültiges Format hat, gibt sie 0 aus. |
|
IPv4NumToStringClassC(num) |
Ähnlich wie IPv4NumToString, aber verwendet xxx anstatt des letzten Oktetts. |
|
IPv6NumToString(x) |
Akzeptiert einen FixedString(16)-Wert, der die IPv6-Adresse im binären Format beinhaltet. Sie gibt eine Zeichenfolge aus, die diese Adresse im Textformat beinhaltet. IPv6-zugeordnete IPv4-Adressen werden ausgegeben im Format :: ffff: 111.222.33.44. |
|
IPv6StringToNum(s) |
Die Umkehrfunktion von IPv6NumToString. Falls die IPv6-Adresse ein ungültiges Format hat, wird eine Zeichenfolge mit null Bytes ausgegeben. HEX kann aus Groß- oder Kleinbuchstaben bestehen. |
|
IPv4ToIPv6(x) |
Nimmt eine UInt32-Zahl und interpretiert sie als IPv4-Adresse in Big Endian. Sie gibt einen FixedString(16)-Wert aus, der die IPv6-Adresse im binären Format beinhaltet. |
|
cutIPv6(x, bitsToCutForIPv6, bitsToCutForIPv4) |
Akzeptiert einen FixedString(16)-Wert, der die IPv6-Adresse im binären Format beinhaltet. Sie gibt eine Zeichenfolge aus, die die Adresse der angegebenen Zahl entfernter Bits im Textformat beinhaltet. |
|
IPv4CIDRtoIPv4Range(ipv4, cidr) |
Akzeptiert einen IPv4- und einen UInt8-Wert, der CIDR beinhaltet. Sie gibt ein Tuple mit zwei IPv4-Werten aus, das den unteren und oberen Bereich des Subnetzes beinhaltet. |
|
IPv6CIDRtoIPv6Range(ipv6, cidr) |
Akzeptiert einen IPv6- und einen UInt8-Wert, der CIDR beinhaltet. Sie gibt ein Tuple mit zwei IPv6-Werten aus, das den unteren und oberen Bereich des Subnetzes beinhaltet. |
Funktionen zur Arbeit mit Nullable-Argumenten
| Funktion | Beschreibung |
|---|---|
|
isNull(x) |
Prüft, ob das Argument NULL ist. Parameter:
Ausgegebener Wert:
|
|
isNotNull (x) |
Parameter:
Ausgegebener Wert:
|
|
coalesce(x,...) |
|
|
ifNull |
Gibt einen alternativen Wert aus, wenn das Hauptargument NULL ist. |
|
ifNull (x, alt) |
Parameter:
Ausgegebene Werte:
|
|
nullIf(x,y) |
Gibt NULL aus, falls die Argumente gleich sind. Parameter:
Ausgegebene Werte:
|
|
assumeNotNull(x) |
Parameter:
Ausgegebene Werte:
|
|
toNullable(x) |
Wandelt den Argumenttyp in Nullable um. Parameter:
Ausgegebener Wert:
|