Kategorien:: Zeichenfolgenfunktionen (reguläre Ausdrücke)

REGEXP_INSTR¶

Gibt die Position des angegebenen Auftretens des Musters des regulären Ausdrucks im Zeichenfolgensubjekt zurück.

Siehe auch Zeichenfolgenfunktionen (reguläre Ausdrücke).

Syntax¶

REGEXP_INSTR( <subject> , <pattern> [ , <position> [ , <occurrence> [ , <option> [ , <regexp_parameters> [ , <group_num> ] ] ] ] ] )

Argumente¶

Benötigt:

subject

Die Zeichenfolge, nach der gesucht werden soll.

pattern

Abzugleichendes Muster.

Richtlinien zur Angabe von Mustern finden Sie unter Zeichenfolgenfunktionen (reguläre Ausdrücke).

Optional:

position

Anzahl der Zeichen ab dem Anfang der Zeichenfolge, an dem die Funktion mit der Suche nach Übereinstimmungen beginnt. Der Wert muss eine positive Ganzzahl sein.

Standard: 1 (die Suche nach einer Übereinstimmung beginnt beim ersten Zeichen links)

occurrence

Gibt das erste Auftreten des Musters an, ab dem Übereinstimmungen zurückgegeben werden sollen.

Die Funktion überspringt die ersten occurrence - 1 Übereinstimmungen. Wenn es beispielsweise 5 Übereinstimmungen gibt und Sie 3 für das occurrence-Argument angeben, ignoriert die Funktion die ersten beiden Übereinstimmungen und gibt die dritte, vierte und fünfte Übereinstimmung zurück.

Standard: 1

option

Gibt an, ob der Offset des ersten Zeichens der Übereinstimmung (0) oder der Offset des ersten Zeichens nach dem Ende der Übereinstimmung (1) zurückgegeben werden soll.

Standard: 0

regexp_parameters

Zeichenfolge aus einem oder mehreren Zeichen, in der die Parameter angegeben sind, die zur Suche nach Übereinstimmungen verwendet werden. Unterstützte Werte:


Parameter	Beschreibung
`c`	Abgleich, bei dem zwischen Groß- und Kleinschreibung unterschieden wird
`i`	Abgleich ohne Berücksichtigung der Groß-/Kleinschreibung
`m`	Mehrzeiliger Modus.
`e`	Untergeordnete Übereinstimmungen extrahieren
`s`	POSIX-Platzhalterzeichen `.` im einzeiligen Modus stimmt mit `\n` überein

Standard: c

Weitere Informationen dazu finden Sie unter Angeben der Parameter für reguläre Ausdrücke.

Bemerkung

Standardmäßig gibt REGEXP_INSTR für den gesamten übereinstimmenden Teil des Subjekts den Offset des Anfangs- oder Endzeichens zurück. Wenn jedoch der Parameter e (für „extrahieren“) angegeben ist, gibt REGEXP_INSTR den Offset des Anfangs- oder Endzeichens für den Teil des Subjekts zurück, der mit dem ersten Teilausdruck im Muster übereinstimmt. Wenn zwar e angegeben ist, aber kein Wert für group_num, dann ist der Wert von group_num standardmäßig 1 (die erste Gruppe). Wenn das Muster keinen Teilausdruck enthält, verhält sich REGEXP_INSTR so, als wäre e nicht gesetzt. Beispiele, die e verwenden, finden Sie im Abschnitt Beispiele (unter diesem Thema).

group_num

Der Parameter group_num gibt an, welche Gruppe extrahiert werden soll. Gruppen werden im regulären Ausdruck mithilfe von Klammern angegeben.

Wenn eine group_num angegeben ist, erlaubt Snowflake die Extraktion auch dann, wenn die Option e nicht mit angegeben wurde. Die Option e ist implizit.

Snowflake unterstützt bis zu 1.024 Gruppen.

Beispiele, die group_num verwenden, finden Sie unter Beispiele für Erfassungsgruppen in diesem Thema.

Rückgabewerte¶

Gibt einen Wert vom Typ NUMBER zurück.

Wenn keine Übereinstimmung gefunden wird, wird 0 zurückgegeben.

Nutzungshinweise¶

Positionen sind 1-basiert, nicht 0-basiert. Beispielsweise ist die Position des Buchstabens „M“ in „MAN“ 1 und nicht 0.
Weitere Hinweise zur Verwendung der Funktionen für reguläre Ausdrücke finden Sie unter Allgemeine Nutzungshinweise.

