Reguläre Ausdrücke

DuckDB bietet Operatoren für den Mustervergleich (LIKE, SIMILAR TO, GLOB) sowie Unterstützung für reguläre Ausdrücke über Funktionen.

Syntax regulärer Ausdrücke

DuckDB verwendet die RE2-Bibliothek als Engine für reguläre Ausdrücke. Zur Syntax regulärer Ausdrücke siehe die RE2-Dokumentation.

Funktionen

Alle Funktionen akzeptieren eine optionale Menge von Optionen.

Name	Beschreibung
`regexp_extract(string, pattern[, group = 0][, options])`	Enthält `string` das regexp-`pattern`, 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 `options` kann gesetzt werden.
`regexp_extract(string, pattern, name_list[, options])`	Enthält `string` das regexp-`pattern`, 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.
`regexp_extract_all(string, regex[, group = 0][, options])`	Findet nicht überlappende Vorkommen von `regex` in `string` und gibt die entsprechenden Werte von `group` zurück.
`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.
`regexp_full_match(string, regex[, options])`	Gibt `true` zurück, wenn die gesamte `string` dem `regex` entspricht.
`regexp_matches(string, pattern[, options])`	Gibt `true` zurück, wenn `string` das regexp-`pattern` enthält, andernfalls `false`.
`regexp_replace(string, pattern, replacement[, options])`	Enthält `string` das regexp-`pattern`, wird der passende Teil durch `replacement` ersetzt. Standardmäßig wird nur das erste Vorkommen ersetzt. Eine Menge optionaler `options`, einschließlich des globalen Flags `g`, kann gesetzt werden.
`regexp_split_to_array(string, regex[, options])`	Alias von `string_split_regex`. Teilt die `string` entlang des `regex`.
`regexp_split_to_table(string, regex[, options])`	Teilt die `string` entlang des `regex` und gibt eine Zeile für jeden Teil zurück.

`regexp_extract(string, pattern[, group = 0][, options])`

| Beschreibung | Enthält string das regexp-pattern, 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 options kann gesetzt werden. | | Beispiel | regexp_extract('abc', '([a-z])(b)', 1) | | Ergebnis | a |

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

| Beschreibung | Enthält string das regexp-pattern, 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 options kann gesetzt werden. | | Beispiel | regexp_extract('2023-04-15', '(\d+)-(\d+)-(\d+)', ['y', 'm', 'd']) | | Ergebnis | {'y':'2023', 'm':'04', 'd':'15'} |

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

| Beschreibung | Findet nicht überlappende Vorkommen von regex in string und gibt die entsprechenden Werte von group zurück. Eine Menge optionaler 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 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[, options])`

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

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

| Beschreibung | Enthält string das regexp-pattern, wird der passende Teil durch replacement ersetzt. Standardmäßig wird nur das erste Vorkommen ersetzt. Eine Menge optionaler options, einschließlich des globalen Flags g, kann gesetzt werden. | | Beispiel | regexp_replace('hello', '[lo]', '-') | | Ergebnis | he-lo |

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

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

| Beschreibung | Teilt die string entlang des regex und gibt eine Zeile für jeden Teil zurück. Eine Menge optionaler options kann gesetzt werden. | | Beispiel | regexp_split_to_table('hello world; 42', ';? ') | | Ergebnis | Drei Zeilen: 'hello', 'world', '42' |

Die Funktion regexp_matches ähnelt dem Operator SIMILAR TO, erfordert jedoch nicht, dass die gesamte Zeichenkette übereinstimmt. Stattdessen gibt regexp_matches true zurück, wenn die Zeichenkette das Muster lediglich enthält (sofern nicht die Sonderzeichen ^ und $ verwendet werden, um den regulären Ausdruck an Anfang und Ende der Zeichenkette zu verankern). Nachfolgend einige Beispiele:

SELECT regexp_matches('abc', 'abc');       -- true
SELECT regexp_matches('abc', '^abc$');     -- true
SELECT regexp_matches('abc', 'a');         -- true
SELECT regexp_matches('abc', '^a$');       -- false
SELECT regexp_matches('abc', '.*(b|d).*'); -- true
SELECT regexp_matches('abc', '(b|c).*');   -- true
SELECT regexp_matches('abc', '^(b|c).*');  -- false
SELECT regexp_matches('abc', '(?i)A');     -- true
SELECT regexp_matches('abc', 'A', 'i');    -- true

Optionen für Funktionen mit regulären Ausdrücken

Die Regex-Funktionen unterstützen die folgenden options.

Option	Beschreibung
`'c'`	Groß-/kleinschreibungssensitiver Vergleich
`'i'`	Groß-/kleinschreibungsunabhängiger Vergleich
`'l'`	Literale statt Tokens regulärer Ausdrücke vergleichen
`'m'`, `'n'`, `'p'`	Zeilenumbruchsensitiver Vergleich
`'g'`	Globales Ersetzen, nur für `regexp_replace` verfügbar
`'s'`	Nicht zeilenumbruchsensitiver Vergleich

Zum Beispiel:

