Textfunktionen

Textfunktionen und -operatoren

Dieser Abschnitt beschreibt Funktionen und Operatoren zum Untersuchen und Manipulieren von STRING-Werten.

Funktion	Beschreibung
`string[index]`	Extrahiert ein einzelnes Zeichen über einen (1-basierten) `index`.
`string[begin:end]`	Extrahiert eine Zeichenkette nach Slice-Konventionen ähnlich wie in Python. Fehlende Argumente `begin` oder `end` werden als Anfang bzw. Ende der Liste interpretiert. Negative Werte sind erlaubt.
`string LIKE target`	Gibt `true` zurück, wenn die `string` der Like-Angabe entspricht (siehe Mustervergleich).
`string SIMILAR TO regex`	Gibt `true` zurück, wenn die `string` dem `regex` entspricht (siehe Mustervergleich).
`string ^@ search_string`	Alias für `starts_with`.
[`arg1
`array_extract(string, index)`	Extrahiert ein einzelnes Zeichen aus einer `string` über einen (1-basierten) `index`.
`array_slice(list, begin, end)`	Extrahiert eine Teilliste oder Teilzeichenkette nach Slice-Konventionen. Negative Werte sind erlaubt.
`ascii(string)`	Gibt eine Ganzzahl zurück, die den Unicode-Codepoint des ersten Zeichens der `string` darstellt.
`bar(x, min, max[, width])`	Zeichnet einen Balken, dessen Breite proportional zu (`x - min`) ist und bei `x` = `max` `width` Zeichen entspricht. `width` ist standardmäßig 80.
`base64(blob)`	Alias für `to_base64`.
`bin(string)`	Wandelt die `string` in Binärdarstellung um.
`bit_length(string)`	Anzahl der Bits in einer `string`.
`char_length(string)`	Alias für `length`.
`character_length(string)`	Alias für `length`.
`chr(code_point)`	Gibt ein Zeichen zurück, das dem ASCII-Codewert oder Unicode-Codepoint entspricht.
`concat(value, ...)`	Verkettet mehrere Zeichenketten oder Listen. `NULL`-Eingaben werden übersprungen. Siehe auch [Operator `
`concat_ws(separator, string, ...)`	Verkettet viele Zeichenketten, getrennt durch `separator`. `NULL`-Eingaben werden übersprungen.
`contains(string, search_string)`	Gibt `true` zurück, wenn `search_string` in `string` gefunden wird. Beachten Sie, dass Collations nicht unterstützt werden.
`ends_with(string, search_string)`	Alias für `suffix`.
`format(format, ...)`	Formatiert eine Zeichenkette mit der fmt-Syntax.
`formatReadableDecimalSize(integer)`	Wandelt `integer` in eine menschenlesbare Darstellung mit Einheiten auf Basis von Zehnerpotenzen um (KB, MB, GB usw.).
`format_bytes(integer)`	Wandelt `integer` in eine menschenlesbare Darstellung mit Einheiten auf Basis von Zweierpotenzen um (KiB, MiB, GiB usw.).
`from_base64(string)`	Wandelt eine Base64-kodierte `string` in eine Zeichenkette (`BLOB`) um.
`from_binary(value)`	Alias für `unbin`.
`from_hex(value)`	Alias für `unhex`.
`greatest(arg1, ...)`	Gibt den größten Wert in lexikographischer Reihenfolge zurück. Beachten Sie, dass Kleinbuchstaben als größer als Großbuchstaben gelten und Collations nicht unterstützt werden.
`hash(value, ...)`	Gibt einen `UBIGINT` mit dem Hash des `value` zurück. Beachten Sie, dass dies kein kryptographischer Hash ist.
`hex(string)`	Wandelt die `string` in hexadezimale Darstellung um.
`ilike_escape(string, like_specifier, escape_character)`	Gibt `true` zurück, wenn die `string` dem `like_specifier` entspricht (siehe Mustervergleich), mit groß-/kleinschreibungsunabhängigem Vergleich. `escape_character` wird verwendet, um nach Platzhalterzeichen in der `string` zu suchen.
`instr(string, search_string)`	Gibt die Position des ersten Vorkommens von `search_string` in `string` zurück, gezählt ab 1. Gibt 0 zurück, wenn kein Treffer gefunden wird.
`lcase(string)`	Alias für `lower`.
`least(arg1, ...)`	Gibt den kleinsten Wert in lexikographischer Reihenfolge zurück. Beachten Sie, dass Großbuchstaben als kleiner als Kleinbuchstaben gelten und Collations nicht unterstützt werden.
`left(string, count)`	Extrahiert die count linken Zeichen.
`left_grapheme(string, count)`	Extrahiert die count linken Grapheme-Cluster.
`len(string)`	Alias für `length`.
`length(string)`	Anzahl der Zeichen in `string`.
`length_grapheme(string)`	Anzahl der Grapheme-Cluster in `string`.
`like_escape(string, like_specifier, escape_character)`	Gibt `true` zurück, wenn die `string` dem `like_specifier` entspricht (siehe Mustervergleich), mit groß-/kleinschreibungssensitivem Vergleich. `escape_character` wird verwendet, um nach Platzhalterzeichen in der `string` zu suchen.
`lower(string)`	Wandelt `string` in Kleinbuchstaben um.
`lpad(string, count, character)`	Füllt die `string` links mit dem `character` auf, bis sie `count` Zeichen hat. Kürzt die `string` rechts, wenn sie mehr als `count` Zeichen hat.
`ltrim(string[, characters])`	Entfernt alle Vorkommen aller `characters` von der linken Seite der `string`. `characters` ist standardmäßig `space`.
`md5(string)`	Gibt den MD5-Hash der `string` als `VARCHAR` zurück.
`md5_number(string)`	Gibt den MD5-Hash der `string` als `HUGEINT` zurück.
`md5_number_lower(string)`	Gibt das untere 64-Bit-Segment des MD5-Hashs der `string` als `UBIGINT` zurück.
`md5_number_upper(string)`	Gibt das obere 64-Bit-Segment des MD5-Hashs der `string` als `UBIGINT` zurück.
`nfc_normalize(string)`	Wandelt `string` in eine Unicode-NFC-normalisierte Zeichenkette um. Nützlich für Vergleiche und Sortierung, wenn Textdaten gemischt NFC-normalisiert und nicht normalisiert sind.
`not_ilike_escape(string, like_specifier, escape_character)`	Gibt `false` zurück, wenn die `string` dem `like_specifier` entspricht (siehe Mustervergleich), mit groß-/kleinschreibungsunabhängigem Vergleich. `escape_character` wird verwendet, um nach Platzhalterzeichen in der `string` zu suchen.
`not_like_escape(string, like_specifier, escape_character)`	Gibt `false` zurück, wenn die `string` dem `like_specifier` entspricht (siehe Mustervergleich), mit groß-/kleinschreibungssensitivem Vergleich. `escape_character` wird verwendet, um nach Platzhalterzeichen in der `string` zu suchen.
`ord(string)`	Alias für `unicode`.
`parse_dirname(path[, separator])`	Gibt den Verzeichnisnamen der obersten Ebene aus dem gegebenen `path` zurück. Optionen für `separator`: `system`, `both_slash` (Standard), `forward_slash`, `backslash`.
`parse_dirpath(path[, separator])`	Gibt den Kopf des `path` zurück (den Pfadnamen bis zum letzten Schrägstrich), ähnlich wie Pythons `os.path.dirname`. Optionen für `separator`: `system`, `both_slash` (Standard), `forward_slash`, `backslash`.
`parse_filename(string[, trim_extension][, separator])`	Gibt die letzte Komponente des `path` zurück, ähnlich wie Pythons Funktion `os.path.basename`. Ist `trim_extension` `true`, wird die Dateiendung entfernt (Standard ist `false`). Optionen für `separator`: `system`, `both_slash` (Standard), `forward_slash`, `backslash`.
`parse_path(path[, separator])`	Gibt eine Liste der Komponenten (Verzeichnisse und Dateiname) im `path` zurück, ähnlich wie Pythons Funktion `pathlib.parts`. Optionen für `separator`: `system`, `both_slash` (Standard), `forward_slash`, `backslash`.
`position(search_string IN string)`	Gibt die Position des ersten Vorkommens von `search_string` in `string` zurück, gezählt ab 1. Gibt 0 zurück, wenn kein Treffer gefunden wird.
`position(string, search_string)`	Alias für `instr`.
`prefix(string, search_string)`	Gibt `true` zurück, wenn `string` mit `search_string` beginnt.
`printf(format, ...)`	Formatiert eine `string` mit printf-Syntax.
`read_text(source)`	Gibt den Inhalt von `source` (ein Dateiname, eine Liste von Dateinamen oder ein Glob-Muster) als `VARCHAR` zurück. Der Dateiinhalt wird zuerst als gültiges UTF-8 geprüft. Versucht `read_text` eine Datei mit ungültigem UTF-8 zu lesen, wird ein Fehler ausgelöst, der vorschlägt, stattdessen `read_blob` zu verwenden. Details finden Sie im `read_text`-Leitfaden.
`regexp_escape(string)`	Escapet Sonderzeichen, um `string` in einen regulären Ausdruck zu verwandeln, ähnlich wie Pythons `re.escape`-Funktion.
`regexp_extract(string, regex[, group][, options])`	Enthält `string` das `regex`-Muster, wird die durch den optionalen Parameter `group` angegebene Capture-Gruppe zurückgegeben; andernfalls die leere Zeichenkette. `group` muss ein konstanter Wert sein. Wird keine `group` angegeben, ist der Standard 0. Eine Menge optionaler Regex-`options` kann gesetzt werden.
`regexp_extract(string, regex, name_list[, options])`	Enthält `string` das `regex`-Muster, werden die Capture-Gruppen als Struct mit den entsprechenden Namen aus `name_list` zurückgegeben; andernfalls ein Struct mit denselben Schlüsseln und leeren Zeichenketten als Werten. Eine Menge optionaler Regex-`options` kann gesetzt werden.
`regexp_extract_all(string, regex[, group][, options])`	Findet nicht überlappende Vorkommen des `regex` in der `string` und gibt die entsprechenden Werte der Capture-`group` zurück. Eine Menge optionaler Regex-`options` kann gesetzt werden.
`regexp_extract_all(string, regex, name_list[, options])`	Findet nicht überlappende Vorkommen von `regex` in `string` und gibt die Capture-Gruppen als Liste von Structs mit den entsprechenden Namen aus `name_list` zurück. Eine Menge optionaler Regex-`options` kann gesetzt werden.
`regexp_full_match(string, regex[, col2])`	Gibt `true` zurück, wenn die gesamte `string` dem `regex` entspricht. Eine Menge optionaler Regex-`options` kann gesetzt werden.
`regexp_matches(string, regex[, options])`	Gibt `true` zurück, wenn `string` den `regex` enthält, andernfalls `false`. Eine Menge optionaler Regex-`options` kann gesetzt werden.
`regexp_replace(string, regex, replacement[, options])`	Enthält `string` den `regex`, wird der passende Teil durch `replacement` ersetzt. Eine Menge optionaler Regex-`options` kann gesetzt werden.
`regexp_split_to_array(string, regex[, options])`	Alias für `string_split_regex`.
`regexp_split_to_table(string, regex)`	Teilt die `string` entlang des `regex` und gibt eine Zeile für jeden Teil zurück.
`repeat(string, count)`	Wiederholt die `string` `count`-mal.
`replace(string, source, target)`	Ersetzt alle Vorkommen von `source` durch `target` in `string`.
`reverse(string)`	Kehrt die `string` um.
`right(string, count)`	Extrahiert die `count` rechten Zeichen.
`right_grapheme(string, count)`	Extrahiert die `count` rechten Grapheme-Cluster.
`rpad(string, count, character)`	Füllt die `string` rechts mit dem `character` auf, bis sie `count` Zeichen hat. Kürzt die `string` rechts, wenn sie mehr als `count` Zeichen hat.
`rtrim(string[, characters])`	Entfernt alle Vorkommen aller `characters` von der rechten Seite der `string`. `characters` ist standardmäßig `space`.
`sha1(value)`	Gibt einen `VARCHAR` mit dem SHA-1-Hash des `value` zurück.
`sha256(value)`	Gibt einen `VARCHAR` mit dem SHA-256-Hash des `value` zurück.
`split(string, separator)`	Alias für `string_split`.
`split_part(string, separator, index)`	Teilt die `string` entlang des `separator` und gibt die Daten am (1-basierten) `index` der Liste zurück. Liegt der `index` außerhalb der Listengrenzen, wird eine leere Zeichenkette zurückgegeben (um dem Verhalten von PostgreSQL zu entsprechen).
`starts_with(string, search_string)`	Gibt `true` zurück, wenn `string` mit `search_string` beginnt.
`str_split(string, separator)`	Alias für `string_split`.
`str_split_regex(string, regex[, options])`	Alias für `string_split_regex`.
`string_split(string, separator)`	Teilt die `string` entlang des `separator`.
`string_split_regex(string, regex[, options])`	Teilt die `string` entlang des `regex`. Eine Menge optionaler Regex-`options` kann gesetzt werden.
`string_to_array(string, separator)`	Alias für `string_split`.
`strip_accents(string)`	Entfernt Akzente aus `string`.
`strlen(string)`	Anzahl der Bytes in `string`.
`strpos(string, search_string)`	Alias für `instr`.
`substr(string, start[, length])`	Alias für `substring`.
`substring(string, start[, length])`	Extrahiert eine Teilzeichenkette ab dem Zeichen `start` bis zum Ende der Zeichenkette. Ist das optionale Argument `length` gesetzt, wird stattdessen eine Teilzeichenkette von `length` Zeichen extrahiert. Beachten Sie, dass ein `start`-Wert von `1` das erste Zeichen der `string` bezeichnet.
`substring_grapheme(string, start[, length])`	Extrahiert eine Teilzeichenkette ab dem Grapheme-Cluster `start` bis zum Ende der Zeichenkette. Ist das optionale Argument `length` gesetzt, wird stattdessen eine Teilzeichenkette von `length` Grapheme-Clustern extrahiert. Beachten Sie, dass ein `start`-Wert von `1` das `erste` Zeichen der `string` bezeichnet.
`suffix(string, search_string)`	Gibt `true` zurück, wenn `string` mit `search_string` endet. Beachten Sie, dass Collations nicht unterstützt werden.
`to_base(number, radix[, min_length])`	Wandelt `number` in eine Zeichenkette zur Basis `radix` um, optional mit führenden Nullen auf `min_length` aufgefüllt.
`to_base64(blob)`	Wandelt einen `blob` in eine Base64-kodierte Zeichenkette um.
`to_binary(string)`	Alias für `bin`.
`to_hex(string)`	Alias für `hex`.
`translate(string, from, to)`	Ersetzt jedes Zeichen in `string`, das einem Zeichen in der Menge `from` entspricht, durch das entsprechende Zeichen in der Menge `to`. Ist `from` länger als `to`, werden Vorkommen der überzähligen Zeichen in `from` gelöscht.
`trim(string[, characters])`	Entfernt alle Vorkommen aller `characters` von beiden Seiten der `string`. `characters` ist standardmäßig `space`.
`ucase(string)`	Alias für `upper`.
`unbin(value)`	Wandelt einen `value` aus der Binärdarstellung in einen Blob um.
`unhex(value)`	Wandelt einen `value` aus der hexadezimalen Darstellung in einen Blob um.
`unicode(string)`	Gibt einen `INTEGER` zurück, der den `unicode`-Codepoint des ersten Zeichens in der `string` darstellt.
`upper(string)`	Wandelt `string` in Großbuchstaben um.
`url_decode(string)`	Dekodiert eine URL aus einer Darstellung mit Percent-Encoding.
`url_encode(string)`	Kodiert eine URL in eine Darstellung mit Percent-Encoding.

`string[index]`

`string[begin:end]`

`string LIKE target`

`string SIMILAR TO regex`

`arg1 || arg2`

| Beschreibung | Verkettet zwei Zeichenketten, Listen oder Blobs. Jede NULL-Eingabe ergibt NULL. Siehe auch concat(arg1, arg2, ...) und list_concat(list1, list2, ...). | | Beispiel 1 | 'Duck' || 'DB' | | Ergebnis | DuckDB | | Beispiel 2 | [1, 2, 3] || [4, 5, 6] | | Ergebnis | [1, 2, 3, 4, 5, 6] | | Beispiel 3 | '\xAA'::BLOB || '\xBB'::BLOB | | Ergebnis | \xAA\xBB |

`array_extract(string, index)`

`array_slice(list, begin, end)`

`ascii(string)`

`bar(x, min, max[, width])`

`bin(string)`

`bit_length(string)`

`chr(code_point)`

`concat(value, ...)`

| Beschreibung | Verkettet mehrere Zeichenketten oder Listen. NULL-Eingaben werden übersprungen. Siehe auch Operator ||. | | Beispiel 1 | concat('Hello', ' ', 'World') | | Ergebnis | Hello World | | Beispiel 2 | concat([1, 2, 3], NULL, [4, 5, 6]) | | Ergebnis | [1, 2, 3, 4, 5, 6] |

`concat_ws(separator, string, ...)`

`contains(string, search_string)`

`format(format, ...)`

| Beschreibung | Formatiert eine Zeichenkette mit der fmt-Syntax. | | Beispiel | format('Benchmark "{}" took {} seconds', 'CSV', 42) | | Ergebnis | Benchmark "CSV" took 42 seconds |

`formatReadableDecimalSize(integer)`

`format_bytes(integer)`

`from_base64(string)`

`greatest(arg1, ...)`

`hash(value, ...)`

`hex(string)`

`ilike_escape(string, like_specifier, escape_character)`

| Beschreibung | Gibt true zurück, wenn die string dem like_specifier entspricht (siehe Mustervergleich), mit groß-/kleinschreibungsunabhängigem Vergleich. escape_character wird verwendet, um nach Platzhalterzeichen in der string zu suchen. | | Beispiel | ilike_escape('A%c', 'a$%C', '$') | | Ergebnis | true |

`instr(string, search_string)`

`least(arg1, ...)`

`left(string, count)`

`left_grapheme(string, count)`

`length(string)`

`length_grapheme(string)`

`like_escape(string, like_specifier, escape_character)`

| Beschreibung | Gibt true zurück, wenn die string dem like_specifier entspricht (siehe Mustervergleich), mit groß-/kleinschreibungssensitivem Vergleich. escape_character wird verwendet, um nach Platzhalterzeichen in der string zu suchen. | | Beispiel | like_escape('a%c', 'a$%c', '$') | | Ergebnis | true |

`lower(string)`

`lpad(string, count, character)`

`ltrim(string[, characters])`

`md5(string)`

`md5_number(string)`

`md5_number_lower(string)`

`md5_number_upper(string)`

`nfc_normalize(string)`

| Beschreibung | Wandelt string in eine Unicode-NFC-normalisierte Zeichenkette um. Nützlich für Vergleiche und Sortierung, wenn Textdaten gemischt NFC-normalisiert und nicht normalisiert sind. | | Beispiel | nfc_normalize('ardèch') | | Ergebnis | ardèch |

`not_ilike_escape(string, like_specifier, escape_character)`

| Beschreibung | Gibt false zurück, wenn die string dem like_specifier entspricht (siehe Mustervergleich), mit groß-/kleinschreibungsunabhängigem Vergleich. escape_character wird verwendet, um nach Platzhalterzeichen in der string zu suchen. | | Beispiel | not_ilike_escape('A%c', 'a$%C', '$') | | Ergebnis | false |

`not_like_escape(string, like_specifier, escape_character)`

| Beschreibung | Gibt false zurück, wenn die string dem like_specifier entspricht (siehe Mustervergleich), mit groß-/kleinschreibungssensitivem Vergleich. escape_character wird verwendet, um nach Platzhalterzeichen in der string zu suchen. | | Beispiel | not_like_escape('a%c', 'a$%c', '$') | | Ergebnis | false |

`parse_dirname(path[, separator])`

| Beschreibung | Gibt den Verzeichnisnamen der obersten Ebene aus dem gegebenen path zurück. Optionen für separator: system, both_slash (Standard), forward_slash, backslash. | | Beispiel | parse_dirname('path/to/file.csv', 'system') | | Ergebnis | path |

`parse_dirpath(path[, separator])`

| Beschreibung | Gibt den Kopf des path zurück (den Pfadnamen bis zum letzten Schrägstrich), ähnlich wie Pythons os.path.dirname. Optionen für separator: system, both_slash (Standard), forward_slash, backslash. | | Beispiel | parse_dirpath('path/to/file.csv', 'forward_slash') | | Ergebnis | path/to |

`parse_filename(string[, trim_extension][, separator])`

| Beschreibung | Gibt die letzte Komponente des path zurück, ähnlich wie Pythons Funktion os.path.basename. Ist trim_extension true, wird die Dateiendung entfernt (Standard ist false). Optionen für separator: system, both_slash (Standard), forward_slash, backslash. | | Beispiel | parse_filename('path/to/file.csv', true, 'forward_slash') | | Ergebnis | file |

`parse_path(path[, separator])`

| Beschreibung | Gibt eine Liste der Komponenten (Verzeichnisse und Dateiname) im path zurück, ähnlich wie Pythons Funktion pathlib.parts. Optionen für separator: system, both_slash (Standard), forward_slash, backslash. | | Beispiel | parse_path('path/to/file.csv', 'system') | | Ergebnis | [path, to, file.csv] |

`position(search_string IN string)`

`prefix(string, search_string)`

`printf(format, ...)`

`read_text(source)`

| Beschreibung | Gibt den Inhalt von source (ein Dateiname, eine Liste von Dateinamen oder ein Glob-Muster) als VARCHAR zurück. Der Dateiinhalt wird zuerst als gültiges UTF-8 geprüft. Versucht read_text eine Datei mit ungültigem UTF-8 zu lesen, wird ein Fehler ausgelöst, der vorschlägt, stattdessen read_blob zu verwenden. Details finden Sie im read_text-Leitfaden. | | Beispiel | read_text('hello.txt') | | Ergebnis | hello\n |

`regexp_escape(string)`

`regexp_extract(string, regex[, group][, options])`

| Beschreibung | Enthält string das regex-Muster, wird die durch den optionalen Parameter group angegebene Capture-Gruppe zurückgegeben; andernfalls die leere Zeichenkette. group muss ein konstanter Wert sein. Wird keine group angegeben, ist der Standard 0. Eine Menge optionaler Regex-options kann gesetzt werden. | | Beispiel | regexp_extract('ABC', '([a-z])(b)', 1, 'i') | | Ergebnis | A |

`regexp_extract(string, regex, name_list[, options])`

| Beschreibung | Enthält string das regex-Muster, werden die Capture-Gruppen als Struct mit den entsprechenden Namen aus name_list zurückgegeben; andernfalls ein Struct mit denselben Schlüsseln und leeren Zeichenketten als Werten. Eine Menge optionaler Regex-options kann gesetzt werden. | | Beispiel | regexp_extract('John Doe', '([a-z]+) ([a-z]+)', ['first_name', 'last_name'], 'i') | | Ergebnis | {'first_name': John, 'last_name': Doe} |

`regexp_extract_all(string, regex[, group][, options])`

| Beschreibung | Findet nicht überlappende Vorkommen des regex in der string und gibt die entsprechenden Werte der Capture-group zurück. Eine Menge optionaler Regex-options kann gesetzt werden. | | Beispiel | regexp_extract_all('Peter: 33, Paul:14', '(\w+):\s*(\d+)', 2) | | Ergebnis | [33, 14] |

`regexp_extract_all(string, regex, name_list[, options])`

| Beschreibung | Findet nicht überlappende Vorkommen von regex in string und gibt die Capture-Gruppen als Liste von Structs mit den entsprechenden Namen aus name_list zurück. Eine Menge optionaler Regex-options kann gesetzt werden. | | Beispiel | regexp_extract_all('Peter: 33, Paul: 14', '(\w+):\s*(\d+)', ['name', 'age']) | | Ergebnis | [{'name': Peter, 'age': 33}, {'name': Paul, 'age': 14}] |

`regexp_full_match(string, regex[, col2])`

`regexp_matches(string, regex[, options])`

`regexp_replace(string, regex, replacement[, options])`

`regexp_split_to_table(string, regex)`

`repeat(string, count)`

`replace(string, source, target)`

`reverse(string)`

`right(string, count)`

`right_grapheme(string, count)`

`rpad(string, count, character)`

`rtrim(string[, characters])`

`sha1(value)`

`sha256(value)`

`split_part(string, separator, index)`

| Beschreibung | Teilt die string entlang des separator und gibt die Daten am (1-basierten) index der Liste zurück. Liegt der index außerhalb der Listengrenzen, wird eine leere Zeichenkette zurückgegeben (um dem Verhalten von PostgreSQL zu entsprechen). | | Beispiel | split_part('a;b;c', ';', 2) | | Ergebnis | b |

`starts_with(string, search_string)`

`string_split(string, separator)`

`string_split_regex(string, regex[, options])`

`strip_accents(string)`

`strlen(string)`

`substring(string, start[, length])`

`substring_grapheme(string, start[, length])`

| Beschreibung | Extrahiert eine Teilzeichenkette ab dem Grapheme-Cluster start bis zum Ende der Zeichenkette. Ist das optionale Argument length gesetzt, wird stattdessen eine Teilzeichenkette von length Grapheme-Clustern extrahiert. Beachten Sie, dass ein start-Wert von 1 das erste Zeichen der string bezeichnet. | | Beispiel 1 | substring_grapheme('🦆🤦🏼‍♂️🤦🏽‍♀️🦆', 3) | | Ergebnis | 🤦🏽‍♀️🦆 | | Beispiel 2 | substring_grapheme('🦆🤦🏼‍♂️🤦🏽‍♀️🦆', 3, 2) | | Ergebnis | 🤦🏽‍♀️🦆 |

`suffix(string, search_string)`

`to_base(number, radix[, min_length])`

`to_base64(blob)`

`translate(string, from, to)`

| Beschreibung | Ersetzt jedes Zeichen in string, das einem Zeichen in der Menge from entspricht, durch das entsprechende Zeichen in der Menge to. Ist from länger als to, werden Vorkommen der überzähligen Zeichen in from gelöscht. | | Beispiel | translate('12345', '143', 'ax') | | Ergebnis | a2x5 |

`trim(string[, characters])`

`unbin(value)`

`unhex(value)`

`unicode(string)`

`upper(string)`

`url_decode(string)`

`url_encode(string)`

Textähnlichkeitsfunktionen

Diese Funktionen messen die Ähnlichkeit zweier Zeichenketten anhand verschiedener Ähnlichkeitsmaße.

Funktion	Beschreibung
`damerau_levenshtein(s1, s2)`	Erweiterung der Levenshtein-Distanz, die auch die Vertauschung benachbarter Zeichen als erlaubte Editieroperation einschließt. Mit anderen Worten: die minimale Anzahl von Editieroperationen (Einfügungen, Löschungen, Ersetzungen oder Vertauschungen), die nötig sind, um eine Zeichenkette in eine andere zu überführen. Zeichen unterschiedlicher Groß-/Kleinschreibung (z. B. `a` und `A`) gelten als unterschiedlich.
`editdist3(s1, s2)`	Alias für `levenshtein`.
`hamming(s1, s2)`	Die Hamming-Distanz zwischen zwei Zeichenketten, d. h. die Anzahl der Positionen mit unterschiedlichen Zeichen bei zwei Zeichenketten gleicher Länge. Die Zeichenketten müssen gleich lang sein. Zeichen unterschiedlicher Groß-/Kleinschreibung (z. B. `a` und `A`) gelten als unterschiedlich.
`jaccard(s1, s2)`	Die Jaccard-Ähnlichkeit zwischen zwei Zeichenketten. Zeichen unterschiedlicher Groß-/Kleinschreibung (z. B. `a` und `A`) gelten als unterschiedlich. Gibt eine Zahl zwischen 0 und 1 zurück.
`jaro_similarity(s1, s2[, score_cutoff])`	Die Jaro-Ähnlichkeit zwischen zwei Zeichenketten. Zeichen unterschiedlicher Groß-/Kleinschreibung (z. B. `a` und `A`) gelten als unterschiedlich. Gibt eine Zahl zwischen 0 und 1 zurück. Bei Ähnlichkeit < `score_cutoff` wird stattdessen 0 zurückgegeben. `score_cutoff` ist standardmäßig 0.
`jaro_winkler_similarity(s1, s2[, score_cutoff])`	Die Jaro-Winkler-Ähnlichkeit zwischen zwei Zeichenketten. Zeichen unterschiedlicher Groß-/Kleinschreibung (z. B. `a` und `A`) gelten als unterschiedlich. Gibt eine Zahl zwischen 0 und 1 zurück. Bei Ähnlichkeit < `score_cutoff` wird stattdessen 0 zurückgegeben. `score_cutoff` ist standardmäßig 0.
`levenshtein(s1, s2)`	Die minimale Anzahl von Ein-Zeichen-Edits (Einfügungen, Löschungen oder Ersetzungen), die nötig sind, um eine Zeichenkette in die andere zu überführen. Zeichen unterschiedlicher Groß-/Kleinschreibung (z. B. `a` und `A`) gelten als unterschiedlich.
`mismatches(s1, s2)`	Alias für `hamming`.

`damerau_levenshtein(s1, s2)`

| Beschreibung | Erweiterung der Levenshtein-Distanz, die auch die Vertauschung benachbarter Zeichen als erlaubte Editieroperation einschließt. Mit anderen Worten: die minimale Anzahl von Editieroperationen (Einfügungen, Löschungen, Ersetzungen oder Vertauschungen), die nötig sind, um eine Zeichenkette in eine andere zu überführen. Zeichen unterschiedlicher Groß-/Kleinschreibung (z. B. a und A) gelten als unterschiedlich. | | Beispiel | damerau_levenshtein('duckdb', 'udckbd') | | Ergebnis | 2 |

`hamming(s1, s2)`

| Beschreibung | Die Hamming-Distanz zwischen zwei Zeichenketten, d. h. die Anzahl der Positionen mit unterschiedlichen Zeichen bei zwei Zeichenketten gleicher Länge. Die Zeichenketten müssen gleich lang sein. Zeichen unterschiedlicher Groß-/Kleinschreibung (z. B. a und A) gelten als unterschiedlich. | | Beispiel | hamming('duck', 'luck') | | Ergebnis | 1 | | Alias | mismatches |

`jaccard(s1, s2)`

| Beschreibung | Die Jaccard-Ähnlichkeit zwischen zwei Zeichenketten. Zeichen unterschiedlicher Groß-/Kleinschreibung (z. B. a und A) gelten als unterschiedlich. Gibt eine Zahl zwischen 0 und 1 zurück. | | Beispiel | jaccard('duck', 'luck') | | Ergebnis | 0.6 |

`jaro_similarity(s1, s2[, score_cutoff])`

| Beschreibung | Die Jaro-Ähnlichkeit zwischen zwei Zeichenketten. Zeichen unterschiedlicher Groß-/Kleinschreibung (z. B. a und A) gelten als unterschiedlich. Gibt eine Zahl zwischen 0 und 1 zurück. Bei Ähnlichkeit < score_cutoff wird stattdessen 0 zurückgegeben. score_cutoff ist standardmäßig 0. | | Beispiel | jaro_similarity('duck', 'duckdb') | | Ergebnis | 0.8888888888888888 |

`jaro_winkler_similarity(s1, s2[, score_cutoff])`

| Beschreibung | Die Jaro-Winkler-Ähnlichkeit zwischen zwei Zeichenketten. Zeichen unterschiedlicher Groß-/Kleinschreibung (z. B. a und A) gelten als unterschiedlich. Gibt eine Zahl zwischen 0 und 1 zurück. Bei Ähnlichkeit < score_cutoff wird stattdessen 0 zurückgegeben. score_cutoff ist standardmäßig 0. | | Beispiel | jaro_winkler_similarity('duck', 'duckdb') | | Ergebnis | 0.9333333333333333 |

`levenshtein(s1, s2)`

| Beschreibung | Die minimale Anzahl von Ein-Zeichen-Edits (Einfügungen, Löschungen oder Ersetzungen), die nötig sind, um eine Zeichenkette in die andere zu überführen. Zeichen unterschiedlicher Groß-/Kleinschreibung (z. B. a und A) gelten als unterschiedlich. | | Beispiel | levenshtein('duck', 'db') | | Ergebnis | 3 | | Alias | editdist3 |

Formatierer

`fmt`-Syntax

Die Funktion format(format, parameters...) formatiert Zeichenketten, grob der Syntax der Open-Source-Formatierungsbibliothek {fmt} folgend.

Formatieren ohne zusätzliche Parameter:

SELECT format('Hello world'); -- Hello world

Eine Zeichenkette mit {} formatieren:

SELECT format('The answer is {}', 42); -- The answer is 42

Eine Zeichenkette mit Positionsargumenten formatieren:

SELECT format('I''d rather be {1} than {0}.', 'right', 'happy'); -- I'd rather be happy than right.

Formatspezifizierer

Spezifizierer	Beschreibung	Beispiel
`{:d}`	Ganzzahl	`654321`
`{:E}`	wissenschaftliche Notation	`3.141593E+00`
`{:f}`	Gleitkommazahl	`4.560000`
`{:o}`	oktal	`2375761`
`{:s}`	Zeichenkette	`asd`
`{:x}`	hexadezimal	`9fbf1`
`{:tX}`	Ganzzahl, `X` ist das Tausendertrennzeichen	`654 321`

Typen formatieren

Ganzzahlen:

SELECT format('{} + {} = {}', 3, 5, 3 + 5); -- 3 + 5 = 8

Booleans:

SELECT format('{} != {}', true, false); -- true != false

Datetime-Werte formatieren:

SELECT format('{}', DATE '1992-01-01'); -- 1992-01-01
SELECT format('{}', TIME '12:01:00'); -- 12:01:00
SELECT format('{}', TIMESTAMP '1992-01-01 12:01:00'); -- 1992-01-01 12:01:00

BLOB formatieren:

SELECT format('{}', BLOB '\x00hello'); -- \x00hello

Ganzzahlen mit 0en auffüllen:

SELECT format('{:04d}', 33); -- 0033

Auffüllen kann derzeit nicht mit der Angabe eines Tausendertrennzeichens kombiniert werden.

Zeitstempel aus Ganzzahlen erzeugen:

SELECT format('{:02d}:{:02d}:{:02d} {}', 12, 3, 16, 'AM'); -- 12:03:16 AM

Nach Hexadezimal umwandeln:

SELECT format('{:x}', 123_456_789); -- 75bcd15

Nach Binär umwandeln:

SELECT format('{:b}', 123_456_789); -- 111010110111100110100010101

Zahlen mit Tausendertrennzeichen ausgeben

Ganzzahlen:

SELECT format('{:,}',  123_456_789); -- 123,456,789
SELECT format('{:t.}', 123_456_789); -- 123.456.789
SELECT format('{:''}', 123_456_789); -- 123'456'789
SELECT format('{:_}',  123_456_789); -- 123_456_789
SELECT format('{:t }', 123_456_789); -- 123 456 789
SELECT format('{:tX}', 123_456_789); -- 123X456X789

Float, Double und Decimal:

SELECT format('{:,f}',    123456.789); -- 123,456.78900
SELECT format('{:,.2f}',  123456.789); -- 123,456.79
SELECT format('{:t..2f}', 123456.789); -- 123.456,79

`printf`-Syntax

Die Funktion printf(format, parameters...) formatiert Zeichenketten mit der printf-Syntax.

Formatieren ohne zusätzliche Parameter:

SELECT printf('Hello world');

Hello world

Eine Zeichenkette mit Argumenten in einer gegebenen Reihenfolge formatieren:

SELECT printf('The answer to %s is %d', 'life', 42);

The answer to life is 42

Eine Zeichenkette mit Positionsargumenten %position$formatter formatieren, z. B. der zweite Parameter als Zeichenkette ist als %2$s kodiert:

SELECT printf('I''d rather be %2$s than %1$s.', 'right', 'happy');

I'd rather be happy than right.

Formatspezifizierer

Spezifizierer	Beschreibung	Beispiel
`%c`	Zeichencode zu Zeichen	`a`
`%d`	Ganzzahl	`654321`
`%Xd`	Ganzzahl mit Tausendertrennzeichen `X` aus `,`, `.`, `''`, `_`	`654_321`
`%E`	wissenschaftliche Notation	`3.141593E+00`
`%f`	Gleitkommazahl	`4.560000`
`%hd`	Ganzzahl	`654321`
`%hhd`	Ganzzahl	`654321`
`%lld`	Ganzzahl	`654321`
`%o`	oktal	`2375761`
`%s`	Zeichenkette	`asd`
`%x`	hexadezimal	`9fbf1`

Typen formatieren

Ganzzahlen:

SELECT printf('%d + %d = %d', 3, 5, 3 + 5); -- 3 + 5 = 8

Booleans:

SELECT printf('%s != %s', true, false); -- true != false

Datetime-Werte formatieren:

SELECT printf('%s', DATE '1992-01-01'); -- 1992-01-01
SELECT printf('%s', TIME '12:01:00'); -- 12:01:00
SELECT printf('%s', TIMESTAMP '1992-01-01 12:01:00'); -- 1992-01-01 12:01:00

BLOB formatieren:

SELECT printf('%s', BLOB '\x00hello'); -- \x00hello

Ganzzahlen mit 0en auffüllen:

SELECT printf('%04d', 33); -- 0033

Zeitstempel aus Ganzzahlen erzeugen:

SELECT printf('%02d:%02d:%02d %s', 12, 3, 16, 'AM'); -- 12:03:16 AM

Nach Hexadezimal umwandeln:

SELECT printf('%x', 123_456_789); -- 75bcd15

Nach Binär umwandeln:

SELECT printf('%b', 123_456_789); -- 111010110111100110100010101

Tausendertrennzeichen

Ganzzahlen:

SELECT printf('%,d',  123_456_789); -- 123,456,789
SELECT printf('%.d',  123_456_789); -- 123.456.789
SELECT printf('%''d', 123_456_789); -- 123'456'789
SELECT printf('%_d',  123_456_789); -- 123_456_789

Float, Double und Decimal:

SELECT printf('%,f',   123456.789); -- 123,456.789000
SELECT printf('%,.2f', 123456.789); -- 123,456.79