Sortierungsdetails¶

Arguments with collation specifications currently aren’t supported.

Beispiele¶

Die folgenden Beispiele verwenden die Funktion REGEXP_INSTR.

Grundlegende Beispiele¶

Erstellen Sie eine Tabelle, und fügen Sie Daten ein:

CREATE OR REPLACE TABLE demo1 (id INT, string1 VARCHAR);
INSERT INTO demo1 (id, string1) VALUES
  (1, 'nevermore1, nevermore2, nevermore3.');

Suchen Sie nach einer übereinstimmenden Zeichenfolge. In diesem Fall lautet die Zeichenfolge nevermore, gefolgt von einer einzelnen Dezimalzahl (z. B. nevermore1). Das Beispiel verwendet die Funktion REGEXP_SUBSTR, um die passende Teilzeichenkette anzuzeigen:

SELECT id,
       string1,
       REGEXP_SUBSTR(string1, 'nevermore\\d') AS substring,
       REGEXP_INSTR( string1, 'nevermore\\d') AS position
  FROM demo1
  ORDER BY id;

+----+-------------------------------------+------------+----------+
| ID | STRING1                             | SUBSTRING  | POSITION |
|----+-------------------------------------+------------+----------|
|  1 | nevermore1, nevermore2, nevermore3. | nevermore1 |        1 |
+----+-------------------------------------+------------+----------+

Suchen Sie nach einer übereinstimmenden Zeichenfolge, beginnen Sie jedoch mit dem 5. Zeichen der Zeichenfolge und nicht mit dem 1. Zeichen der Zeichenfolge:

SELECT id,
       string1,
       REGEXP_SUBSTR(string1, 'nevermore\\d', 5) AS substring,
       REGEXP_INSTR( string1, 'nevermore\\d', 5) AS position
  FROM demo1
  ORDER BY id;

+----+-------------------------------------+------------+----------+
| ID | STRING1                             | SUBSTRING  | POSITION |
|----+-------------------------------------+------------+----------|
|  1 | nevermore1, nevermore2, nevermore3. | nevermore2 |       13 |
+----+-------------------------------------+------------+----------+

Suchen Sie nach einer übereinstimmenden Zeichenfolge, aber suchen Sie nach der dritten Übereinstimmung und nicht nach der ersten Übereinstimmung:

SELECT id,
       string1,
       REGEXP_SUBSTR(string1, 'nevermore\\d', 1, 3) AS substring,
       REGEXP_INSTR( string1, 'nevermore\\d', 1, 3) AS position
  FROM demo1
  ORDER BY id;

+----+-------------------------------------+------------+----------+
| ID | STRING1                             | SUBSTRING  | POSITION |
|----+-------------------------------------+------------+----------|
|  1 | nevermore1, nevermore2, nevermore3. | nevermore3 |       25 |
+----+-------------------------------------+------------+----------+

Diese Abfrage ist fast identisch mit der vorherigen Abfrage, zeigt jedoch, wie Sie mit dem Argument option angeben, ob Sie die Position des übereinstimmenden Ausdrucks oder die Position des ersten Zeichens nach dem übereinstimmenden Ausdruck erhalten möchten:

SELECT id,
       string1,
       REGEXP_SUBSTR(string1, 'nevermore\\d', 1, 3) AS substring,
       REGEXP_INSTR( string1, 'nevermore\\d', 1, 3, 0) AS start_position,
       REGEXP_INSTR( string1, 'nevermore\\d', 1, 3, 1) AS after_position
  FROM demo1
  ORDER BY id;

+----+-------------------------------------+------------+----------------+----------------+
| ID | STRING1                             | SUBSTRING  | START_POSITION | AFTER_POSITION |
|----+-------------------------------------+------------+----------------+----------------|
|  1 | nevermore1, nevermore2, nevermore3. | nevermore3 |             25 |             35 |
+----+-------------------------------------+------------+----------------+----------------+

Diese Abfrage zeigt, dass bei der Suche nach einem Vorkommen, das über das letzte tatsächliche Vorkommen hinausgeht, die zurückgegebene Position 0 ist:

SELECT id,
       string1,
       REGEXP_SUBSTR(string1, 'nevermore', 1, 4) AS substring,
       REGEXP_INSTR( string1, 'nevermore', 1, 4) AS position
  FROM demo1
  ORDER BY id;