SELECT regexp_matches('abcd', 'ABC', 'c'); -- false
SELECT regexp_matches('abcd', 'ABC', 'i'); -- true
SELECT regexp_matches('ab^/$cd', '^/$', 'l'); -- true
SELECT regexp_matches(E'hello\nworld', 'hello.world', 'p'); -- false
SELECT regexp_matches(E'hello\nworld', 'hello.world', 's'); -- true

Verwendung von `regexp_matches`

Der Operator regexp_matches wird nach Möglichkeit zum Operator LIKE optimiert. Für beste Leistung sollte die Option 'c' (groß-/kleinschreibungssensitiver Vergleich) übergeben werden, sofern zutreffend. Beachten Sie, dass die RE2-Bibliothek das Zeichen . standardmäßig nicht mit einem Zeilenumbruch abgleicht.

Original	Optimiertes Äquivalent
`regexp_matches('hello world', '^hello', 'c')`	`prefix('hello world', 'hello')`
`regexp_matches('hello world', 'world$', 'c')`	`suffix('hello world', 'world')`
`regexp_matches('hello world', 'hello.world', 'c')`	`LIKE 'hello_world'`
`regexp_matches('hello world', 'he.*rld', 'c')`	`LIKE '%he%rld'`

Verwendung von `regexp_replace`

Die Funktion regexp_replace kann verwendet werden, um den Teil einer Zeichenkette, der dem regexp-Muster entspricht, durch eine Ersatzzeichenkette zu ersetzen. Die Notation \d (wobei d eine Zahl ist, die die Gruppe angibt) kann in der Ersatzzeichenkette verwendet werden, um auf im regulären Ausdruck erfasste Gruppen zu verweisen. Beachten Sie, dass regexp_replace standardmäßig nur das erste Vorkommen des regulären Ausdrucks ersetzt. Um alle Vorkommen zu ersetzen, verwenden Sie das Flag für globales Ersetzen (g).

Einige Beispiele für die Verwendung von regexp_replace:

SELECT regexp_replace('abc', '(b|c)', 'X');        -- aXc
SELECT regexp_replace('abc', '(b|c)', 'X', 'g');   -- aXX
SELECT regexp_replace('abc', '(b|c)', '\1\1\1\1'); -- abbbbc
SELECT regexp_replace('abc', '(.*)c', '\1e');      -- abe
SELECT regexp_replace('abc', '(a)(b)', '\2\1');    -- bac

Verwendung von `regexp_extract`

Die Funktion regexp_extract wird verwendet, um einen Teil einer Zeichenkette zu extrahieren, der dem regexp-Muster entspricht. Eine bestimmte Capture-Gruppe innerhalb des Musters kann mit dem Parameter group extrahiert werden. Wird group nicht angegeben, ist der Standard 0, d. h. der erste Treffer mit dem gesamten Muster.

SELECT regexp_extract('abc', '.b.');           -- abc
SELECT regexp_extract('abc', '.b.', 0);        -- abc
SELECT regexp_extract('abc', '.b.', 1);        -- (empty)
SELECT regexp_extract('abc', '([a-z])(b)', 1); -- a
SELECT regexp_extract('abc', '([a-z])(b)', 2); -- b

Die Funktion regexp_extract unterstützt außerdem ein Argument name_list, das eine LIST von Zeichenketten ist. Mit name_list gibt regexp_extract die entsprechenden Capture-Gruppen als Felder eines STRUCT zurück:

SELECT regexp_extract('2023-04-15', '(\d+)-(\d+)-(\d+)', ['y', 'm', 'd']);

{'y': 2023, 'm': 04, 'd': 15}

SELECT regexp_extract('2023-04-15 07:59:56', '^(\d+)-(\d+)-(\d+) (\d+):(\d+):(\d+)', ['y', 'm', 'd']);

{'y': 2023, 'm': 04, 'd': 15}

SELECT regexp_extract('duckdb_0_7_1', '^(\w+)_(\d+)_(\d+)', ['tool', 'major', 'minor', 'fix']);

Binder Error:
Not enough group names in regexp_extract

Ist die Anzahl der Spaltennamen kleiner als die Anzahl der Capture-Gruppen, werden nur die ersten Gruppen zurückgegeben. Ist die Anzahl der Spaltennamen größer, wird ein Fehler erzeugt.

Einschränkungen

Reguläre Ausdrücke unterstützen nur 9 Capture-Gruppen: \1, \2, \3, …, \9. Capture-Gruppen mit zwei oder mehr Ziffern werden nicht unterstützt.

Reguläre Ausdrücke

Syntax regulärer Ausdrücke

Funktionen

regexp_extract(string, pattern[, group = 0][, options])

regexp_extract(string, pattern, name_list[, options])

regexp_extract_all(string, regex[, group = 0][, options])

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

regexp_full_match(string, regex[, options])

regexp_matches(string, pattern[, options])

regexp_replace(string, pattern, replacement[, options])

regexp_split_to_array(string, regex[, options])

regexp_split_to_table(string, regex[, options])