Finden Sie eine Zahl mit Oracle regexp, der hat eine genaue Länge von 3

Mir nicht ganz klar, ob Sie exakte übereinstimmungen oder sub-string übereinstimmt, so habe ich verschiedene Optionen:

SQL Fiddle

Oracle 11g R2-Schema-Setup:

CREATE TABLE MY_TABLE (MY_COLUMN) AS
          SELECT '456' FROM DUAL
UNION ALL SELECT '12345678' FROM DUAL
UNION ALL SELECT 'abc 123 def 456' FROM DUAL;

Abfrage 1:

Wenn Sie möchten, dass nur Zeilen, in denen MY_COLUMN enthält genau eine 3-stellige Nummer, dann können Sie einfach Ihre regelmäßigen Ausdruck eingewickelt in den start-string (^) und Ende-string ($) Anker:

    SELECT MY_COLUMN
    FROM   MY_TABLE
    WHERE  REGEXP_LIKE( MY_COLUMN, '^[[:digit:]]{3}$' )

Ergebnisse:

| MY_COLUMN |
|-----------|
|       456 |

Abfrage 2:

Oder, wenn Sie mit Oracle 11g-dann können Sie die weniger ausführlich, die PERL-syntax:

    SELECT MY_COLUMN
    FROM   MY_TABLE
    WHERE  REGEXP_LIKE( MY_COLUMN, '^\d{3}$' )

Ergebnisse:

| MY_COLUMN |
|-----------|
|       456 |

Abfrage 3:

Wenn Sie möchten, zu extrahieren, die die erste 3-stellige Zahl aus der Spalte (wo kann es umgebenden text oder mehrere Ziffern), dann:

    SELECT MY_COLUMN,
           REGEXP_INSTR( MY_COLUMN, '\d{3}' ), 
           REGEXP_SUBSTR( MY_COLUMN, '\d{3}' )
    FROM   MY_TABLE
    WHERE  REGEXP_LIKE( MY_COLUMN, '\d{3}' )

Ergebnisse:

|       MY_COLUMN | REGEXP_INSTR(MY_COLUMN,'\D{3}') | REGEXP_SUBSTR(MY_COLUMN,'\D{3}') |
|----------------- | --------------------------------- | ----------------------------------|
|             456 |                               1 |                              456 |
|        12345678 |                               1 |                              123 |
| abc 123 def 456 |                               5 |                              123 |

Abfrage-4:

Wenn Sie möchten, zu extrahieren, die der ersten genau 3-stellige Zahl aus der Spalte dann:

    SELECT MY_COLUMN,
           REGEXP_SUBSTR( REGEXP_SUBSTR( MY_COLUMN, '(^|\D)\d{3}(\D|$)' ), '\d{3}' ) AS match
    FROM   MY_TABLE
    WHERE  REGEXP_LIKE( MY_COLUMN, '(^|\D)\d{3}(\D|$)' )

Ergebnisse:

|       MY_COLUMN | MATCH |
|----------------- | -------|
|             456 |   456 |
| abc 123 def 456 |   123 |

Abfrage 5:

Wenn Sie möchten, zu extrahieren alle nicht-überlappende 3-stellige zahlen aus der Spalte (wo kann es umgebenden text), dann:

    WITH re_counts AS (
      SELECT MY_COLUMN,
             REGEXP_COUNT( MY_COLUMN, '\d{3}' ) AS re_count
      FROM   MY_TABLE
    )
    ,indexes AS (
      SELECT LEVEL AS "index"
      FROM   DUAL
      CONNECT BY LEVEL <= (SELECT MAX( re_count)  FROM re_counts)
    )
    SELECT MY_COLUMN,
           "index", 
           REGEXP_SUBSTR( MY_COLUMN, '\d{3}', 1, "index" )
    FROM   re_counts
           INNER JOIN
           indexes
           ON ("index" <= re_count)
    ORDER BY MY_COLUMN, "index"

Ergebnisse:

|       MY_COLUMN | INDEX | REGEXP_SUBSTR(MY_COLUMN,'\D{3}',1,"INDEX") |
|----------------- | ------- | --------------------------------------------|
|        12345678 |     1 |                                        123 |
|        12345678 |     2 |                                        456 |
|             456 |     1 |                                        456 |
| abc 123 def 456 |     1 |                                        123 |
| abc 123 def 456 |     2 |                                        456 |

Abfrage-6:

Wenn Sie möchten, zu extrahieren alle der sub-Spiele, die sind genau 3-stellige zahlen dann:

    WITH re_counts AS (
      SELECT MY_COLUMN,
             REGEXP_COUNT( MY_COLUMN, '(^|\D)\d{3}(\D|$)' ) AS re_count
      FROM   MY_TABLE
    )
    ,indexes AS (
      SELECT LEVEL AS "index"
      FROM   DUAL
      CONNECT BY LEVEL <= (SELECT MAX( re_count)  FROM re_counts)
    )
    SELECT MY_COLUMN,
           "index", 
           REGEXP_SUBSTR( REGEXP_SUBSTR( MY_COLUMN, '(^|\D)\d{3}(\D|$)', 1, "index" ), '\d{3}' ) AS match
    FROM   re_counts
           INNER JOIN
           indexes
           ON ("index" <= re_count)
    ORDER BY MY_COLUMN, "index"

Ergebnisse:

|       MY_COLUMN | INDEX | MATCH |
|----------------- | ------- | -------|
|             456 |     1 |   456 |
| abc 123 def 456 |     1 |   123 |
| abc 123 def 456 |     2 |   456 |

Abfrage 7:

Wenn Sie möchten, extrahieren Sie alle 3-stelligen zahlen, die aus einer Spalte, unabhängig davon, ob die Spiele teilweise überlappen oder nicht, dann:

    WITH positions AS (
      SELECT LEVEL AS pos
      FROM   DUAL
      CONNECT BY LEVEL <= (SELECT MAX( LENGTH( MY_COLUMN ) - 2 )  FROM MY_TABLE )
    )
    SELECT MY_COLUMN,
           pos, 
           SUBSTR( MY_COLUMN, pos, 3 )
    FROM   MY_TABLE
           INNER JOIN
           positions
           ON (pos <= LENGTH( MY_COLUMN ) - 2 )
    WHERE  REGEXP_LIKE( SUBSTR( MY_COLUMN, pos, 3 ), '^\d{3}$' )
    ORDER BY MY_COLUMN, pos

Ergebnisse:

|       MY_COLUMN | POS | SUBSTR(MY_COLUMN,POS,3) |
|----------------- | ----- | -------------------------|
|        12345678 |   1 |                     123 |
|        12345678 |   2 |                     234 |
|        12345678 |   3 |                     345 |
|        12345678 |   4 |                     456 |
|        12345678 |   5 |                     567 |
|        12345678 |   6 |                     678 |
|             456 |   1 |                     456 |
| abc 123 def 456 |   5 |                     123 |
| abc 123 def 456 |  13 |                     456 |

Können Sie dieses Muster:

(^|[^[:digit:]])([[:digit:]]{3})($|[^[:digit:]])

wo [^[:digit:]] ist all das ist keine Zahl und ^, $ sind Anfang und Ende der Zeichenfolge Anker.