+----+-------------------------------------+-----------+----------+
| ID | STRING1                             | SUBSTRING | POSITION |
|----+-------------------------------------+-----------+----------|
|  1 | nevermore1, nevermore2, nevermore3. | NULL      |        0 |
+----+-------------------------------------+-----------+----------+

Beispiele für Erfassungsgruppen¶

In diesem Abschnitt erfahren Sie, wie Sie die „Gruppen“-Funktion von regulären Ausdrücken verwenden.

Die ersten Beispiele in diesem Abschnitt verwenden keine Erfassungsgruppen. Der Abschnitt beginnt mit einigen einfachen Beispielen und setzt sich dann mit Beispielen fort, die Erfassungsgruppen verwenden.

In den Beispielen werden die unten erstellten Zeichenfolgen verwendet:

CREATE OR REPLACE TABLE demo2 (id INT, string1 VARCHAR);

INSERT INTO demo2 (id, string1) VALUES
    (2, 'It was the best of times, it was the worst of times.'),
    (3, 'In    the   string   the   extra   spaces  are   redundant.'),
    (4, 'A thespian theater is nearby.');

SELECT * FROM demo2;

+----+-------------------------------------------------------------+
| ID | STRING1                                                     |
|----+-------------------------------------------------------------|
|  2 | It was the best of times, it was the worst of times.        |
|  3 | In    the   string   the   extra   spaces  are   redundant. |
|  4 | A thespian theater is nearby.                               |
+----+-------------------------------------------------------------+

Die Zeichenfolgen haben die folgenden Eigenschaften:

Die Zeichenfolge mit einer id von 2 hat mehrere Vorkommen des Wortes „the“.
Die Zeichenfolge mit einer id von 3 hat mehrere Vorkommen des Wortes „the“ mit zusätzlichen Leerzeichen zwischen den Wörtern.
Die Zeichenfolge mit einer id von 4 enthält die Zeichenfolge „the“ innerhalb mehrerer Wörter („thespian“ und „theater“), aber ohne das Wort „the“ selbst.

In diesem Beispiel wird nach dem ersten Vorkommen des Wortes the gesucht, gefolgt von einem oder mehreren Nicht-Wort-Zeichen (z. B. dem Leerzeichen, das Wörter trennt), gefolgt von einem oder mehreren Wort-Zeichen.

„Wortzeichen“ umfassen nicht nur die Buchstaben a–z und A–Z, sondern auch den Unterstrich („_“) und die Dezimalziffern 0–9, jedoch keine Leerzeichen, Satzzeichen und so weiter.

SELECT id,
       string1,
       REGEXP_SUBSTR(string1, 'the\\W+\\w+') AS substring,
       REGEXP_INSTR(string1, 'the\\W+\\w+') AS position
  FROM demo2
  ORDER BY id;

+----+-------------------------------------------------------------+--------------+----------+
| ID | STRING1                                                     | SUBSTRING    | POSITION |
|----+-------------------------------------------------------------+--------------+----------|
|  2 | It was the best of times, it was the worst of times.        | the best     |        8 |
|  3 | In    the   string   the   extra   spaces  are   redundant. | the   string |        7 |
|  4 | A thespian theater is nearby.                               | NULL         |        0 |
+----+-------------------------------------------------------------+--------------+----------+

Suchen Sie ab Position 1 der Zeichenfolge nach dem zweiten Vorkommen des Wortes the, gefolgt von einem oder mehreren Nicht-Wort-Zeichen, gefolgt von einem oder mehreren Wort-Zeichen.

SELECT id,
       string1,
       REGEXP_SUBSTR(string1, 'the\\W+\\w+', 1, 2) AS substring,
       REGEXP_INSTR(string1, 'the\\W+\\w+', 1, 2) AS position
  FROM demo2
  ORDER BY id;

+----+-------------------------------------------------------------+-------------+----------+
| ID | STRING1                                                     | SUBSTRING   | POSITION |
|----+-------------------------------------------------------------+-------------+----------|
|  2 | It was the best of times, it was the worst of times.        | the worst   |       34 |
|  3 | In    the   string   the   extra   spaces  are   redundant. | the   extra |       22 |
|  4 | A thespian theater is nearby.                               | NULL        |        0 |
+----+-------------------------------------------------------------+-------------+----------+

Dieses Beispiel ähnelt dem vorherigen Beispiel, fügt jedoch Erfassungsgruppen hinzu. Anstatt die Position der gesamten Übereinstimmung zurückzugeben, gibt diese Abfrage nur die Position der Gruppe zurück, (d. h. den Teil der Teilzeichenfolge, der mit dem Teil des regulären Ausdrucks in Klammern übereinstimmt). In diesem Fall ist der Rückgabewert die Position des Wortes nach dem zweiten Vorkommen des Wortes the.

SELECT id,
       string1,
       REGEXP_SUBSTR(string1, 'the\\W+(\\w+)', 1, 2,    'e', 1) AS substring,
       REGEXP_INSTR( string1, 'the\\W+(\\w+)', 1, 2, 0, 'e', 1) AS position
  FROM demo2
  ORDER BY id;

+----+-------------------------------------------------------------+-----------+----------+
| ID | STRING1                                                     | SUBSTRING | POSITION |
|----+-------------------------------------------------------------+-----------+----------|
|  2 | It was the best of times, it was the worst of times.        | worst     |       38 |
|  3 | In    the   string   the   extra   spaces  are   redundant. | extra     |       28 |
|  4 | A thespian theater is nearby.                               | NULL      |        0 |
+----+-------------------------------------------------------------+-----------+----------+

Wenn Sie den Parameter 'e' (Auszug) angeben, aber nicht group_num, dann ist group_num standardmäßig auf 1 festgelegt:

SELECT id,
       string1,
       REGEXP_SUBSTR(string1, 'the\\W+(\\w+)', 1, 2,    'e') AS substring,
       REGEXP_INSTR( string1, 'the\\W+(\\w+)', 1, 2, 0, 'e') AS position
  FROM demo2
  ORDER BY id;

+----+-------------------------------------------------------------+-----------+----------+
| ID | STRING1                                                     | SUBSTRING | POSITION |
|----+-------------------------------------------------------------+-----------+----------|
|  2 | It was the best of times, it was the worst of times.        | worst     |       38 |
|  3 | In    the   string   the   extra   spaces  are   redundant. | extra     |       28 |
|  4 | A thespian theater is nearby.                               | NULL      |        0 |
+----+-------------------------------------------------------------+-----------+----------+

Wenn Sie group_num angeben, geht Snowflake davon aus, dass Sie extrahieren möchten, auch wenn Sie 'e' (extrahieren) nicht als einen der Parameter angegeben haben:

SELECT id,
       string1,
       REGEXP_SUBSTR(string1, 'the\\W+(\\w+)', 1, 2,    '', 1) AS substring,
       REGEXP_INSTR( string1, 'the\\W+(\\w+)', 1, 2, 0, '', 1) AS position
  FROM demo2
  ORDER BY id;

+----+-------------------------------------------------------------+-----------+----------+
| ID | STRING1                                                     | SUBSTRING | POSITION |
|----+-------------------------------------------------------------+-----------+----------|
|  2 | It was the best of times, it was the worst of times.        | worst     |       38 |
|  3 | In    the   string   the   extra   spaces  are   redundant. | extra     |       28 |
|  4 | A thespian theater is nearby.                               | NULL      |        0 |
+----+-------------------------------------------------------------+-----------+----------+

In diesem Beispiel wird gezeigt, wie die Position des zweiten Wortes aus den ersten, zweiten und dritten Übereinstimmungen eines Zwei-Wort-Musters abgerufen wird, in dem das erste Wort A ist. Dies zeigt auch, dass Snowflake beim Versuch, über das letzte Muster hinauszugehen, 0 zurückgibt.

Erstellen Sie eine Tabelle, und fügen Sie Daten ein:

CREATE TABLE demo3 (id INT, string1 VARCHAR);
INSERT INTO demo3 (id, string1) VALUES
  (5, 'A MAN A PLAN A CANAL');

Führen Sie die Abfrage aus:

SELECT id,
       string1,
       REGEXP_SUBSTR(string1, 'A\\W+(\\w+)', 1, 1,    'e', 1) AS substring1,
       REGEXP_INSTR( string1, 'A\\W+(\\w+)', 1, 1, 0, 'e', 1) AS position1,
       REGEXP_SUBSTR(string1, 'A\\W+(\\w+)', 1, 2,    'e', 1) AS substring2,
       REGEXP_INSTR( string1, 'A\\W+(\\w+)', 1, 2, 0, 'e', 1) AS position2,
       REGEXP_SUBSTR(string1, 'A\\W+(\\w+)', 1, 3,    'e', 1) AS substring3,
       REGEXP_INSTR( string1, 'A\\W+(\\w+)', 1, 3, 0, 'e', 1) AS position3,
       REGEXP_SUBSTR(string1, 'A\\W+(\\w+)', 1, 4,    'e', 1) AS substring4,
       REGEXP_INSTR( string1, 'A\\W+(\\w+)', 1, 4, 0, 'e', 1) AS position4
  FROM demo3;

+----+----------------------+------------+-----------+------------+-----------+------------+-----------+------------+-----------+
| ID | STRING1              | SUBSTRING1 | POSITION1 | SUBSTRING2 | POSITION2 | SUBSTRING3 | POSITION3 | SUBSTRING4 | POSITION4 |
|----+----------------------+------------+-----------+------------+-----------+------------+-----------+------------+-----------|
|  5 | A MAN A PLAN A CANAL | MAN        |         3 | PLAN       |         9 | CANAL      |        16 | NULL       |         0 |
+----+----------------------+------------+-----------+------------+-----------+------------+-----------+------------+-----------+

Dieses Beispiel zeigt, wie die Position der ersten, zweiten und dritten Gruppe innerhalb des ersten Auftretens des Musters abgerufen wird. In diesem Fall sind die zurückgegebenen Werte die Positionen der einzelnen Buchstaben des Wortes MAN.

SELECT id,
       string1,
       REGEXP_SUBSTR(string1, 'A\\W+(\\w)(\\w)(\\w)', 1, 1,    'e', 1) AS substring1,
       REGEXP_INSTR( string1, 'A\\W+(\\w)(\\w)(\\w)', 1, 1, 0, 'e', 1) AS position1,
       REGEXP_SUBSTR(string1, 'A\\W+(\\w)(\\w)(\\w)', 1, 1,    'e', 2) AS substring2,
       REGEXP_INSTR( string1, 'A\\W+(\\w)(\\w)(\\w)', 1, 1, 0, 'e', 2) AS position2,
       REGEXP_SUBSTR(string1, 'A\\W+(\\w)(\\w)(\\w)', 1, 1,    'e', 3) AS substring3,
       REGEXP_INSTR( string1, 'A\\W+(\\w)(\\w)(\\w)', 1, 1, 0, 'e', 3) AS position3
  FROM demo3;

+----+----------------------+------------+-----------+------------+-----------+------------+-----------+
| ID | STRING1              | SUBSTRING1 | POSITION1 | SUBSTRING2 | POSITION2 | SUBSTRING3 | POSITION3 |
|----+----------------------+------------+-----------+------------+-----------+------------+-----------|
|  5 | A MAN A PLAN A CANAL | M          |         3 | A          |         4 | N          |         5 |
+----+----------------------+------------+-----------+------------+-----------+------------+-----------+

Zusätzliche Beispiele¶

Im folgenden Beispiel werden Vorkommen des Worts was abgeglichen. Der Abgleich beginnt beim ersten Zeichen in der Zeichenfolge und gibt die Position des Zeichens in der Zeichenfolge zurück, das auf das erste Vorkommen folgt:

SELECT REGEXP_INSTR('It was the best of times, it was the worst of times',
                    '\\bwas\\b',
                    1,
                    1) AS result;

+--------+
| RESULT |
|--------|
|      4 |
+--------+

Im folgenden Beispiel wird der Offset des ersten Zeichens des Teils der Zeichenfolge zurückgegeben, der mit dem Muster übereinstimmt. Der Abgleich beginnt beim ersten Zeichen in der Zeichenfolge und gibt das erste Vorkommen des Musters zurück:

SELECT REGEXP_INSTR('It was the best of times, it was the worst of times',
                    'the\\W+(\\w+)',
                    1,
                    1,
                    0) AS result;

+--------+
| RESULT |
|--------|
|      8 |
+--------+

Das folgende Beispiel ist dasselbe wie das vorherige Beispiel, verwendet jedoch den Parameter e, um den Zeichenoffset für den Teil des Subjekts zurückzugeben, der mit dem ersten Unterausdruck des Musters übereinstimmt (die erste Menge von Wortzeichen nach the):

SELECT REGEXP_INSTR('It was the best of times, it was the worst of times',
                    'the\\W+(\\w+)',
                    1,
                    1,
                    0,
                    'e') AS result;

+--------+
| RESULT |
|--------|
|     12 |
+--------+

Das folgende Beispiel findet Vorkommen von Wörtern, die auf st enden und denen zwei oder mehr alphabetische Zeichen vorausgehen (Groß- und Kleinschreibung wird nicht berücksichtigt). Der Abgleich beginnt beim 15. Zeichen in der Zeichenfolge und gibt die Position des Zeichens in der Zeichenfolge nach dem ersten Auftraten zurück (den Anfang von worst):

SELECT REGEXP_INSTR('It was the best of times, it was the worst of times',
                    '[[:alpha:]]{2,}st',
                    15,
                    1) AS result;

+--------+
| RESULT |
|--------|
|     38 |
+--------+

Um die nächsten Beispiele auszuführen, erstellen Sie eine Tabelle und fügen Sie Daten ein:

CREATE OR REPLACE TABLE message(body VARCHAR(255));
INSERT INTO message VALUES
  ('Hellooo World'),
  ('How are you doing today?'),
  ('the quick brown fox jumps over the lazy dog'),
  ('PACK MY BOX WITH FIVE DOZEN LIQUOR JUGS');

Gibt den Offset des ersten Zeichens im ersten Treffer zurück, das einen Kleinbuchstaben enthält o:

SELECT body,
       REGEXP_INSTR(body, '\\b\\S*o\\S*\\b') AS result
  FROM message;

+---------------------------------------------+--------+
| BODY                                        | RESULT |
|---------------------------------------------+--------|
| Hellooo World                               |      1 |
| How are you doing today?                    |      1 |
| the quick brown fox jumps over the lazy dog |     11 |
| PACK MY BOX WITH FIVE DOZEN LIQUOR JUGS     |      0 |
+---------------------------------------------+--------+

Gibt den Offset des ersten Zeichens im ersten Treffer zurück, das einen Kleinbuchstaben o enthält, beginnend mit dem dritten Zeichen im Subjekt:

SELECT body,
       REGEXP_INSTR(body, '\\b\\S*o\\S*\\b', 3) AS result
  FROM message;

+---------------------------------------------+--------+
| BODY                                        | RESULT |
|---------------------------------------------+--------|
| Hellooo World                               |      3 |
| How are you doing today?                    |      9 |
| the quick brown fox jumps over the lazy dog |     11 |
| PACK MY BOX WITH FIVE DOZEN LIQUOR JUGS     |      0 |
+---------------------------------------------+--------+

Gibt den Offset des ersten Zeichens in der dritten Übereinstimmung zurück, das einen Kleinbuchstaben o enthält, beginnend mit dem dritten Zeichen im Subjekt:

SELECT body, REGEXP_INSTR(body, '\\b\\S*o\\S*\\b', 3, 3) AS result
  FROM message;

+---------------------------------------------+--------+
| BODY                                        | RESULT |
|---------------------------------------------+--------|
| Hellooo World                               |      0 |
| How are you doing today?                    |     19 |
| the quick brown fox jumps over the lazy dog |     27 |
| PACK MY BOX WITH FIVE DOZEN LIQUOR JUGS     |      0 |
+---------------------------------------------+--------+

Gibt den Offset des letzten Zeichens in der dritten Übereinstimmung zurück, das einen Kleinbuchstaben o enthält, beginnend mit dem dritten Zeichen im Subjekt:

SELECT body, REGEXP_INSTR(body, '\\b\\S*o\\S*\\b', 3, 3, 1) AS result
  FROM message;

+---------------------------------------------+--------+
| BODY                                        | RESULT |
|---------------------------------------------+--------|
| Hellooo World                               |      0 |
| How are you doing today?                    |     24 |
| the quick brown fox jumps over the lazy dog |     31 |
| PACK MY BOX WITH FIVE DOZEN LIQUOR JUGS     |      0 |
+---------------------------------------------+--------+

Gibt den Offset des letzten Zeichens in der dritten Übereinstimmung zurück, das ein klein geschriebenes o enthält, beginnend mit dem dritten Zeichen im Subjekt, Übereinstimmung ohne Berücksichtigung der Groß-/Kleinschreibung:

SELECT body, REGEXP_INSTR(body, '\\b\\S*o\\S*\\b', 3, 3, 1, 'i') AS result
  FROM message;

+---------------------------------------------+--------+
| BODY                                        | RESULT |
|---------------------------------------------+--------|
| Hellooo World                               |      0 |
| How are you doing today?                    |     24 |
| the quick brown fox jumps over the lazy dog |     31 |
| PACK MY BOX WITH FIVE DOZEN LIQUOR JUGS     |     35 |
+---------------------------------------------+--------+